Article Schema with Named Authors: The E-E-A-T Signal Google and AI Both Check

Key Takeaways

• Article schema without author.sameAs is incomplete. The author field must resolve to a verifiable entity, not just a string, or Google and AI systems cannot validate the authorship claim.
• Google's post-HCU and spam update landscape penalizes anonymous content — named authorship with verifiable credentials is now a defensive requirement, not just an optimization.
• AI assistants use author.sameAs links to cross-reference author identity before selecting content as a citation source on competitive queries.
• A valid author page requires full name, job title, 200+ word bio, professional photo, and links to external publications or profiles.
• Three fields determine the majority of E-E-A-T signal in Article schema: author.name, author.sameAs, and author.url (the author's page on your own site).

---

Article schema is one of the most commonly implemented — and most commonly broken — structured data types on the web. A quick audit of the top-ranking pages on any competitive query reveals a consistent pattern: the majority have Article schema, but most are missing the fields that actually matter for E-E-A-T.

The most common omission is author.sameAs. Without it, the author field in your schema is just a name. It has no connection to a verifiable external identity. Google cannot confirm the author is a real expert. AI assistants cannot validate the credential claim. You have implemented the syntax of Article schema while skipping the semantics that make it valuable.

This guide explains exactly which fields matter, why, and how to implement them correctly in Next.js App Router.

---

Why Named Authors Matter More in 2026

Google's Helpful Content System (HCS), introduced in 2023 and significantly strengthened through 2024 and 2025, explicitly targets content that lacks demonstrable expertise, experience, and authoritativeness. The Quality Rater Guidelines — the human review framework that feeds into Google's algorithm training — dedicate extensive sections to author credentials as a proxy for content quality.

The practical impact of this shift:

• Anonymous content is systemically devalued on YMYL queries (health, finance, legal, news). A post with no named author or a generic "Editorial Team" byline now starts with a baseline E-E-A-T deficit that strong content alone cannot fully overcome.
• Thin author profiles are penalized at the domain level. A site where all posts are attributed to the same single author with no bio, no credentials, and no external publications signals a content farm pattern regardless of content quality.
• The spam update history confirms the direction. Google's March 2024 spam update specifically targeted "scaled content abuse" and "site reputation abuse," both of which correlate strongly with anonymous or thin-author content.

Beyond Google, the AI citation landscape adds a second audience for your author signals. When ChatGPT, Perplexity, or Claude evaluates whether to cite your content, the author's verifiability is a weighted signal — particularly for topics where expertise is assumed to be required.

A named author with a LinkedIn profile, a verifiable publication history, and an author.sameAs link in your Article schema is a higher-confidence citation source than the same content published anonymously. This is not a marginal effect — on competitive topics, it is often the deciding factor.

---

The Critical Gap: Why author.sameAs Is Missing From Most Implementations

The sameAs property in Schema.org vocabulary links an entity — in this case, a Person — to external identifiers that allow knowledge systems to confirm identity. For an author, sameAs should point to their LinkedIn profile, Twitter/X account, Wikipedia page if applicable, and any other authoritative external profile.

Most Article schema implementations skip sameAs because:

1. CMS plugins generate minimal schema — Yoast, Rank Math, and most WordPress schema plugins populate author.name but leave sameAs empty unless manually configured
2. Developer implementations copy minimal examples — most online Article schema examples show only name in the author object, creating a widespread pattern of incomplete implementation
3. The value is not visible in Google's Rich Results Test — sameAs does not generate a rich result or a validation warning when absent, so there is no immediate signal that it is missing

The consequence: a site can pass every Rich Results Test validation check and still have Article schema that provides near-zero E-E-A-T signal, because the fields that matter most for entity validation are the ones the tests do not flag.

---

The Complete Article Schema Implementation

Below is a complete, production-ready Article schema JSON-LD block with all high-value E-E-A-T fields populated. This is the standard every post on your site should meet.

{
  "@context": "https://schema.org",
  "@type": "Article",
  "headline": "Article Schema with Named Authors: The E-E-A-T Signal Google and AI Both Check",
  "description": "How to implement Article schema with named authors, sameAs social links, and credentials to maximize E-E-A-T signals.",
  "image": "https://seo.yatna.ai/blog/images/2026/03/article-schema-named-authors-eeat.webp",
  "datePublished": "2026-03-25T08:00:00",
  "dateModified": "2026-03-25T08:00:00",
  "author": {
    "@type": "Person",
    "name": "Priya Sharma",
    "jobTitle": "Head of SEO & AI Search Strategy",
    "url": "https://seo.yatna.ai/authors/priya-sharma/",
    "sameAs": [
      "https://www.linkedin.com/in/priya-sharma-seo/",
      "https://twitter.com/priyasharmaseo"
    ]
  },
  "publisher": {
    "@type": "Organization",
    "name": "seo.yatna.ai",
    "logo": {
      "@type": "ImageObject",
      "url": "https://seo.yatna.ai/logo.png"
    }
  },
  "mainEntityOfPage": {
    "@type": "WebPage",
    "@id": "https://seo.yatna.ai/seo-academy/article-schema-named-authors-eeat/"
  }
}

Every field in this example exists for a specific reason. None of them are decorative.

---

The 3 Author Fields That Carry the Most E-E-A-T Weight

1. author.name

This must be a full, real, consistent name — not "Admin," not "Editorial Team," not a brand name. The name should match exactly across the author bio page, the post byline, the Article schema, and any external profiles. Inconsistency across these signals reduces entity resolution confidence.

2. author.sameAs

This is the highest-value field that most implementations are missing. sameAs should include:

• LinkedIn profile URL — the most universally accepted professional identity signal; Google's knowledge graph actively uses LinkedIn data for person entity validation
• Twitter/X profile URL — secondary identity signal, particularly valuable for authors in tech, marketing, and media
• Wikipedia URL (if applicable) — the highest-confidence entity signal; most authors will not have this, but for prolific industry voices it is worth adding
• Google Scholar profile (for academic or research-oriented authors) — signals peer-reviewed expertise

Use the canonical version of each URL. For LinkedIn, use https://www.linkedin.com/in/[username]/ — not the full redirect URL from a shared link. For Twitter/X, use https://twitter.com/[username] or https://x.com/[username].

3. author.url

This points to the author's dedicated page on your own domain — the /authors/[name]/ URL. This is the bridge between your Article schema and the on-site evidence of expertise. An AI assistant or quality rater who encounters author.url will follow that link to evaluate the author's credentials. What they find there determines whether the E-E-A-T signal is fulfilled.

---

What an Author Page Must Include

The author.url field only works if the destination — the author page — contains sufficient E-E-A-T signals. A page that is just a name and a list of posts fails this test.

A complete author page requires:

Essential elements:

• Full name, prominently displayed as the <h1>
• Professional headshot (a real photo, not an avatar or stock image)
• Job title and organization, current
• 200+ word biography covering:
  • Professional background and years of experience in the specific field
  • Publications, speaking engagements, or media appearances
  • Specific areas of expertise or methodological approach
  • Any credentials, certifications, or degrees relevant to the topics covered

E-E-A-T enhancement elements:

• Links to published work on external sites (industry publications, guest posts, press mentions)
• Links to LinkedIn and Twitter/X profiles (these should match author.sameAs in your schema)
• A list of all posts authored on your site — this builds topical authority evidence
• Contact method or speaking inquiry link — signals a real person available for accountability

Schema on the author page itself: The author page should have its own Person schema with the same sameAs links, consistent with the Article schema on each post. This creates a schema chain: Article → author.url → Person schema with sameAs → external profiles.

---

How to Implement in Next.js App Router

In Next.js 13+ with the App Router, inject Article JSON-LD as a <script> tag using a server component. The JSON-LD script pattern is safe for structured data because the content is application-controlled schema markup, not user input — no sanitization risk applies.

// components/ArticleJsonLd.tsx
interface ArticleJsonLdProps {
  title: string;
  description: string;
  image: string;
  datePublished: string;
  dateModified: string;
  authorName: string;
  authorTitle: string;
  authorUrl: string;
  authorSameAs: string[];
  canonicalUrl: string;
}

export default function ArticleJsonLd({
  title,
  description,
  image,
  datePublished,
  dateModified,
  authorName,
  authorTitle,
  authorUrl,
  authorSameAs,
  canonicalUrl,
}: ArticleJsonLdProps) {
  const schema = {
    "@context": "https://schema.org",
    "@type": "Article",
    headline: title,
    description,
    image,
    datePublished,
    dateModified,
    author: {
      "@type": "Person",
      name: authorName,
      jobTitle: authorTitle,
      url: authorUrl,
      sameAs: authorSameAs,
    },
    publisher: {
      "@type": "Organization",
      name: "seo.yatna.ai",
      logo: {
        "@type": "ImageObject",
        url: "https://seo.yatna.ai/logo.png",
      },
    },
    mainEntityOfPage: {
      "@type": "WebPage",
      "@id": canonicalUrl,
    },
  };

  // Safe: content is application-controlled schema markup, not user input
  return (
    <script
      type="application/ld+json"
      // eslint-disable-next-line react/no-danger
      dangerouslySetInnerHTML={{ __html: JSON.stringify(schema) }}
    />
  );
}

Use this component inside the <head> section of your blog post layout:

// app/seo-academy/[slug]/page.tsx
import ArticleJsonLd from "@/components/ArticleJsonLd";

export default async function BlogPostPage({ params }) {
  const post = await getPostBySlug(params.slug);

  return (
    <>
      <head>
        <ArticleJsonLd
          title={post.title}
          description={post.excerpt}
          image={`https://seo.yatna.ai${post.ogImage}`}
          datePublished={post.date}
          dateModified={post.modified}
          authorName={post.author.name}
          authorTitle={post.author.jobTitle}
          authorUrl={`https://seo.yatna.ai/authors/${post.author.slug}/`}
          authorSameAs={post.author.sameAs}
          canonicalUrl={`https://seo.yatna.ai/seo-academy/${post.slug}/`}
        />
      </head>
      {/* page content */}
    </>
  );
}

This approach renders schema server-side for immediate crawler access and co-locates schema logic with the page that consumes it.

---

Common Article Schema Errors

author as a plain string

// Wrong
"author": "Priya Sharma"

// Correct
"author": {
  "@type": "Person",
  "name": "Priya Sharma"
}

A string value for author is syntactically valid JSON-LD but semantically meaningless — it prevents all entity resolution and provides zero E-E-A-T signal.

Missing dateModified

datePublished alone is insufficient. Google uses dateModified to assess content freshness. Articles without dateModified are treated as never-updated. Always include both fields, and update dateModified whenever you make substantive content changes.

publisher.logo missing or incorrect dimensions

Google's Article rich result requirements specify that publisher.logo must be present and that the logo image should be no taller than 60px and no wider than 600px. An oversized or missing logo image will cause the Article rich result to fail validation.

headline exceeding 110 characters

Google's Article schema documentation recommends keeping headline under 110 characters. Longer headlines may be truncated in rich result displays.

mainEntityOfPage pointing to the wrong URL

mainEntityOfPage["@id"] should be the canonical URL of the article page — including trailing slash if your site uses it. An inconsistent URL (with and without trailing slash, or HTTP vs HTTPS) creates a disconnect between your schema and your canonical tag.

---

The GEO Angle: How AI Assistants Use Author Schema

When Perplexity, ChatGPT, or Claude evaluates whether to cite a piece of content on a competitive query, the author's verifiability is a weighted factor in that evaluation. The mechanism works through author.sameAs.

When an AI assistant encounters your Article schema and finds author.sameAs pointing to a LinkedIn profile, it can cross-reference:

• Does the author's LinkedIn profile align with the claimed expertise?
• Does the author's publication history support their claimed authority on this topic?
• Is this person cited by other sources in the AI's training data or real-time index?

An author with a strong LinkedIn profile, a publication history on recognized industry sites, and a consistent name across all touchpoints is a high-confidence citation source. An author with author.name: "Admin" and no sameAs is a low-confidence source — and on competitive topics where multiple high-confidence sources exist, it will not be cited.

This is why author.sameAs is not a nice-to-have optimization. In the post-HCU, AI-search landscape of 2026, it is a baseline requirement for competitive content.

---

FAQ

Does Article schema generate a rich result in Google Search?

Article schema itself does not consistently generate a visual rich result. Its primary function is to provide structured signals — author, date, publisher, headline — that feed Google's quality evaluation systems and AI Overviews pipeline. FAQPage and HowTo schema are more reliable generators of visual rich results. Use Article schema for its E-E-A-T signal value, not for an expected SERP visual enhancement.

What is the difference between Article, NewsArticle, and BlogPosting schema types?

All three are valid Article schema subtypes. NewsArticle is appropriate for timely news content; BlogPosting is appropriate for opinion and analysis; Article is appropriate for evergreen informational content. Google accepts all three. For SEO Academy-style educational content, Article is the most appropriate type.

Should every page on my site have Article schema?

No. Article schema is appropriate for blog posts, guides, and editorial content. Product pages, landing pages, and category pages should use other schema types (Product, WebPage, or CollectionPage). Applying Article schema to non-article pages can create a mismatch between schema type and actual content that Google's quality systems will detect.

How quickly does Google process Article schema after I publish?

Google typically processes new or updated structured data within 24–72 hours for sites that are crawled regularly. For new sites or pages that have not been crawled before, use Google Search Console's URL Inspection tool and request indexing after publishing to accelerate the process.

Can I have multiple authors in Article schema?

Yes. Use an array for the author field when a post has multiple contributors: "author": [{"@type": "Person", "name": "..."}, {"@type": "Person", "name": "..."}]. Each author object should include sameAs and url independently.

---

Validate your Article schema and check for missing E-E-A-T fields — Run a free audit at seo.yatna.ai →