S SCHEMA.BIZ
Content Extends: SocialMediaPosting

Blog Post Schema (BlogPosting)

Blog post schema uses BlogPosting, the schema.org type for an entry in a blog, to describe a post's headline, author, images and dates. Google treats it like any Article markup: no required properties, and the same recommendations. Use it on each post's own page, and keep the dates in the markup in step with the ones readers see.

Last updated:

Does Google show Blog Post schema?

Yes Google reads BlogPosting markup for this feature: Article.

  • Article Active

    Better title text, images and dates for the article in search results.

    Last change in Google's documentation: October 17, 2023. Google added a reminder to give a time zone with each date, and what it assumes without one.

Last checked against Google's documentation: .

What we found on the top 10,000 sites

  • 1.7% of the 5,687 top sites we could analyze use BlogPosting markup (97 sites).
  • 33% of those sites have a missing property Google recommends on their BlogPosting markup, the most common problem we found.

From the home page of each of the Tranco top 10,000 sites and, where we found one, a page it links to, crawled in November 2026. Methodology and every chart: State of Schema 2026.

When to Use BlogPosting

Company and engineering blogs Personal blogs Guest posts Tutorial and how-to posts Product update posts Posts with reader comments

What Google requires

schema.org defines 137 properties a BlogPosting can use, counting the ones it inherits. Google reads only a few of them for each feature; the rest are valid schema.org that Google doesn't require.

Article: 0 required, 5 recommended Google's documentation

Property Google schema.org expects
headline recommended Text
image recommended ImageObject, URL
datePublished recommended Date, DateTime
dateModified recommended Date, DateTime
author recommended Organization, Person

BlogPosting properties

The properties that matter most in practice, of the 137 schema.org defines for BlogPosting. Status is our advice for a complete description; Google's own requirements are in the table above.

Property Type Status Description
headline Text recommended The post's title, as the post page shows it.
image URL or ImageObject recommended The post's featured image, at least 50,000 pixels, ideally in 16x9, 4x3 and 1x1 crops.
datePublished Date or DateTime recommended When the post went live, with a time zone offset.
dateModified Date or DateTime recommended When the post was last revised. Match the "Updated" date the post shows, if it shows one.
author Person or Organization recommended The writer as a Person with a name and a url to their author page. Guest authors get their own Person.
publisher Organization or Person optional Who runs the blog: the company, or the blogger for a personal site.
isPartOf CreativeWork optional The Blog the post belongs to, by @id.
description Text optional The post's excerpt or summary.
articleSection Text optional The blog category the post is filed under.
keywords Text or DefinedTerm optional The post's tags, as a comma-separated string or an array.
comment Comment optional Reader comments shown on the post, each a Comment with author, datePublished and text.
commentCount Integer optional How many comments the post has, including ones on later pages.
wordCount Integer optional The number of words in the post.

JSON-LD Examples

Once you've adapted an example, check your schema markup for errors and Google rich result eligibility.

Minimal:A post with a title, featured image, date and author

What a blog's post template should output at the least: the post's headline, its featured image, its publication time and its author with a link to the author page.

{
  "@context": "https://schema.org",
  "@type": "BlogPosting",
  "headline": "Moving Our Build from Webpack to Vite: What Broke",
  "image": "https://example.com/blog/images/vite-migration-16x9.png",
  "datePublished": "2026-04-08T09:00:00-07:00",
  "author": {
    "@type": "Person",
    "name": "Priya Raman",
    "url": "https://example.com/blog/authors/priya-raman/"
  }
}

Complete:A revised post in a company blog, with tags and category

All five properties Google recommends, the post's excerpt, category and tags, and isPartOf naming the blog. dateModified matches the "Updated" line the post shows after a revision.

