How to Add Article Schema Markup to Blog Posts

Article schema tells search engines exactly what a blog post or news article is about — the headline, author, publish date, and featured image. Without it, Google has to guess these details from your HTML. With it, your search listings can display more accurate titles, larger images, and proper byline dates. Here's how to implement BlogPosting and Article schema correctly using JSON-LD, and how Schema SEO Markup automates this for sites with dozens or hundreds of posts.

What Does Article Schema Do for Your Blog Posts?

Adding Article structured data to blog posts helps Google show better search results for your content. According to Google's Article documentation, this markup enables Google to display enhanced title text, larger-than-thumbnail images, and accurate date information in search results, Google News, and Google Discover.

The practical impact: your blog post listing in search goes from a bare title and meta description to a result with a visible publish date, author attribution, and potentially a featured image. Google also uses the dateModified property to determine content freshness, which influences whether your post appears for time-sensitive queries.

Unlike many other Schema types, Article schema has no strictly required properties. Everything is recommended. This makes it one of the easiest types to implement — but also one of the easiest to implement poorly. The properties you include determine how much value the markup provides.

How Do You Write Article JSON-LD for a Blog Post?

A complete BlogPosting JSON-LD block includes the headline, author, dates, image, and publisher. Here's a well-structured example:

{
  "@context": "https://schema.org",
  "@type": "BlogPosting",
  "headline": "How to Add Article Schema to Blog Posts",
  "author": {
    "@type": "Person",
    "name": "Sarah Chen",
    "url": "https://example.com/team/sarah-chen"
  },
  "datePublished": "2026-04-06T08:00:00-05:00",
  "dateModified": "2026-04-06T08:00:00-05:00",
  "image": [
    "https://example.com/images/blog/article-schema-16x9.webp",
    "https://example.com/images/blog/article-schema-4x3.webp",
    "https://example.com/images/blog/article-schema-1x1.webp"
  ],
  "publisher": {
    "@type": "Organization",
    "name": "Example Company",
    "url": "https://example.com"
  },
  "mainEntityOfPage": {
    "@type": "WebPage",
    "@id": "https://example.com/blog/article-schema"
  }
}

Let's break down each property and why it matters.

Which Properties Should Every Blog Post Include?

Google's documentation lists all Article properties as recommended rather than required. But some carry more weight than others for search appearance:

Property	Purpose	Impact
headline	The title of the article	Helps Google choose the correct title for search results
author.name	Who wrote the article	Enables author attribution in search
author.url	Link to the author's page	Helps Google verify author identity
datePublished	Original publication date	Shown in search results, affects freshness signals
dateModified	Last update date	Indicates content freshness for time-sensitive queries
image	Featured image(s)	Enables larger image thumbnails in search and Discover
publisher	The publishing organization	Identifies the brand behind the content
mainEntityOfPage	Canonical URL of the article	Tells Google this is the primary content of the page

A few implementation details matter here. Dates should be in ISO 8601 format with timezone information — Google defaults to Googlebot's timezone if you omit it. Images should be provided in three aspect ratios (16:9, 4:3, 1:1) with a minimum resolution of 50K pixels (width × height). The author.url should link to a page that uniquely identifies the author, such as an about page or social profile.

What Is the Difference Between Article, NewsArticle, and BlogPosting?

Google supports three Article subtypes. They all produce similar rich results, but each describes a different content format:

• Article — The general-purpose type. Works for any written content: tutorials, guides, opinion pieces, editorial content
• NewsArticle — For time-sensitive news reporting. Appropriate for journalism, press releases, and current events coverage. While there's no markup requirement for Google News eligibility, NewsArticle signals the content's nature
• BlogPosting — For blog entries. The most common choice for company blogs, personal blogs, and content marketing

In practice, Google treats all three similarly when rendering rich results. The choice comes down to accuracy: use NewsArticle if you're publishing news, BlogPosting for blog posts, and Article when neither fits perfectly.

{
  "@context": "https://schema.org",
  "@type": "NewsArticle",
  "headline": "Breaking: New Structured Data Features Announced"
}

{
  "@context": "https://schema.org",
  "@type": "BlogPosting",
  "headline": "10 Ways to Improve Your Schema Markup"
}

The JSON-LD structure is identical across all three types — only the @type value changes.

How Should You Mark Up the Author?

