Article schema done right: Article, BlogPosting and NewsArticle

Article schema is a small block of JSON-LD that tells machines a page's headline, who wrote it, when it was published and last changed, and which image represents it. Done right, it uses the most specific type (Article, BlogPosting or NewsArticle), names each author as a Person with a url that leads to an author page, and carries dates that match the page. Done wrong, it states things the page does not, which is worse than having none.

This guide covers the properties that matter, a complete example, author pages, honest dates, common mistakes and how to check your own markup in a few minutes.

Article, BlogPosting or NewsArticle: which type to use

All three come from schema.org. NewsArticle is a direct subtype of Article, and BlogPosting sits under Article by way of SocialMediaPosting (the BlogPosting page shows the full chain). Google's Article structured data documentation says Article markup must use one of these three types and documents one shared set of properties for all of them.

Pick the most specific type that is true. A tutorial on a company blog is a BlogPosting. A press release republished on a news site is a NewsArticle only if the site is reporting it as news. If you are unsure, Article is the safe general choice.

The properties that matter

Google's documentation is direct about this: "There are no required properties; instead, add the properties that apply to your content." It then recommends seven. We add three more that keep the record complete.

On images, Google asks for images that represent the article (not a logo), in a format Google Images supports, with crawlable and indexable URLs. For best results it recommends several high-resolution images in 16x9, 4x3 and 1x1 ratios, each at least 50,000 pixels when you multiply width by height.

A complete BlogPosting example in JSON-LD

This is a full block for a post with one author. Put it in a <script type="application/ld+json"> tag in the server-rendered HTML of the post.

{
  "@context": "https://schema.org",
  "@type": "BlogPosting",
  "headline": "How we cut our checkout page weight in half",
  "description": "What we removed, what we lazy-loaded and what it did to load times.",
  "mainEntityOfPage": {
    "@type": "WebPage",
    "@id": "https://example.com/blog/checkout-page-weight"
  },
  "image": [
    "https://example.com/images/checkout-16x9.jpg",
    "https://example.com/images/checkout-4x3.jpg",
    "https://example.com/images/checkout-1x1.jpg"
  ],
  "datePublished": "2026-10-14T09:00:00+01:00",
  "dateModified": "2026-11-02T16:30:00+00:00",
  "author": [
    {
      "@type": "Person",
      "name": "Dana Okafor",
      "url": "https://example.com/authors/dana-okafor"
    }
  ],
  "publisher": {
    "@type": "Organization",
    "name": "Example Ltd",
    "url": "https://example.com/",
    "logo": {
      "@type": "ImageObject",
      "url": "https://example.com/logo.png"
    }
  }
}

A few details worth copying. The dates carry a timezone offset, and the two offsets differ because UK daylight saving time ended between them (on 25 October 2026). author is an array, so adding a second author means adding a second object, not editing a name string. The logo sits on the publisher, not in image.

Authors: a Person with a url, and a page to point at

Google's author best practices for Article markup come down to five rules:

1. Include every author shown on the page.
2. Give each author their own entry. Never write "name": "Dana Okafor and Sam Reyes".
3. Use Person for people and Organization for organizations, and never the generic Thing.
4. Put only the name in author.name. Leave out job titles, honorifics and phrases such as "Posted by"; the publisher's name goes in publisher. On schema.org a job title belongs in jobTitle and honorifics in honorificPrefix or honorificSuffix.
5. Add url or sameAs with valid URLs that identify the author.

The url should go somewhere useful: an author page on your site that says who the person is and what they write about. Google's guidance on helpful content asks whether bylines "lead to further information about the author or authors involved", and it calls fabricated creator profiles, such as made-up names or false credentials, a form of deception. An author page is that further information.

On the author page itself, you can describe the person with ProfilePage markup, which Google's Article documentation recommends for internal author profile pages:

{
  "@context": "https://schema.org",
  "@type": "ProfilePage",
  "mainEntity": {
    "@type": "Person",
    "@id": "https://example.com/authors/dana-okafor#person",
    "name": "Dana Okafor",
    "jobTitle": "Lead front-end engineer",
    "description": "Writes about web performance and checkout flows.",
    "image": "https://example.com/images/dana-okafor.jpg",
    "sameAs": ["https://www.linkedin.com/in/example-dana-okafor"]
  }
}

If a post really is written by a team with no named person, Organization as the author is accurate and fine. What is not fine is inventing a person to have a face on the byline.

Honest dates: datePublished and dateModified

Dates are an easy place for Article markup to drift from the truth. Google's byline date guidance asks for a few simple things:

