Article & Author Person Schema: Building E-E-A-T in Code (2026)
Master Article BlogPosting Author Person schema EEAT in 2026. Learn nested Person nodes, sameAs authority links, ISO timestamps, and publisher schemas.
To establish machine-verifiable Experience, Expertise, Authoritativeness, and Trustworthiness (E-E-A-T), modern publishers and enterprise engineering teams must implement robust Article or BlogPosting structured data integrated with deeply connected Person and Organization nodes. Search algorithms and generative AI answer engines no longer rely solely on visible bylines; they parse explicit JSON-LD entity graphs to cross-reference author identities across global knowledge bases.
Google's Search Quality Rater Guidelines emphasize that content creators must have demonstrable real-world expertise, particularly for Your Money or Your Life (YMYL) topics. By nesting a rich Person entity containing verified sameAs citations (Wikidata, LinkedIn, ORCID, GitHub) and strict ISO 8601 timestamps (datePublished, dateModified), you provide search engines with unambiguous cryptographic proof of authorship and editorial rigor.
┌─────────────────────────────────────────────────────────────────────────────┐
│ 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
Search engines map authors using an entity extraction pipeline rather than simple keyword matching:
┌─────────────────────────────────────────────────────────────────────────────┐
│ AUTHOR ENTITY RESOLUTION PIPELINE │
├─────────────────────────────────────────────────────────────────────────────┤
│ 1. Schema Extraction │ Parse JSON-LD script block for Person entity │
│ 2. URI Disambiguation │ Follow sameAs links to Wikidata & authoritative │
│ 3. Knowledge Graph Join │ Bind author to existing Knowledge Graph Node ID │
│ 4. Topical Weighting │ Calculate author expertise score for topic │
└─────────────────────────────────────────────────────────────────────────────┘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
Both traditional ranking systems and generative answer engines heavily prioritize content freshness. Google mandates exact ISO 8601 formatting for publication and modification dates:
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. Complete Production JSON-LD Blueprint: Article 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/kazi-khalid/#author",
"name": "Kazi Khalid",
"url": "https://example.com/authors/kazi-khalid",
"image": "https://example.com/assets/authors/kazi-khalid.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/kazikhalid",
"https://github.com/kazikhalid757",
"https://orcid.org/0009-0001-2345-6789",
"https://twitter.com/kazikhalid"
],
"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/kazi-khalid/#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 Audits E-E-A-T & Author Schemas Automatically
Manually inspecting author credentials and timestamp validity across an editorial library of hundreds of posts is impractical. BugViso's AI Search Readiness (GEO) Engine and Advanced SEO Intelligence Engine automate author entity validation across every crawl.
┌─────────────────────────────────────────────────────────────────────────────┐
│ BUGVISO E-E-A-T SCHEMA VALIDATION SUITE │
├─────────────────────────────────────────────────────────────────────────────┤
│ 1. Entity Disambiguation Check │ Audits presence of Person sameAs URIs │
│ 2. Timestamp Freshness Engine │ Validates ISO 8601 published/modified dates │
│ 3. Knowledge Graph Connectivity│ Verifies @graph circular references and @id│
│ 4. Visible DOM Parity │ Matches JSON-LD author to visible byline │
└─────────────────────────────────────────────────────────────────────────────┘When you launch an automated crawl with BugViso:
- Author Authority & E-E-A-T Scoring: BugViso inspects the nested
authornode on every blog post, checking for job titles, corporate affiliations (worksFor), and outbound trust credentials (sameAs). Posts lacking author credentials receive a degraded GEO score. - Timestamp Integrity Checks: The crawler verifies that
datePublishedanddateModifieduse valid UTC ISO 8601 timestamps and flags instances wheredateModifiedis older thandatePublished. - Byline Data Parity: Headless Chromium compares the structured author name against visible byline text in the rendered HTML, ensuring no hidden authorship manipulation occurs.
- Remediation Snippets: When an author node lacks critical fields, BugViso generates a ready-to-use JSON-LD replacement block in the remediation playbook.
To audit your publishing architecture and maximize search engine trust, run a free BugViso automated audit.
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": "Kazi Khalid"
}// ✅ Optimized Pattern: Rich Person object with knowledge graph hooks
{
"@context": "https://schema.org",
"@type": "BlogPosting",
"headline": "Scaling Cloud Microservices",
"author": {
"@type": "Person",
"name": "Kazi Khalid",
"jobTitle": "Lead Systems Architect",
"sameAs": ["https://www.linkedin.com/in/kazikhalid", "https://github.com/kazikhalid757"]
}
}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 our beginner's guide to schema markup.
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. Both qualify for identical visual enhancements in Google Search, but TechArticle is preferred for in-depth engineering 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 disambiguates the author's identity and attaches existing domain authority directly to your article.
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" }]. Google supports multiple co-authors for both rich snippet bylines and Discover feeds.
Does author schema directly improve rankings?
While schema markup is not a direct algorithmic ranking factor, E-E-A-T is a core component of Google's Helpful Content System. Clear author schema provides the explicit entity proof search engines need to reward content with higher topical authority and visibility.
How does author schema impact AI answer engines like ChatGPT and Perplexity?
AI search engines prioritize citations from verifiably authoritative sources. Explicit author schema with verified credentials reduces hallucination risk and increases the probability that generative engines will cite your article as a primary answer source.
9. Conclusion
Implementing comprehensive Article BlogPosting Author Person schema EEAT 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 publication commands higher topical authority and visual prominence across both traditional and AI search ecosystems—which is exactly what an automated BugViso scan verifies across every published article on your website.
See where your site stands
Run a free BugViso audit for SEO, speed, accessibility and AI search readiness — with fixes you can ship today.