{
  "@context": "https://schema.org",
  "@type": "BlogPosting",
  "headline": "Moving Our Build from Webpack to Vite: What Broke",
  "description": "Cold starts went from 41 seconds to 3. Here is what we had to rewrite on the way: environment variables, worker imports and two legacy plugins.",
  "image": [
    "https://example.com/blog/images/vite-migration-1x1.png",
    "https://example.com/blog/images/vite-migration-4x3.png",
    "https://example.com/blog/images/vite-migration-16x9.png"
  ],
  "datePublished": "2026-04-08T09:00:00-07:00",
  "dateModified": "2026-05-02T14:20:00-07:00",
  "author": {
    "@type": "Person",
    "name": "Priya Raman",
    "url": "https://example.com/blog/authors/priya-raman/"
  },
  "publisher": {
    "@type": "Organization",
    "name": "Tidewater Labs",
    "url": "https://example.com/"
  },
  "isPartOf": {
    "@type": "Blog",
    "name": "Tidewater Labs Engineering",
    "url": "https://example.com/blog/"
  },
  "articleSection": "Build tooling",
  "keywords": [
    "vite",
    "webpack",
    "build performance"
  ],
  "wordCount": 2300,
  "mainEntityOfPage": "https://example.com/blog/webpack-to-vite/"
}

Real-world, nested:A post inside its Blog, with its author and two comments

The @graph a post page can carry: the Blog the post belongs to, the BlogPosting pointing at it with isPartOf, the author as a Person node shared with the author page, and the comments the page shows.

{
  "@context": "https://schema.org",
  "@graph": [
    {
      "@type": "Blog",
      "@id": "https://example.com/blog/#blog",
      "name": "Tidewater Labs Engineering",
      "url": "https://example.com/blog/",
      "publisher": {
        "@id": "https://example.com/#organization"
      }
    },
    {
      "@type": "BlogPosting",
      "@id": "https://example.com/blog/webpack-to-vite/#post",
      "headline": "Moving Our Build from Webpack to Vite: What Broke",
      "mainEntityOfPage": "https://example.com/blog/webpack-to-vite/",
      "isPartOf": {
        "@id": "https://example.com/blog/#blog"
      },
      "image": [
        "https://example.com/blog/images/vite-migration-1x1.png",
        "https://example.com/blog/images/vite-migration-4x3.png",
        "https://example.com/blog/images/vite-migration-16x9.png"
      ],
      "datePublished": "2026-04-08T09:00:00-07:00",
      "dateModified": "2026-05-02T14:20:00-07:00",
      "author": {
        "@id": "https://example.com/blog/authors/priya-raman/#person"
      },
      "publisher": {
        "@id": "https://example.com/#organization"
      },
      "commentCount": 2,
      "comment": [
        {
          "@type": "Comment",
          "author": {
            "@type": "Person",
            "name": "Marcus Lindqvist"
          },
          "datePublished": "2026-04-08T17:45:00-07:00",
          "text": "Did you keep the legacy plugins as Rollup plugins, or replace them?"
        },
        {
          "@type": "Comment",
          "author": {
            "@id": "https://example.com/blog/authors/priya-raman/#person"
          },
          "datePublished": "2026-04-09T08:10:00-07:00",
          "text": "One we ported, the other we dropped. Section 4 has the details."
        }
      ]
    },
    {
      "@type": "Person",
      "@id": "https://example.com/blog/authors/priya-raman/#person",
      "name": "Priya Raman",
      "url": "https://example.com/blog/authors/priya-raman/",
      "jobTitle": "Staff Engineer",
      "worksFor": {
        "@id": "https://example.com/#organization"
      }
    },
    {
      "@type": "Organization",
      "@id": "https://example.com/#organization",
      "name": "Tidewater Labs",
      "url": "https://example.com/",
      "logo": "https://example.com/images/tidewater-logo-512.png",
      "sameAs": [
        "https://github.com/example-tidewater-labs"
      ]
    }
  ]
}

Common Blog Post schema mistakes

Mapping the CMS's tags field to a "tags" property

PROP_UNKNOWN: schema.org has no property with this name (names are case-sensitive), so search engines ignore it.

schema.org calls tags keywords. The same goes for "category": use articleSection.

Wrong

{
  "@context": "https://schema.org",
  "@type": "BlogPosting",
  "headline": "Moving Our Build from Webpack to Vite: What Broke",
  "tags": [
    "vite",
    "webpack"
  ]
}

Right

