Article Schema and Content Entity Signals

When someone publishes an article on your website, three entities are involved: the author (a Person), the publisher (an Organization), and the article itself (a CreativeWork). Article schema makes these relationships explicit. Without it, Google has to infer who wrote the article, who published it, and how the article connects to both entities. With Article schema, the attribution chain is declared, not guessed.

This session covers how to implement Article schema correctly, how the author-publisher-article chain works, and why each link in the chain matters for entity authority.

The Attribution Chain

The diagram shows the complete attribution chain. The Person entity is the author of the Article. The Organization entity is the publisher. The Person works for the Organization. The Article is about a topic. Each arrow is a declared relationship that Google can read without inference.

When all links in this chain are present and consistent, Google can construct a complete picture: "Jane Smith, who works for Acme Corp, authored this article about SEO, published by Acme Corp." That is four entity relationships from a single Article schema block. Without the schema, Google has to figure out all four through text analysis.

Article Schema Implementation

Here is a complete Article schema example with the full attribution chain:

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "Article",
  "headline": "How to Recover From a Google Core Update",
  "description": "A step-by-step recovery plan for sites affected by Google core algorithm updates.",
  "image": "https://example.com/images/core-update-guide.jpg",
  "datePublished": "2025-03-15",
  "dateModified": "2025-06-01",
  "author": {
    "@type": "Person",
    "@id": "https://example.com/team/jane-smith/#person",
    "name": "Jane Smith",
    "url": "https://example.com/team/jane-smith/"
  },
  "publisher": {
    "@type": "Organization",
    "@id": "https://example.com/#organization",
    "name": "Acme Corp",
    "logo": {
      "@type": "ImageObject",
      "url": "https://example.com/images/logo.png"
    }
  },
  "mainEntityOfPage": {
    "@type": "WebPage",
    "@id": "https://example.com/blog/core-update-recovery/"
  }
}
</script>

Several properties deserve attention. The author references the Person's @id, linking this article to the same Person entity declared on the author page. The publisher references the Organization's @id, linking to the entity declared on the homepage and about page. The mainEntityOfPage tells Google that this article is the primary content of this URL.

Schema Properties Reference

Article Types: When to Use Which

Schema.org offers several Article subtypes. The choice matters because different types carry different semantic weight:

• Article: Generic article type. Use when the content does not fit a more specific subtype.
• BlogPosting: A blog post. Use for dated, regular blog content. Subtype of Article.
• NewsArticle: A news article. Use for timely, journalistic content. Triggers news-specific rich results eligibility.
• ScholarlyArticle: An academic paper. Use only for peer-reviewed or academic content.
• TechArticle: A technical article. Use for documentation, tutorials, and technical guides.

For most business content, Article or BlogPosting is appropriate. Use NewsArticle only if your site qualifies as a news source in Google News. Misusing NewsArticle on non-news content does not help and may trigger manual review.

The about and mentions Properties

Two underutilized Article schema properties are about and mentions. The about property declares the primary topic entity of the article. The mentions property lists other entities referenced in the content.

For example, an article about Google's Search Generative Experience could include:

"about": {
  "@type": "Thing",
  "name": "Search Generative Experience",
  "sameAs": "https://en.wikipedia.org/wiki/Search_Generative_Experience"
},
"mentions": [
  {
    "@type": "Organization",
    "name": "Google",
    "sameAs": "https://www.wikidata.org/wiki/Q95"
  }
]

These properties create explicit entity-to-entity connections through your content. When Google sees that your articles consistently mention and discuss specific entities, it builds co-occurrence patterns that strengthen your own entity's knowledge profile.

Validation and Common Errors

Use Google's Rich Results Test to validate your Article schema. Common errors include: missing author property (Google requires it for Article rich results), author declared as a string instead of a Person object, publisher missing the logo property, and datePublished in a non-ISO format.

The most consequential error is inconsistent @id references. If your Article schema references an author @id that does not match the @id on the author page, the entity connection breaks. Google sees two different Person entities instead of one. Always verify that @id values are identical across pages.

Further Reading

• Google: Article Structured Data Documentation
• Schema.org: Article Type
• Google: Rich Results Test Tool
• Search Engine Journal: Article Structured Data Guide