---
title: "Article Schema: A Step-by-Step Setup Guide"
description: "Article schema is JSON-LD markup that tells search engines and AI answer engines a page is a news, blog, or reporting piece."
canonical_url: "https://kinetixseo.com/articles/article-schema"
published_at: "2026-09-14T10:23:01+00:00"
updated_at: "2026-09-07T08:38:27+00:00"
author: "Rogier Bruggeman"
category: "Technical SEO"
---
# Article Schema: A Step-by-Step Setup Guide

Article schema is JSON-LD markup that tells search engines and AI answer engines a page is a news, blog, or reporting piece.

## What is article schema?

Article schema is structured data — written as JSON-LD — that identifies a page as a news article, blog post, or piece of reporting so that search engines and AI answer engines can read its headline, author, publish date, and main image as distinct, machine-readable fields instead of guessing at them from raw HTML. It uses the schema.org vocabulary, with three variants: `Article`, `NewsArticle`, and `BlogPosting`. Google uses it to power article rich results (the headline-and-thumbnail cards in Top Stories and standard search), and AI answer engines use the same fields to extract a clean summary when deciding what to cite. Without it, a crawler has to infer the headline from an `<h1>`, guess the author from footer text, and estimate the publish date from a sitemap — all steps that can fail silently and quietly cost you visibility in both channels.

That second audience matters more than most guides admit. Structured data was originally a Google rich-results play, but it now doubles as the cleanest signal you can hand an AI crawler that doesn't render JavaScript and doesn't want to parse your CSS to find the byline.

## Why article schema matters beyond rich results

The immediate payoff of article schema is eligibility for Google's article rich results — the card-style listings with a headline, thumbnail, and publish date that appear in Top Stories and standard search. But the less obvious payoff is showing up correctly when an AI system summarizes or cites your page, because those systems lean on structured fields precisely because they're unambiguous.

That second point isn't theoretical. According to [KinetixSEO GEO citation tracking](https://kinetixseo.com), 83% of the sources AI answer engines cited for its tracked prompts over the last 90 days were vendor or marketing pages — not forums, not reference wikis, not product documentation. That measurement came from 665 AI answer-engine checks over 90 days, with the 40 cited source links classified by domain type. The practical read: AI systems are already citing pages like yours far more than they're citing community or reference content, which means the pages that mark themselves up cleanly as articles have an outsized chance of being the ones an AI engine picks to summarize and link back to. Structured data is how you make that pick easy instead of a guess.

## Before you start: what you need

Article schema requires a handful of fields to be genuinely useful, and skipping any of them either blocks eligibility outright or leaves an AI crawler with a gap it has to fill by guessing. Gather these before you touch a template:

- **Headline** — the exact article title, capped at roughly 110 characters for Google's rich-result eligibility.
- **Author name** — a person or organization, not a placeholder like "Admin" or "Staff."
- **Publish date and, if applicable, modified date** — in ISO 8601 format (`2026-09-07T09:00:00-04:00`).
- **Main image** — at least one image URL, ideally at 1200px width or wider, matching what's actually rendered on the page.
- **Publisher name and logo** — required for `NewsArticle`, recommended for the others.
- **Article body reference** — the schema doesn't need your full text, but the headline and description should match what's visibly on the page, not a rewritten version aimed at rankings.

If you're new to structured data generally, the [Structured Data SEO Guide](https://kinetixseo.com/articles/structured-data-for-seo-a-practical-json-ld-guide) covers JSON-LD syntax and validation from the ground up; this guide assumes you're comfortable with the basics and focuses specifically on the Article type. A shorter primer on what structured data is generally is available too, if that's the piece you're missing.

## Step-by-step: adding article schema to a page

Follow these steps in order. Each one names the exact file, screen, or tool involved so you can execute it without hunting for the right menu.