{
  "@context": "https://schema.org",
  "@type": "BlogPosting",
  "headline": "Moving Our Build from Webpack to Vite: What Broke",
  "keywords": [
    "vite",
    "webpack"
  ]
}

A relative author URL from the theme's author link

VALUE_URL: This property expects an absolute URL, including https://. Relative paths can't be resolved reliably.

Themes often reuse the link helper the visible byline uses, which returns a path. Build the absolute URL from the site's base URL.

Wrong

{
  "@context": "https://schema.org",
  "@type": "BlogPosting",
  "headline": "Moving Our Build from Webpack to Vite: What Broke",
  "author": {
    "@type": "Person",
    "name": "Priya Raman",
    "url": "/blog/authors/priya-raman/"
  }
}

Right

{
  "@context": "https://schema.org",
  "@type": "BlogPosting",
  "headline": "Moving Our Build from Webpack to Vite: What Broke",
  "author": {
    "@type": "Person",
    "name": "Priya Raman",
    "url": "https://example.com/blog/authors/priya-raman/"
  }
}

Comments without @type Comment

TYPE_MISSING_NESTED: Nested objects should say what they are too. Without an @type, search engines have to guess, and Google's features may not recognise the object.

Wrong

{
  "@context": "https://schema.org",
  "@type": "BlogPosting",
  "headline": "Moving Our Build from Webpack to Vite: What Broke",
  "comment": [
    {
      "author": {
        "@type": "Person",
        "name": "Marcus Lindqvist"
      },
      "text": "Did you keep the legacy plugins?"
    }
  ]
}

Right

{
  "@context": "https://schema.org",
  "@type": "BlogPosting",
  "headline": "Moving Our Build from Webpack to Vite: What Broke",
  "comment": [
    {
      "@type": "Comment",
      "author": {
        "@type": "Person",
        "name": "Marcus Lindqvist"
      },
      "text": "Did you keep the legacy plugins?"
    }
  ]
}

Using blogPost on the post to name its blog

PROP_NOT_ON_TYPE: This schema.org property isn't defined for the object's type, so search engines may ignore it.

blogPost points the other way: it's a property of Blog, listing the posts. A post names its blog with isPartOf.

Wrong

{
  "@context": "https://schema.org",
  "@type": "BlogPosting",
  "headline": "Moving Our Build from Webpack to Vite: What Broke",
  "blogPost": {
    "@type": "Blog",
    "name": "Tidewater Labs Engineering",
    "url": "https://example.com/blog/"
  }
}

Right

{
  "@context": "https://schema.org",
  "@type": "BlogPosting",
  "headline": "Moving Our Build from Webpack to Vite: What Broke",
  "isPartOf": {
    "@type": "Blog",
    "name": "Tidewater Labs Engineering",
    "url": "https://example.com/blog/"
  }
}

Also watch for

  • Putting a full BlogPosting for every post on the blog's index or category pages. Those pages list posts; the full markup belongs on each post's own page.

  • Marking up comments that aren't on the page, or that load only after a click and never appear in the HTML. Mark up what readers see, and nothing else.

  • Two Article nodes for one post: one from an SEO plugin and one hand-written in the theme. Check what the plugin already outputs before adding markup.

  • Crediting guest posts to the blog owner or to the company. The author is the person who wrote the post.

Where BlogPosting goes in a blog's templates

A blog has a handful of templates, and only one of them gets a BlogPosting: the single-post template. Each post's own URL carries one BlogPosting describing that post, generated from the same fields the template prints: the title, the featured image, the publish and update dates, the author.

The other templates describe something else. The blog's front page is the Blog itself, or a CollectionPage if you'd rather describe the page. Category and tag archives are CollectionPages; an ItemList of the posts they show is optional. Author archives describe a person (see below). None of them should repeat each post's full markup: a list of twenty BlogPosting objects on the home page tells search engines that twenty articles live on one URL.

If the blog runs on WordPress or another CMS with an SEO plugin, look at the page source first. Most such plugins already emit an Article or BlogPosting in a @graph, with the WebPage, the WebSite and the Organization. Adding a second block from the theme gives search engines two descriptions of one post with different details. Either configure the plugin to output BlogPosting, or turn its article output off and write your own; don't do both. The Schema Validator at /markup/validator/ lists every object on a page, which makes duplicates easy to spot.

