You can publish a great blog post and still leave Google guessing about it. The title is in an h1, the author name is somewhere in a byline, the date is in small grey text — a human reader puts it all together in seconds, but a search engine has to infer it. Article schema removes that guesswork.
What is Article schema?
Article schema is structured data, written in JSON-LD, that tells search engines exactly what a page is: an article, who wrote it, when it was published, and what its headline and main image are. It uses vocabulary from Schema.org, and it lives in a <script type="application/ld+json"> block in the page, invisible to readers but readable by search engines.
There are two types you will meet most often:
- Article — the general type, suitable for news articles, reports and long-form pieces.
- BlogPosting — a more specific subtype of Article, and the natural choice for a blog post.
If your page is a blog post, use BlogPosting. It is more precise, and precision is the whole point of structured data.
The key fields
You do not need every property Schema.org defines. These are the ones that matter most for a blog post:
- headline — the title of the article, exactly as it appears on the page.
-
author — the person (or organisation) who wrote it. Use a
Personobject with aname, and aurlto the author's profile when you have one. -
datePublished — the original publication date, in ISO 8601 format, for example
2026-11-19. - dateModified — the date the article was last updated. Keep this honest: update it only when the content actually changes.
- image — the main image of the article, as a full URL. It should be the image a reader actually sees at the top of the post.
- description — a short summary of the article.
- mainEntityOfPage — the URL of the page the article lives on, which ties the schema to the page itself.
A JSON-LD example
Here is a complete, minimal example for a blog post:
{
"@context": "https://schema.org",
"@type": "BlogPosting",
"headline": "Article Schema for Blog Posts: Help Google Understand Your Content",
"description": "How Article and BlogPosting schema help search engines understand a blog post, and how to add them correctly.",
"author": {
"@type": "Person",
"name": "Quicklity",
"url": "https://quicklitytools.com"
},
"datePublished": "2026-11-19",
"dateModified": "2026-11-19",
"image": "https://quicklitytools.com/images/article-schema-example.jpg",
"mainEntityOfPage": {
"@type": "WebPage",
"@id": "https://example.com/blog/article-schema-for-blog-posts"
}
}
Paste a block like this into the <head> of your blog post page, replacing the values with your own. That is genuinely all there is to it — no plugin required if you can edit the page HTML.
The golden rule: match what readers can see
This is the rule most people get wrong. Every value in your schema must match content that is actually visible on the page:
- The
headlinemust be the headline on the page, not a keyword-stuffed alternative. - The
authormust be the author shown in the byline. - The
datePublishedmust be the date shown to readers. - The
imagemust be an image that appears in the article.
Adding a different author, a fake date, a stock image that never appears on the page, or a headline that does not exist on the page is misleading markup. Google can ignore it, and repeated misleading markup can cost you the rich-result eligibility you were trying to earn. Write the article first, then describe it accurately in schema — never the other way round.
Test before you publish
Always test the page before it goes live, and again after any template change:
- Open Google's Rich Results Test and enter the page URL (or paste the code).
- Check that the Article/BlogPosting item is detected with no errors.
- Fix any warnings about missing recommended fields, such as
imageorauthor, where you can. - Re-test after fixing — a small typo in JSON, like a missing comma, breaks the whole block.
The Schema.org validator is also worth a run for a second opinion, since it checks the markup against the full vocabulary rather than only what Google displays.
Common mistakes to avoid
- Copy-pasting the same schema onto every post. Each article needs its own headline, dates and image.
-
Forgetting
dateModified. Updating a post without updating the date — or updating the date without changing the content — both erode trust. - Using Article when the page is not an article. A product page, a homepage or a category page is not a blog post; use the schema type that fits the page.
- Hiding the data. Schema that describes content nobody can see on the page is exactly what Google warns against.
- Invalid JSON. One trailing comma or unescaped quote silently invalidates the block. Validate, don't assume.
Generate it instead of hand-writing it
If you would rather not write JSON-LD by hand, a generator does the formatting for you. Fill in the headline, author, dates and image URL, and it produces a ready-to-paste block: Schema Markup Generator. Whichever route you take, run the result through the Rich Results Test before publishing.
Article schema will not turn a weak post into a good one, and it is not a ranking guarantee. What it does is make a good post easier for Google to understand — who wrote it, when, and what it is about. For a blogger, that is a cheap, one-time improvement worth making on every post.
Top comments (0)