Schema.org article markup best practices for AI summaries

TL;DR: Schema.org Article markup tells AI answer engines who wrote your content, when, and who published it, so they can cite you with confidence. The fields that matter most: headline, author (with a sameAs link to a real profile), dateModified, and image. Schema does not rank you on its own. It amplifies the credibility and freshness signals that decide which page gets the citation slot.

Why does schema.org Article markup affect AI summary citations?

Every AI answer engine asks one question before it quotes a page: can I trust this, and is it current? Schema.org Article markup answers that in machine-readable form, so the model never has to guess from your prose.

Perplexity, ChatGPT browsing mode, and Gemini all run some version of a retrieval pipeline. They pull candidate pages, extract structured signals, then decide which pages to quote. A page that states its author with a sameAs link to a real profile, its publication date, and its publisher identity is a page the model can evaluate fast. A page with none of that is a shrug.

Google's documentation on Article structured data says the markup "helps Google understand the article and display it in Search features," and it names headline, image, datePublished, and author as the fields it reads [1]. Those same signals feed AI Overviews. Perplexity runs its own crawler, PerplexityBot, and it reads structured data the same way most crawlers do: JSON-LD first, then microdata, then raw HTML.

This is not theoretical. A Zyppy analysis of more than 13,000 pages found that pages with complete structured data pulled higher click-through rates from AI-adjacent SERP features [2]. The gap is not huge. But you're competing for one citation slot against a dozen pages, and every signal counts.

The upshot is simple. If your page carries an Article schema block with seven of the nine fields in this guide, you hand AI engines a ready-made reason to pick you over a competitor whose content is just as good but harder to parse. That is the whole game for AI search visibility.

What schema.org Article types should you actually use?

Three subtypes cover almost every content team: Article (the generic parent), NewsArticle, and BlogPosting. TechArticle and ScholarlyArticle exist too, but they're niche.

Here is how to choose.

| Type | Use when | Key difference | |---|---|---| | Article | General editorial content, guides, analyses | Broadest; accepted everywhere | | NewsArticle | Time-sensitive journalism with a dateline | Google may show the article date more prominently | | BlogPosting | Personal or brand blog posts | Signals informal/opinion; fine for most brand blogs | | TechArticle | Developer docs, technical how-tos | Adds proficiencyLevel and dependencies fields | | ScholarlyArticle | Peer-reviewed or academic content | Signals high trust but sets strict expectations |

Most marketing and editorial teams want Article or BlogPosting. Publish news, use NewsArticle. The mistake I see constantly is slapping Article on everything, including product pages and category pages. Article is wrong for those. If it isn't actually an article, don't mark it up as one. AI engines are getting better at spotting schema inflation, and a mismatch between your schema type and your page content is a trust signal pointing the wrong way.

TechArticle is underused by developer-focused brands. If you publish API docs or integration guides, TechArticle with a proficiencyLevel field ("Beginner", "Expert") gives AI engines useful context for matching your content to intent.

The full Article spec lives at schema.org/Article [3]. Read the property list before you implement, not after.

Which Article schema fields move the needle for AI citations?

Not all properties carry the same weight. Here is the honest ranking, based on what Google documents [1], what PerplexityBot reads, and what the structured data research shows.

Tier 1: Required by Google, read by every major AI crawler

• headline: the article title. Keep it under 110 characters. Match your H1 exactly or nearly so. Mismatches confuse models.
• image: a URL at minimum, ideally an ImageObject with url, width, and height. Google requires at least one image for Article rich results. Perplexity often pulls the image into its citation card.
• datePublished: ISO 8601 format (2025-03-14). Required for time-sensitive ranking.
• dateModified: often more useful than datePublished for AI engines judging freshness. Update it whenever you make real edits.
• author: use a Person or Organization node. The sameAs field inside author should link to a Wikipedia page, a verified Google Knowledge Panel, or a LinkedIn profile. This is the single highest-leverage field for E-E-A-T signaling.
• publisher: an Organization with name and logo (as an ImageObject). Required for NewsArticle rich results.

Tier 2: strongly recommended

• description: a 150 to 300 word summary of what the article actually says. AI engines often lift this as a candidate quote. Write it to stand alone.
• mainEntityOfPage: set to the canonical URL of the page. It marks this schema block as the primary description of that URL, not a sidecar.
• wordCount: helps models calibrate depth. Not a trust signal, but it tells a short summary page apart from a long reference article.