A BlogPosting inside its Blog

schema.org models a blog as a Blog, a CreativeWork whose blogPost property lists its posts. From the post's side, isPartOf points back at the blog. On the post page, the cleanest markup gives the Blog an @id (the blog's URL plus #blog) and refers to it from the post, so every post names the same blog without repeating its details.

On the blog's index page you can describe the Blog in full, with its name, url, publisher and a blogPost array. Keep those entries short: each a BlogPosting with a headline, url and datePublished, or a reference to the post's @id. The post's own page has the complete description.

A site with several blogs, such as an engineering blog and a product-news blog, gives each one its own Blog node and @id, and each post points at the blog it was published in. The post template can work it out from the post's blog or section field, so it never has to be typed by hand.

The type matters less to Google than to other consumers. Google's Article documentation treats BlogPosting exactly like Article and NewsArticle, and none of its rich results depend on the Blog wrapper. What the structure gives you is a site where each object is described once, in one place, and everything else refers to it.

Author archives and guest authors

Each author's archive page is the natural target for author.url. Google's guidance for article authors suggests linking to a page that describes the author, and an archive with a short bio, a photo and the list of posts does that. Mark that page up as a ProfilePage whose mainEntity is the author's Person, and give that Person an @id such as https://example.com/blog/authors/priya-raman/#person.

Then every post by that author can carry "author": { "@id": "…#person" }, with the Person node written once per page in the @graph. The name, job title and sameAs links stay consistent across hundreds of posts because they come from one author record.

Guest posts get their own Person: the guest's name, a link to their own site or profile in url or sameAs, and no worksFor pointing at your company unless they work there. Posts with several authors list each one in an array. A post written by the team without a named author can credit the organization, as an Organization author.

Comments in BlogPosting markup

Comments are optional. If the post shows reader comments in its HTML, comment can describe them, each a Comment with an author (a Person with a name), a datePublished and the text, and commentCount can give the total, including comments on later pages. Mark up only the comments the page actually shows, with the same text, and skip deleted or held comments.

Google's Article documentation doesn't use comments, and Google's discussion forum markup is for content written by a site's users, not for a blog post whose comments are a side feature. So comment markup is accurate description, not a route to a different result. On a busy blog, marking up the first page of comments and the total count is plenty.

To check the result, render a real post with comments, paste its HTML into the Validator, and compare the comment count with what the page shows. The Generator at /markup/generator/ can build the post's block if you're starting from scratch.

Complete Guide to Blog Post Schema

BlogPosting is the schema.org type for an entry in a blog. In schema.org's hierarchy it sits under SocialMediaPosting, which sits under Article, so every Article property applies to it. Google's Article documentation lists BlogPosting beside Article and NewsArticle and reads all three the same way; the discussion forum feature that takes SocialMediaPosting doesn't apply to blog posts.

Whether to use BlogPosting or Article is a question of what the page is, not of what it earns. If the content lives in a blog (dated entries, an author per post, an archive in date order), BlogPosting says so. A standalone guide on a marketing site, or a documentation page, is closer to Article or TechArticle. Neither choice changes how Google reads the markup.

Blog posts get updated, and that's where their dates matter. When you revise a post substantially and show "Updated May 2, 2026" on it, set dateModified to the same moment and keep datePublished as the original date. Don't move datePublished forward to make an old post look new.

The keywords property holds the post's tags. Google doesn't document using it, but it's a faithful copy of the tags the post shows, and other consumers of the markup can use it. Write it as an array or a comma-separated string, from the same tag list the template prints.

Where BlogPosting sits in schema.org

"A blog post."

Path from Thing: Thing CreativeWork Article SocialMediaPosting BlogPosting

Parent type
SocialMediaPosting
More specific types
LiveBlogPosting

Related Types

Ready to Create BlogPosting Markup?

Use our free generator to create valid BlogPosting JSON-LD markup with a visual form. No coding required.

Open Generator