• Show a visible date prominently on the page with a clear label, such as "Published" or "Last updated".
• Keep the visible date and the structured date consistent. The date is required; a time and timezone are optional but recommended for precision.
• If you give a timezone, use the correct one, allowing for daylight saving time.
• Don't use future dates, and don't use the date of an event the page describes.
• Keep other dates on the page to a minimum, so the wrong one is not picked up.

Then there is the habit of bumping dateModified every time the site rebuilds, or every few months to look fresh. Google's helpful content questions name it directly: "Are you changing the date of pages to make them seem fresh when the content has not substantially changed?" The honest rule is short: change dateModified when the substance changes (a new section, a corrected fact, updated steps), not when a typo is fixed or a deploy runs.

A common technical cause of dishonest dates is a template that fills dateModified with the build time or the current time. If every post on your site shows today's date in its markup, that is the likely cause.

How this blog does it

This blog uses the same markup it recommends. Each post page emits one JSON-LD @graph with:

• a BlogPosting whose headline, description, datePublished and dateModified come from the post file, the same values the page shows (the dates are calendar dates without a time, which Google's date guidance allows);
• author and publisher that both reference one Organization node by @id, because the posts are written and reviewed as Crawlito rather than by a named individual;
• an image pointing at the post's own Open Graph image, plus mainEntityOfPage, articleSection, keywords and wordCount;
• a BreadcrumbList, and a FAQPage built from the questions at the end of each post.

Every value is generated from the content file, so the markup cannot say something the page does not. The FAQPage block is there as a machine-readable description of the questions, not for a rich result: Google's changelog says FAQ rich results stopped appearing in Search on 7 May 2026. Our FAQ schema guide covers what that markup still does, and the Organization schema guide covers the node every post points to.

Common Article schema mistakes

Syntax slips such as trailing commas, unescaped quotes and wrong nesting are their own category; common JSON-LD errors walks through them.

How to check your Article markup

Start with the raw HTML, because that is what many crawlers read. Google can process structured data generated with JavaScript, but Vercel's December 2024 analysis, The rise of the AI crawler, found that none of the major AI crawlers it measured rendered JavaScript at the time. This pulls every JSON-LD block from the server response and prints the article fields:

curl -s https://example.com/blog/checkout-page-weight \
  | tr '\n' ' ' \
  | grep -o '<script type="application/ld+json"[^>]*>[^<]*</script>' \
  | sed -E 's/<[^>]+>//g' \
  | jq '.. | objects | select(.headline?) | {"@type", headline, author, datePublished, dateModified, image}'

The grep pattern expects type="application/ld+json" written with double quotes as the script's first attribute and no literal < inside the JSON, so adjust it if your templates differ. If it prints nothing, either there is no Article markup in the raw HTML or it is injected after load. Raw HTML vs rendered HTML explains how to tell which.

Then run two validators:

1. Google's Rich Results Test shows how Google parses the Article and flags property problems.
2. The Schema Markup Validator checks the markup against schema.org itself, including types Google does not use.

Last, compare by eye: the headline, author names and dates in the output should match what a reader sees on the page, character for character.

Does Article schema help with AI search?

Be careful with the claims here. Google's AI features documentation says no special schema.org structured data is needed to appear in AI Overviews or AI Mode, and our AI Overviews requirements guide covers what is. Google does say Article markup can help it show better title text, images and dates in Search. OpenAI's, Anthropic's and Perplexity's crawler documentation does not say whether their crawlers read JSON-LD at all.

So treat Article schema as what it is: a precise, machine-readable statement of who wrote a page and when, which costs little and does no harm when it is accurate. Our broader take on structured data for AI search separates what helps from what is hype.

Frequently asked questions

Is Article schema required?

No. Google's Article documentation says there are no required properties. It recommends author, author.name, author.url, datePublished, dateModified, headline and image.

Should I use BlogPosting or Article for a blog post?

Use BlogPosting. It is a subtype of Article, takes the same properties and describes a blog post more precisely. Article is still valid if your templates cannot tell posts and pages apart.

Can the author be an Organization?

Yes, when no individual wrote the piece. Google asks for Organization for organizations and Person for people. Inventing a named person for the byline is the mistake to avoid.

When should I update dateModified?

When the content changes in substance: new information, corrected facts or rewritten steps. Not for typo fixes, design changes or rebuilds. Google lists changing dates to look fresh as a sign of content made for search engines rather than people.

Does Article markup get my content into AI answers?

No markup can promise that. Google says AI Overviews and AI Mode need no special structured data, and other AI operators do not document using JSON-LD. Accurate Article markup removes ambiguity about authorship and dates; it is not a ranking control.

Check your own pages

As a next step, paste one post URL into the free single-page check; it needs no account. If you later want every template on a blog covered, the full audit runs deterministic checks across up to 500 pages, adds human review and delivers a PDF with the evidence and prioritized fixes.