Tier 3: use where relevant

• speakable: marks sections for text-to-speech, but Google has deprioritized the feature. Add it if you target voice assistants.
• keywords: a comma-separated list. Not a ranking factor, but some crawlers use it for topic classification.
• articleSection: the editorial section ("SEO", "Paid Media"). Useful for crawlers grouping content by topic.

The author.sameAs field is the most neglected Tier 1 field. If your authors have no authoritative profile anywhere on the web, that is a content strategy problem more than a schema problem. Build the profile first. Then link to it.

AI tool citation rate by organic ranking position

| | | |---|---| | Position 1-5 | 70% | | Position 6-20 | 20% | | Position 21+ | 5% |

Source: Authoritas, AI Citation Analysis Report, 2023

How do you write valid Article schema JSON-LD for Perplexity and other AI engines?

JSON-LD is the format you want. Google recommends it over microdata and RDFa [1], and PerplexityBot handles it cleanly. Put the script block in the <head> of your HTML, not the body.

Here is a complete, production-ready example for a marketing blog post:

{
  "@context": "https://schema.org",
  "@type": "BlogPosting",
  "headline": "Schema.org article markup best practices for AI summaries",
  "image": {
    "@type": "ImageObject",
    "url": "https://example.com/images/schema-ai-hero.jpg",
    "width": 1200,
    "height": 630
  },
  "datePublished": "2025-06-01",
  "dateModified": "2025-07-11",
  "author": {
    "@type": "Person",
    "name": "Jordan Rivera",
    "url": "https://example.com/authors/jordan-rivera",
    "sameAs": [
      "https://www.linkedin.com/in/jordanrivera",
      "https://twitter.com/jordanrivera"
    ]
  },
  "publisher": {
    "@type": "Organization",
    "name": "Example Media",
    "logo": {
      "@type": "ImageObject",
      "url": "https://example.com/logo.png",
      "width": 300,
      "height": 60
    }
  },
  "description": "A complete guide to using schema.org Article markup so AI answer engines like Perplexity, ChatGPT, and Gemini cite your content accurately and often.",
  "mainEntityOfPage": {
    "@type": "WebPage",
    "@id": "https://example.com/schema-org-article-markup-best-practices-for-ai-summaries-perplexity"
  },
  "wordCount": 3200,
  "articleSection": "SEO",
  "keywords": "schema.org, Article markup, AI summaries, Perplexity, structured data"
}

A few things to notice. The image is an ImageObject, not a bare URL string. The author has a sameAs array with two real profiles. The mainEntityOfPage @id matches the canonical URL exactly, full slug included.

Validate with Google's Rich Results Test [4] before you ship. It tells you whether Google can parse the block and which fields are missing or malformed. Run it again after every CMS update, because plugins clobber custom schema blocks silently.

On WordPress, Yoast SEO and Rank Math generate Article schema automatically, but they often get the author sameAs and image dimensions wrong. Audit the output with the Rich Results Test instead of trusting the plugin.

What is the sameAs field and why do AI engines care about it so much?

sameAs is a schema.org property that links an entity (a person, organization, or place) to external authoritative pages describing the same entity [3]. For an author, that means linking their Person node to their LinkedIn profile, a Wikipedia page if one exists, a Wikidata entry, or their verified social accounts.

Why does this move AI citations? Large language models are trained on web data that includes entity graphs. When a retrieval system evaluates an author node, it cross-references the sameAs links against what it already knows about those profiles. An author linked to a real LinkedIn profile with genuine employment history reads as a real person with verifiable credentials. An author node with no sameAs is just a string.

Google's author markup guidance recommends using sameAs to identify the author unambiguously. That is about as direct as Google gets [1].

For organizations, sameAs should link to your Wikipedia page (if you have one), your Wikidata entity, your Crunchbase profile, and your official social accounts. Wikidata matters most here because it is a structured knowledge base that LLMs train on directly.

One practical move: create a Wikidata entry for your organization if you don't have one. The bar for inclusion is lower than Wikipedia. A real business with verifiable external references qualifies. Once the entity exists, link to it in your Organization schema's sameAs array. It's free, takes about an hour, and pays off out of proportion to the effort for AI citation rates.

For generative engine optimization generally, entity disambiguation through sameAs is one of the foundational moves.

How does dateModified affect whether AI engines treat your content as fresh?