Author markup is one area where Google has specific best practices that are easy to get wrong. Following Google's author markup guidelines correctly helps Google display author information and may influence how your content appears across Google surfaces.

The rules are straightforward but strict:

1. Include all authors. If two people wrote the post, list both as separate author entries — don't combine them into one string
2. Use the correct type. Person for individuals, Organization for company-authored content. Never use the generic Thing type
3. Only put the name in author.name. Don't include job titles, honorific prefixes ("Dr."), or phrases like "posted by." Use the dedicated properties instead

Correct single author:

"author": {
  "@type": "Person",
  "name": "Sarah Chen",
  "url": "https://example.com/team/sarah-chen"
}

Correct multiple authors:

"author": [
  {
    "@type": "Person",
    "name": "Sarah Chen",
    "url": "https://example.com/team/sarah-chen"
  },
  {
    "@type": "Person",
    "name": "Marcus Rivera",
    "jobTitle": "Technical Editor",
    "url": "https://example.com/team/marcus-rivera"
  }
]

Wrong — combined authors:

"author": {
  "@type": "Person",
  "name": "Sarah Chen, Marcus Rivera"
}

For marketing teams publishing under a brand name, you can use Organization as the author type with the company URL. This is valid but provides less granular attribution than naming individual authors.

How Do You Validate Article Schema Before Publishing?

Invalid markup is worse than no markup — it wastes crawl budget and might confuse search engines about your content. Google provides two ways to check your work:

1. Rich Results Test — Paste your page URL or JSON-LD code into Google's Rich Results Test to see if your markup is valid and eligible for rich results. The tool flags errors and warnings in real time
2. Search Console Rich Results Report — After deployment, monitor the structured data status of your pages over time. The report shows valid items, items with warnings, and invalid items

Common validation failures for Article schema:

• Using an image URL that Google can't crawl (blocked by robots.txt or behind authentication)
• Setting datePublished to a future date
• Providing author.url that returns a 404
• Including markup on pages that aren't actually articles (like product pages or category listings)

If you manage a blog with more than a handful of posts, validating each one manually takes significant time. Tools that generate Schema markup automatically handle validation as part of the generation step — every output is checked against Google's requirements before delivery. Pricing starts at $0 with 10 free credits.

How Does Article Schema Work Alongside Other Markup?

A well-structured blog post typically needs multiple Schema types working together. Article schema covers the content itself, but other types handle navigation, discoverability, and supplementary content:

Article + BreadcrumbList — The most common combination. BreadcrumbList shows the page's position in your site hierarchy (e.g., "Home > Blog > Article Schema Guide") while Article describes the post content. Both go in separate <script type="application/ld+json"> blocks.

Article + FAQPage — If your post includes a genuine FAQ section with question-and-answer pairs, add FAQPage schema for that section. Note that as of Google's latest policy update, FAQ rich results only appear for well-known government and health sites, but the markup still provides semantic signals to search engines and AI systems.

Article + Speakable — The speakable property identifies which sections of your article are most suitable for text-to-speech on Google Assistant devices. Point it at your introductory paragraph (the BLUF summary) using a CSS selector:

"speakable": {
  "@type": "SpeakableSpecification",
  "cssSelector": [".post-content > p:first-of-type"]
}

Each of these Schema types goes in its own JSON-LD block. Google handles multiple blocks on the same page without issues, as long as each describes a distinct entity.

What About Article Schema at Scale?

A blog with 10 posts is manageable by hand. A blog with 200 posts — or an agency managing 15 client blogs — is a different problem entirely. Each post needs unique values for headline, datePublished, dateModified, author, and image. Templates help, but they break when post structures vary.

The errors that creep in at scale are predictable: stale dateModified values that never get updated, author URLs pointing to deleted team member pages, images referencing moved or renamed files. Each error is minor on its own, but across hundreds of posts they erode the value of your structured data.

Developers building content platforms typically automate Article schema through their CMS or static site generator. The generation logic reads the post's metadata (title, date, author) and produces the JSON-LD during build. This works well when the team maintains the generation code — but it still requires someone to build and validate the template for each Schema type.

If you'd rather skip the implementation work, Schema SEO Markup handles it by analyzing each URL and generating the correct Article, BreadcrumbList, and supplementary schema types automatically. One credit per page, validated output, ready to deploy. See how the generation process works.