1. **Choose the right schema type.** Use `NewsArticle` for time-sensitive reporting eligible for Top Stories, `BlogPosting` for opinion or how-to content like this page, and plain `Article` as a fallback when neither fits cleanly. Google treats all three as valid for standard article rich results; only `NewsArticle` unlocks Top Stories placement.
2. **Build the JSON-LD block.** Open your page template or CMS's custom-code field and write a `<script type="application/ld+json">` block containing the `@context`, `@type`, `headline`, `author`, `datePublished`, `dateModified`, `image`, and `publisher` properties. Keep the `author` as an object with `@type: "Person"` and a `name` field, not a bare string.
3. **Place the script in the page `<head>`.** Most CMS platforms (WordPress via a theme's `header.php` or a plugin's custom-field area, or a static site's template partial) let you inject this without touching the visible page body — it should never appear in rendered HTML content, only in the source.
4. **Match every field to what's visibly on the page.** The headline in your JSON-LD must match your on-page `<h1>` text, the image must be one that actually renders on the page, and the author must match the visible byline. Mismatches are the single most common reason article rich results get rejected in review.
5. **Validate with Google's Rich Results Test.** Paste your live URL or raw code into the tool at search.google.com/test/rich-results and confirm it returns "Article" as an eligible enhancement with zero errors. Warnings (like a missing `dateModified`) won't block eligibility but are worth fixing.
6. **Check for duplicate or conflicting markup.** Search your page source for more than one `Article`-type JSON-LD block — a common bug when a CMS plugin and a manual template both inject schema. Conflicting duplicates can cause Google to ignore both.
7. **Submit the URL in Google Search Console.** Use the URL Inspection tool to request indexing after publishing changes, then check back in a few days under the "Enhancements" report for confirmed Article rich-result status.
8. **Re-validate after any template change.** Site redesigns and CMS updates frequently strip or duplicate JSON-LD blocks without anyone noticing; re-run the Rich Results Test any time the article template changes.

## Article vs. NewsArticle vs. BlogPosting

All three variants share the same required fields, but the type you choose determines what you're eligible for and signals intent to both Google and AI crawlers. Choosing the wrong one doesn't break anything technically — the markup still validates — but it can misrepresent the content's purpose to systems deciding whether to feature it in a news-specific surface.

AttributeNewsArticleBlogPosting / ArticleBest forTime-sensitive reporting, breaking newsOpinion, how-to, evergreen commentaryTop Stories eligibilityYesNoTypical update frequencySingle publish, rare editsMay be updated and re-dated over timePublisher fieldRequiredRecommended, not requiredIf your content gets revised substantially after publication — a how-to guide updated for a new tool version, for instance — set `dateModified` to the real revision date rather than leaving it stale. Google and AI crawlers alike use that field to judge freshness, and a `dateModified` that never changes on a page that clearly has changed is a credibility signal working against you.

## Common mistakes that break article schema

Most article schema failures aren't syntax errors — they're mismatches between what the markup claims and what the page actually shows, or fields quietly missing that block eligibility.

- **Headline mismatch.** The JSON-LD headline differs from the on-page `<h1>`, often because a CMS auto-generates one from a slug while the schema pulls from a manually entered title field.
- **Generic or missing author.** Using "Admin," "Staff," or omitting the author object entirely gives both Google and AI crawlers nothing to attach credibility to.
- **Stale or absent dateModified.** Leaving this field unset, or never updating it after a real content revision, undercuts freshness signals that both search and AI systems weigh.
- **Image doesn't match what renders.** Pointing to an image URL that isn't the one actually displayed on the page, or one below Google's minimum resolution guidance.
- **Duplicate JSON-LD blocks.** A plugin and a manual template both injecting `Article` schema on the same page, which can cause the whole block to be ignored.
- **Schema disagrees with visible text.** Writing a punchier headline into the schema than what's on the page — a mismatch that can read as manipulative to both a manual reviewer and an algorithm.

Each of these is a five-minute fix once you know to look for it, but only the Rich Results Test or a manual source-code check will actually surface them — none show up as a ranking drop you'd notice on their own.

## How article schema fits your wider technical SEO

Article schema doesn't operate in isolation — it interacts with how often your pages get crawled and how fast they render, both of which affect whether the markup gets seen and trusted in the first place. If your article pages sit deep in a large site's structure or compete for crawl attention with thousands of other URLs, the schema itself won't matter if a bot never reaches the page often enough to notice you added or updated it; that's covered in more detail in the piece on [crawl budget optimization](https://kinetixseo.com/articles/how-to-fix-crawl-budget-waste-on-large-sites), and a shorter definition of the concept is available too if you just need the basics.

Page speed plays a role too, though a more indirect one. Structured data doesn't directly affect Core Web Vitals scores, but a bloated JSON-LD block loaded synchronously in the `<head>` can add to render-blocking weight on slow templates, and pages that fail Core Web Vitals thresholds are less likely to get the crawl frequency and rendering priority needed for rich results to actually appear — details on current thresholds and fixes are in the [Core Web Vitals guide](https://kinetixseo.com/articles/core-web-vitals-2026-what-actually-moves-rankings). None of this replaces getting the article markup itself right, but it explains why a technically perfect schema block sometimes still doesn't show up in results — the problem may not be the schema at all.

## Verifying your article schema is working

A visual snapshot of what "done" looks like:

- **JSON-LD validates with zero errors** in Google's Rich Results Test, run against the live URL.
- **Headline, image, author, and dates all match** what's visibly rendered on the page.
- **Only one `Article`-type block exists** in the page source — check by viewing source and searching for `"@type": "Article"` or its variants.
- **`dateModified` reflects the real last substantive edit**, not a stale value from initial publish.
- **Search Console's Enhancements report shows confirmed Article status**, not just "detected" or pending.
- **AI crawlers can find the same fields without rendering JavaScript** — check by disabling JavaScript in your browser and confirming the JSON-LD block still loads in the raw HTML source.

If every item on that list checks out and you're still not seeing rich results after a couple of weeks, the bottleneck is more likely crawl frequency or a manual review delay than the markup itself — Google's own guidance notes that eligibility can take time to reflect even after valid markup is in place.

## Frequently asked questions

### Does article schema improve rankings directly?

No — article schema doesn't function as a ranking factor in Google's core algorithm the way page speed or backlinks do. What it does is make your page eligible for article rich results (headline-and-thumbnail cards) and give both search engines and AI answer engines a cleaner, unambiguous way to read your headline, author, and publish date, which can improve click-through and citation rates even without moving your position in standard results.

### Which schema type should I use: Article, NewsArticle, or BlogPosting?

Use `NewsArticle` only for time-sensitive reporting you want eligible for Google's Top Stories carousel; use `BlogPosting` for opinion pieces, how-to guides, and evergreen commentary; and fall back to plain `Article` when neither fits cleanly. All three share the same required fields and validate the same way — the choice affects eligibility and signaling, not markup complexity.

### Can I add article schema without editing code directly?

Yes, in most cases — WordPress plugins like Yoast SEO or Rank Math generate Article JSON-LD automatically from your post's title, featured image, author, and dates, and most modern CMS platforms offer a similar built-in or plugin-based option. You still need to verify the output with the Rich Results Test, because auto-generated markup can inherit the same mismatches (wrong image, generic author name) as hand-written code.

### How do I know if my article schema is actually being read by AI answer engines?

You can't observe this directly the way you can watch a Google rich result appear, since AI engines don't publish which structured fields they used for a given citation. The closest proxy is confirming the JSON-LD validates cleanly and loads in raw HTML without JavaScript, since that's the same access pattern most AI crawlers use; ongoing citation tracking, like the kind covered in [AI citation tracking](https://kinetixseo.com/articles/ai-citation-tracking-how-it-actually-works), is how you'd measure whether it's translating into actual mentions.

### Do I need dateModified if my article never gets updated?

Not strictly — `dateModified` is optional in the schema.org spec, and if a page truly never changes after publish, omitting it or leaving it equal to `datePublished` is accurate. The mistake is leaving a stale `dateModified` on a page you have substantively revised, since that misrepresents freshness to both search engines and AI systems that weigh recency in their citation decisions.

## Sources
- [KinetixSEO GEO citation tracking — 83% of the sources AI answer engines cited for our tracked prompts over the last 90 days were vendor or marketing page pages. Sample: 665 observations, measured Sep 7, 2026. Methodology: Recorded the answers 665 AI answer-engine checks returned for KinetixSEO's own tracked prompts over 90 days, collected the 40 source links those answers cited, and classified each cited domain as a community forum, a reference wiki, product documentation, or a vendor/marketing page.](https://kinetixseo.com) (2026-09-07)