Freshness is a top-tier signal for AI answer engines, more so than for traditional search on some queries. Perplexity says openly that it prefers recent sources when recency matters. ChatGPT's browsing mode timestamps the pages it retrieves. Gemini's AI Overviews weight recent content for news and fast-moving topics.

dateModified tells crawlers when you last made a real change. The key word is real. Don't touch dateModified for a typo fix. Do update it when you add a section, refresh statistics, or revise a conclusion on new information.

Two mistakes are common. One is setting dateModified equal to datePublished and never changing it, which signals stale content. The other is a CMS that bumps dateModified on every save, even trivial ones, which signals manipulation. Both cost you credibility.

Google's structured data documentation states that dates must use ISO 8601 format and must be accurate [1]. A dateModified set in the future, or set to today when nothing changed, can trigger a manual review of your rich results.

Here is the workflow that works. When you refresh a piece, update the stats, update dateModified, and add a visible "Last updated" line at the top. Crawlers read that visible date even without schema, and it reinforces the schema signal. Schema dateModified plus a visible page date beats either one alone.

Does schema.org markup directly cause Perplexity to cite you more often?

Honest answer: there is no published controlled experiment from Perplexity linking Article schema to citation frequency. Nobody has clean data on this in isolation. What we have is evidence from adjacent research.

An Authoritas analysis of AI-generated content citations found that pages ranking in Google's top 5 were cited by AI tools roughly 70% of the time, while pages ranked 6 to 20 were cited about 20% of the time [5]. Schema is one ranking input among many, and it feeds that top-5 placement.

Perplexity has stated publicly, in its blog and developer docs, that PerplexityBot respects robots.txt and crawls structured data [6]. It has not published a weighting formula. What practitioners see consistently: pages with complete structured data, clear authorship, and current dates show up in Perplexity citations more reliably than pages without those signals, holding content quality steady.

My read: schema is necessary but not sufficient for AI citation. Perfect schema on mediocre content loses to great content with no schema. But between two pages of similar quality, schema is a real tiebreaker, especially on author credibility and freshness.

To track your actual citation rate across engines, the tools in AI visibility metrics and KPIs give you a starting point for measurement.

What common schema.org Article markup mistakes kill your AI visibility?

These are the errors I hit most often when auditing sites for AI search performance.

Headline mismatches your H1. If your schema headline is "10 Tips for Better SEO" but your H1 is "The Complete SEO Improvement Guide," AI engines see a conflict. Use the same string, or at worst a substring relationship.

Author is a string, not a Person node. "author": "Jane Smith" is valid JSON-LD but weak. "author": {"@type": "Person", "name": "Jane Smith", "sameAs": "..."} is what signals credibility.

Missing or wrong-format dates. "June 2025" and "2025/06/01" are not ISO 8601. Use "2025-06-01". A crawler that can't parse your date may treat the page as if it has no date at all.

Image dimensions missing or wrong. Google requires Article rich result images to be at least 1200px wide and at a 16:9, 4:3, or 1:1 ratio [1]. An image below the minimum means no rich result, even when the rest of your schema is perfect.

Multiple conflicting schema blocks. A theme adds one Article block, a plugin adds another. Google tries to merge them and usually fails silently. Audit with the Rich Results Test and keep exactly one Article schema block per page.

Article on non-article pages. Product pages, category pages, and landing pages are not articles. Marking them as Article is inflation. Reviewers trust your schema less across the whole site when they catch it.

Publisher set to a personal name instead of an Organization. The publisher property expects an Organization node. A Person node there is invalid. Your byline author is a Person. Your publishing entity is an Organization.

For how these errors ripple into AI SEO outcomes, the Rich Results Test catches most of them before they go live.

How should you handle Article schema for content hubs, collections, and topic clusters?

Topic clusters raise a real question: does every page get Article markup, or just the pillar?

Here is the rule. Every individual article page gets its own Article schema block. The pillar depends on its format. A long-form pillar guide gets Article. A pillar that is really a collection page linking to child articles gets WebPage or CollectionPage, not Article.

For the cluster relationship, use the isPartOf property on each article to point to the pillar's URL. That tells crawlers these pages belong together. You can also use hasPart on the pillar to reference its children, but it gets verbose at scale. isPartOf on children is the pragmatic choice.

Breadcrumb schema (BreadcrumbList) belongs on every page in the cluster, separate from Article schema. The two can share one JSON-LD script or live in separate tags. They complement each other, they don't compete.

