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.

· 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.

Diagram
┌─────────────────────────────────────────────────────────────────────────────┐
│                 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

StepWhat the parser does
1. Schema extractionParses the JSON-LD script block for the Person entity
2. URI disambiguationFollows sameAs links to Wikidata and other authoritative profiles
3. Knowledge Graph joinBinds the author to an existing Knowledge Graph node ID
4. Topic associationRelates the author to the topics they write about

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:00
  • dateModified: 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:

html
<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:

tsx
// 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:

json
{
  "@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 TypeBest Use CaseExpected Rich Result / SERP FeatureKey Unique Properties
TechArticleTechnical tutorials, API docs, engineering writeupsHigh relevance in technical search & AI search enginesdependencies, proficiencyLevel
BlogPostingGeneral company blog posts, founder updates, marketing insightsStandard SERP snippet with thumbnail and bylineLightweight, standard article attributes
NewsArticleTimely journalism, breaking news, press reportsGoogle News feed, Top Stories carousel, Google Discoverdateline, printEdition, printSection
ArticleBroad editorial content, long-form essaysStandard visual article enhancementsGeneric 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:

python
# 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:

json
// ❌ 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"
}
json
// ✅ 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.

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

· 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.

Found this useful? Share it.

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 how it works

See where your site stands

Run a free BugViso audit for SEO, speed, accessibility and AI search readiness — with fixes you can ship today.