Author Schema Markup: Article and Person JSON-LD (2026)
Author schema markup lets search and AI engines verify who wrote what: Article, BlogPosting and Person JSON-LD with sameAs links and a copy-paste template.
Kazi Khalid Hasan Tamim · BugViso Team
16 min read
Author schema markup tells search engines who wrote a page. In Article or BlogPosting JSON-LD, connect it to a Person node for the author and an Organization node for the publisher.
Add sameAs links to the author's real profiles, and keep datePublished and dateModified accurate.
Markup supports E-E-A-T signals but does not prove expertise on its own.
┌─────────────────────────────────────────────────────────────────────────────┐
│ E-E-A-T KNOWLEDGE GRAPH ENTITY ARCHITECTURE │
├─────────────────────────────────────────────────────────────────────────────┤
│ TechArticle / BlogPosting (Root Content Entity) │
│ ├── headline, description, image, datePublished, dateModified │
│ ├── author (Person Entity) │
│ │ ├── name, jobTitle, worksFor, alumniOf, description │
│ │ └── sameAs [Wikidata, LinkedIn, ORCID, Twitter/X, GitHub] │
│ └── publisher (Organization Entity) │
│ ├── name, url, logo (ImageObject) │
│ └── publishingPrinciples, ethicsPolicy, correctionsPolicy │
└─────────────────────────────────────────────────────────────────────────────┘When Googlebot and generative AI crawlers (like GPTBot and PerplexityBot) parse a technical publication, they extract these structured entity triples. Connecting the author's digital footprint directly to external authority sources elevates the document's authority score, protecting organic impressions during core search algorithm updates.
1. How Search Engines and AI Ingest Author Entities
Author markup gives a parser structured facts to work with instead of a name in a byline. In outline, a parser can do this with it (Google does not publish its exact pipeline):
Author Entity Resolution Pipeline
| Step | What the parser does |
|---|---|
| 1. Schema extraction | Parses the JSON-LD script block for the Person entity |
| 2. URI disambiguation | Follows sameAs links to Wikidata and other authoritative profiles |
| 3. Knowledge Graph join | Binds the author to an existing Knowledge Graph node ID |
| 4. Topic association | Relates the author to the topics they write about |
1. Entity Disambiguation via sameAs Links
An author named "David Miller" or "Sarah Chen" is linguistically ambiguous. Without structured entity markers, search engines cannot determine whether the author is an enterprise systems engineer, a medical researcher, or a junior copywriter.
The sameAs array resolves this ambiguity by pointing to authoritative third-party URIs:
- Wikidata Entity URI: (e.g.,
https://www.wikidata.org/wiki/Q...) — The ultimate machine-readable knowledge base. - Academic & Industry Repositories: ORCID IDs for scientists, GitHub profiles for software engineers, IEEE author profiles.
- Verified Professional Profiles: LinkedIn, verified personal domains, and professional social profiles.
When search crawlers follow these outbound entity references, they attach the document to an existing verified entity in Google's Knowledge Graph, transferring established historical authority directly to the published article.
For deeper insight into how AI crawlers weight external trust markers, review our guide on E-E-A-T signals that AI search engines recognize.
2. Temporal Freshness via ISO 8601 Timestamps
Accurate dates matter to readers and to parsers alike. Google's Article documentation asks for ISO 8601 dates in datePublished and dateModified:
datePublished:2026-09-22T08:00:00+00:00dateModified:2026-09-22T14:30:00+00:00
If an article updates significant technical guidance, omitting dateModified in the JSON-LD script prevents search engines from recognizing the revision. Conversely, updating dateModified without making genuine textual changes in the visible DOM violates Google's deceptive content guidelines.
2. Author Schema Markup: Article JSON-LD With Nested Author & Publisher
The following production template demonstrates an enterprise-grade TechArticle implementation that interlinks the content piece, the author's professional credentials, and the publishing organization using an integrated @graph structure:
<script type="application/ld+json">
{
"@context": "https://schema.org",
"@graph": [
{
"@type": "Organization",
"@id": "https://example.com/#organization",
"name": "Apex Engineering Institute",
"url": "https://example.com",
"logo": {
"@type": "ImageObject",
"@id": "https://example.com/#logo",
"url": "https://example.com/assets/logo.png",
"caption": "Apex Engineering Official Logo",
"width": 600,
"height": 60
},
"sameAs": [
"https://www.linkedin.com/company/apex-engineering",
"https://github.com/apex-engineering",
"https://twitter.com/apex_eng"
],
"publishingPrinciples": "https://example.com/editorial-standards",
"correctionsPolicy": "https://example.com/corrections-policy"
},
{
"@type": "Person",
"@id": "https://example.com/authors/jane-doe/#author",
"name": "Jane Doe",
"url": "https://example.com/authors/jane-doe",
"image": "https://example.com/assets/authors/jane-doe.jpg",
"jobTitle": "Lead Systems Architect & Technical SEO Engineer",
"description": "Specialist in distributed backend systems, web performance engineering, and Generative Engine Optimization (GEO).",
"worksFor": {
"@id": "https://example.com/#organization"
},
"sameAs": [
"https://www.linkedin.com/in/janedoe",
"https://github.com/janedoe",
"https://orcid.org/0009-0001-2345-6789",
"https://twitter.com/janedoe"
],
"knowsAbout": [
"Web Performance Optimization",
"Core Web Vitals",
"Search Engine Architecture",
"Next.js SSR Hydration",
"Structured Data Standards"
]
},
{
"@type": "TechArticle",
"@id": "https://example.com/blog/article-author-person-schema-eeat/#article",
"isPartOf": {
"@type": "WebSite",
"@id": "https://example.com/#website",
"name": "Apex Engineering Technical Blog",
"url": "https://example.com/blog"
},
"headline": "Article & Author Person Schema: Building E-E-A-T in Code (2026)",
"description": "Comprehensive engineering guide to structuring Article and BlogPosting schema with nested Person nodes and sameAs credentials for maximum E-E-A-T authority.",
"inLanguage": "en-US",
"mainEntityOfPage": "https://example.com/blog/article-author-person-schema-eeat",
"datePublished": "2026-09-22T08:00:00+00:00",
"dateModified": "2026-09-22T11:00:00+00:00",
"image": [
"https://example.com/assets/blog/eeat-schema-hero-16x9.jpg",
"https://example.com/assets/blog/eeat-schema-hero-4x3.jpg"
],
"author": {
"@id": "https://example.com/authors/jane-doe/#author"
},
"publisher": {
"@id": "https://example.com/#organization"
},
"proficiencyLevel": "Expert",
"dependencies": "TypeScript 5.x, Next.js 15, Schema.org v26+"
}
]
}
</script>3. Dynamic Next.js 15 Implementation with TypeScript
In modern Headless CMS architectures, author profiles and publication timestamps are fetched dynamically from GraphQL or REST endpoints. The Next.js 15 React component below demonstrates how to construct and inject this schema server-side:
// components/seo/ArticleSchema.tsx
import React from 'react';
export interface AuthorEntity {
name: string;
slug: string;
title: string;
bio: string;
avatarUrl: string;
socialUrls: string[];
knowsAbout?: string[];
}
export interface ArticleSchemaProps {
article: {
title: string;
description: string;
canonicalUrl: string;
publishedAt: string;
modifiedAt: string;
heroImages: string[];
author: AuthorEntity;
organizationName: string;
organizationLogo: string;
organizationUrl: string;
};
}
export function ArticleSchema({ article }: ArticleSchemaProps) {
const authorId = `${article.organizationUrl}/authors/${article.author.slug}/#author`;
const orgId = `${article.organizationUrl}/#organization`;
const articleId = `${article.canonicalUrl}/#article`;
const schema = {
'@context': 'https://schema.org',
'@graph': [
{
'@type': 'Organization',
'@id': orgId,
name: article.organizationName,
url: article.organizationUrl,
logo: {
'@type': 'ImageObject',
url: article.organizationLogo
}
},
{
'@type': 'Person',
'@id': authorId,
name: article.author.name,
url: `${article.organizationUrl}/authors/${article.author.slug}`,
image: article.author.avatarUrl,
jobTitle: article.author.title,
description: article.author.bio,
sameAs: article.author.socialUrls,
worksFor: {
'@id': orgId
},
knowsAbout: article.author.knowsAbout || []
},
{
'@type': 'BlogPosting',
'@id': articleId,
mainEntityOfPage: article.canonicalUrl,
headline: article.title,
description: article.description,
image: article.heroImages,
datePublished: article.publishedAt,
dateModified: article.modifiedAt,
author: {
'@id': authorId
},
publisher: {
'@id': orgId
}
}
]
};
return (
<script
type="application/ld+json"
dangerouslySetInnerHTML={{ __html: JSON.stringify(schema) }}
/>
);
}This modular structure allows your application to maintain a single source of truth for author credentials across thousands of published posts without hardcoding duplicate strings.
4. Advanced Entity Verification: reviewedBy & Academic Citations
For YMYL (Your Money or Your Life) niches—such as cybersecurity, financial technology, healthcare, and legal infrastructure—Google requires an additional layer of editorial verification: expert peer review.
The reviewedBy Protocol
In high-stakes technical publications, having an article reviewed by an independent credentialed authority significantly strengthens the document's E-E-A-T scoring. Schema.org provides the native reviewedBy property on CreativeWork and its subclasses:
{
"@type": "TechArticle",
"headline": "Zero-Trust Architecture: Hardening Edge Microservices",
"author": {
"@type": "Person",
"name": "Marcus Vance",
"jobTitle": "DevOps Engineer"
},
"reviewedBy": {
"@type": "Person",
"@id": "https://example.com/authors/dr-elena-rostova/#reviewer",
"name": "Dr. Elena Rostova, Ph.D.",
"jobTitle": "Principal Security Researcher & Cryptographer",
"worksFor": {
"@type": "Organization",
"name": "Cyber Defense Institute"
},
"sameAs": [
"https://orcid.org/0000-0002-1825-0097",
"https://scholar.google.com/citations?user=sample"
]
},
"citation": [
{
"@type": "ScholarlyArticle",
"name": "Cryptographic Protocols in Distributed Ledger Verification",
"url": "https://doi.org/10.1145/sample-doi"
}
]
}By linking both an author and a verified reviewedBy expert with distinct sameAs entity identifiers, the page supplies unambiguous structural proof of rigorous editorial oversight.
5. Article vs BlogPosting vs NewsArticle vs TechArticle
Choosing the correct subclass of CreativeWork is essential for setting clear semantic context:
| Schema.org Entity Type | Best Use Case | Expected Rich Result / SERP Feature | Key Unique Properties |
|---|---|---|---|
TechArticle | Technical tutorials, API docs, engineering writeups | High relevance in technical search & AI search engines | dependencies, proficiencyLevel |
BlogPosting | General company blog posts, founder updates, marketing insights | Standard SERP snippet with thumbnail and byline | Lightweight, standard article attributes |
NewsArticle | Timely journalism, breaking news, press reports | Google News feed, Top Stories carousel, Google Discover | dateline, printEdition, printSection |
Article | Broad editorial content, long-form essays | Standard visual article enhancements | Generic base type for all written work |
For technical SaaS and developer-focused websites, utilizing TechArticle provides search engines with explicit domain hints (proficiencyLevel: "Expert"), signalling high-value educational content.
5. Python Automation: E-E-A-T Schema Validator Script
To ensure your production blog posts satisfy all Google E-E-A-T criteria, you can execute this automated Python audit script. It parses the live HTML, checks for author disambiguation properties, verifies ISO 8601 formatting, and ensures dateModified exists:
# scripts/audit_eeat_schema.py
import sys
import json
import datetime
import httpx
from bs4 import BeautifulSoup
def validate_iso_date(date_str: str) -> bool:
try:
datetime.datetime.fromisoformat(date_str.replace("Z", "+00:00"))
return True
except (ValueError, TypeError):
return False
def audit_article_eeat(url: str):
print(f"[*] Auditing E-E-A-T Schema on: {url}")
headers = {"User-Agent": "BugVisoEEATValidator/1.0 (+https://bugviso.com)"}
try:
res = httpx.get(url, headers=headers, timeout=12.0, follow_redirects=True)
except Exception as e:
print(f"[X] Network request failed: {e}")
return False
soup = BeautifulSoup(res.text, "html.parser")
scripts = soup.find_all("script", type="application/ld+json")
if not scripts:
print("[X] Critical: No application/ld+json script tags found on page.")
return False
article_found = False
author_verified = False
for script in scripts:
if not script.string:
continue
try:
data = json.loads(script.string)
except json.JSONDecodeError:
print("[X] Syntax Error: Invalid JSON-LD detected.")
continue
nodes = data.get("@graph", [data]) if isinstance(data, dict) else data
# Index all Person nodes by @id for reference lookup
person_map = {node.get("@id"): node for node in nodes if node.get("@type") == "Person"}
for node in nodes:
ntype = node.get("@type")
if ntype in ["Article", "BlogPosting", "TechArticle", "NewsArticle"]:
article_found = True
print(f"[✓] Found content entity of type: '{ntype}'")
# Check Dates
pub = node.get("datePublished")
mod = node.get("dateModified")
if not pub or not validate_iso_date(pub):
print(f"[X] Missing or invalid datePublished: '{pub}'")
else:
print(f" - datePublished: {pub} [VALID]")
if not mod or not validate_iso_date(mod):
print(f"[!] Warning: Missing or invalid dateModified: '{mod}'")
else:
print(f" - dateModified: {mod} [VALID]")
# Inspect Author
author_ref = node.get("author")
author_node = None
if isinstance(author_ref, dict):
if "@id" in author_ref and author_ref["@id"] in person_map:
author_node = person_map[author_ref["@id"]]
else:
author_node = author_ref
elif isinstance(author_ref, list) and len(author_ref) > 0:
first = author_ref[0]
author_node = person_map.get(first.get("@id")) if "@id" in first else first
if author_node:
author_verified = True
name = author_node.get("name", "Unknown")
job = author_node.get("jobTitle", "None")
same_as = author_node.get("sameAs", [])
print(f"[✓] Verified Author Entity: '{name}'")
print(f" - Job Title: {job}")
print(f" - Outbound sameAs authority links count: {len(same_as)}")
if not same_as:
print(" [!] E-E-A-T Deficiency: Author has zero 'sameAs' authority links declared.")
else:
for link in same_as:
print(f" -> {link}")
else:
print("[X] Critical: Article does not link to a valid Person author node!")
if not article_found:
print("[X] Failure: No valid Article or BlogPosting entity found.")
return False
return article_found and author_verified
if __name__ == "__main__":
target = sys.argv[1] if len(sys.argv) > 1 else "https://example.com/blog/sample-post"
audit_article_eeat(target)6. How BugViso Checks Author Schema
A BugViso scan parses the JSON-LD on every crawled page and validates it against Schema.org, so a missing or malformed Article, Person or Organization node shows up in the report.
It does not compare the structured author name with the visible byline or judge author credentials, so use the Python validator above for those checks.
You sign in to run a scan, then pay $1.49 per full branded PDF report or use a monthly plan. The technical SEO audit page lists the checks.
7. Common Implementation Traps & Edge Cases
Avoid these frequent mistakes when deploying author structured data:
1. Declaring Author as a Simple String
A pervasive legacy error is passing the author's name as a primitive string instead of an entity object:
// ❌ Anti-Pattern: Primitive string provides zero E-E-A-T entity context
{
"@context": "https://schema.org",
"@type": "BlogPosting",
"headline": "Scaling Cloud Microservices",
"author": "Jane Doe"
}// ✅ Optimized Pattern: Rich Person object with knowledge graph hooks
{
"@context": "https://schema.org",
"@type": "BlogPosting",
"headline": "Scaling Cloud Microservices",
"author": {
"@type": "Person",
"name": "Jane Doe",
"jobTitle": "Lead Systems Architect",
"sameAs": ["https://www.linkedin.com/in/janedoe", "https://github.com/janedoe"]
}
}2. Fabricating dateModified on Minor CSS or Layout Tweaks
Updating the dateModified property in your JSON-LD script whenever a site-wide navigation bar or CSS asset changes is considered deceptive manipulation by Google's webspam team. Only update dateModified when the core article body text, factual data, or code examples have undergone material editorial revisions.
For more technical fundamentals on structured data formatting, review how to add schema markup, and the JSON-LD template library for a ready-made Person and Article block.
8. Frequently Asked Questions
What is the difference between Article and BlogPosting?
Article is the broad parent type for all written text content. BlogPosting is a specialized subclass representing posts in a blog or magazine feed. Google's Article documentation treats them alike, and TechArticle is a further subtype for technical guides.
Why are sameAs links so critical for E-E-A-T?
Search engines use sameAs links to connect your local page's author node to authoritative external entities in Wikidata, Wikipedia, LinkedIn, or academic directories. This helps a parser tell your author apart from others with the same name. It does not transfer authority to your page.
Can an article have multiple co-authors in JSON-LD?
Yes. The author property can accept an array of Person objects: "author": [{ "@type": "Person", "name": "Author 1" }, { "@type": "Person", "name": "Author 2" }]. Check Google's Article documentation for how bylines are used.
Does author schema directly improve rankings?
No. Schema markup is not a direct ranking factor, and markup alone does not prove expertise. Author schema makes the author machine-readable; the credibility itself comes from the visible byline, author page and the content.
How does author schema impact AI answer engines like ChatGPT and Perplexity?
AI engines have not published how they use author markup. It states who wrote the page and links to real profiles, which can help attribution, but we have no evidence it raises citation rates. See schema markup for AI search.
9. Conclusion
Implementing Article or BlogPosting schema with a Person author translates editorial credibility into explicit machine-readable code.
By building connected entity graphs with nested author nodes, verified sameAs authority references, and accurate ISO 8601 publication timestamps, your articles are attributed correctly to real authors. An automated BugViso scan checks the JSON-LD on every published article.
Written by
Kazi Khalid Hasan Tamim · BugViso Team
Kazi writes BugViso’s guides on website audits, Core Web Vitals, technical SEO, accessibility and AI search. The data in them comes from audits BugViso runs in a real Chromium browser, including our 219-site study of website health.
Summarise with AI
Open this guide in your assistant.
Follow BugViso
New guides and audit data as we publish them.
AI visibility tracker
Is your brand in AI answers?
See how often AI assistants mention you, cite your site and rank you against your competitors.
- ChatGPT
- Gemini
- Perplexity
- Claude
- AI Overviews
See where your site stands
Run a free BugViso audit for SEO, speed, accessibility and AI search readiness — with fixes you can ship today.