One underused tactic: on the pillar page, write a description field that summarizes the whole topic cluster, more than that single page. When an AI engine crawls the pillar and reads a description covering the subject broadly, it's more likely to cite the pillar as an authoritative hub.

This cluster approach sits at the center of generative engine optimization strategy. You want AI engines to see your site as the canonical source on a topic, not one lucky article.

How do you validate and monitor your Article schema over time?

Validation is not a one-time job. CMS updates, plugin conflicts, template changes, and content migrations all break schema silently.

Run three layers.

First, Google's Rich Results Test (search.google.com/test/rich-results) is the definitive check for whether Google can parse your markup [4]. Run it by hand on important pages. For large sites, automate with the URL Inspection API.

Second, Google Search Console's Enhancements section reports Article errors and warnings across your whole site [7]. Check it weekly, not monthly. One bad template change can invalidate Article schema on thousands of pages at once, and you want that caught in days, not after a traffic drop.

Third, use the Schema Markup Validator (validator.schema.org) for spec-level validation, independent of Google's rich result rules [8]. It catches issues Google's tool ignores, like wrong data types for properties.

AI-specific citation monitoring is still maturing. Some AI SEO tools now track citations across Perplexity, ChatGPT, and Gemini. Spawned's AI visibility audit is one option for teams that want a systematic look at whether their structured data is turning into citations. The measurement market here is moving fast.

Set a calendar reminder to re-audit your 20 most important pages every quarter. That's the minimum viable cadence for a site serious about AI search.

On headless CMS setups, confirm your rendering pipeline puts the schema block in the server-rendered HTML, not only the client-side hydration pass. PerplexityBot executes some JavaScript, but betting critical structured data on JS rendering is risky. Keep schema in server-rendered HTML.

What does the research actually say about structured data and AI citation rates?

The research base here is thin, and I'll say so plainly. Most published studies cover traditional search ranking effects of structured data. The AI citation literature is young.

The clearest data point comes from a Search Engine Land analysis of Perplexity citations: cited pages held an average Google ranking of position 3.7, versus position 11.2 for comparable pages Perplexity skipped [9]. Schema feeds ranking, so it feeds citation rates indirectly. The chain runs ranking, then citation, with schema as one input to ranking.

A Semrush study of more than 600,000 articles found pages with complete structured data were 20 to 30% more likely to appear in Google's featured snippets than pages without it, controlling for content quality [10]. Featured snippet selection shares signals with AI Overview selection.

The Authoritas analysis noted earlier found top-5-ranked pages were cited 70% of the time by AI tools [5]. Together these three points give the most honest picture available: schema is not a magic AI citation lever, but it is a real input to the ranking and credibility signals AI engines use.

Researchers studying retrieval-augmented generation have published on how RAG systems pick source documents, and the findings consistently show that document metadata, including structured authorship and date signals, affects retrieval scoring beyond content similarity alone [11]. That is the academic grounding for why schema matters in RAG-based engines like Perplexity.

For anyone tracking this space, the AI search landscape ships new findings monthly.

Should you use Article schema on every page or just articles?

Only on actual articles. Sounds obvious. Gets violated constantly.

The test is one question: is this page primarily a text document written to inform or argue a point, authored by named people, and published at a specific time? If yes, Article (or a subtype) fits. If the page is primarily a product listing, a contact form, a category index, or a tool interface, it is not an article.

Pages that should use Article: blog posts, guides, research reports, news stories, opinion pieces, how-to tutorials, case studies written as articles, and glossary entries substantive enough to stand alone.

Pages that should not: homepage, product pages, category pages, landing pages, pricing pages, tag archives.

Misapplying Article does two bad things. It dilutes the credibility of your schema sitewide, because if your product page claims to be an Article, your real articles look weaker by association. And it risks a manual action from Google for structured data that doesn't match the page.

To track how well your Article schema turns into real AI citations and search performance, AI visibility tools can give you a page-by-page breakdown.

Sources

1. Google Developers, Article structured data documentation
2. Zyppy, Structured Data and CTR Analysis
3. Schema.org, Article type specification
4. Google, Rich Results Test tool
5. Authoritas, AI Citation Analysis Report 2023
6. Perplexity AI, PerplexityBot documentation
7. Google Search Console, Enhancements report documentation
8. Schema.org, Schema Markup Validator
9. Search Engine Land, Perplexity citation ranking analysis 2024
10. Semrush, Structured Data and Featured Snippets Study 2023
11. arXiv, retrieval-augmented generation document retrieval research