What Is Blog Post Schema?

Blog post schema — formally called BlogPosting schema — is a type of structured data markup defined by schema.org that communicates the key facts about a blog post directly to search engines. Instead of leaving Google, Bing, and AI systems to guess what your content is about, blog post schema explicitly tells them: this is a blog post, here is who wrote it, here is when it was published, here is what it covers, and here is who published it.

Structured data is added to a page as JSON-LD — a lightweight script block in your page's <head> — and is invisible to human readers but highly legible to search crawlers. Blog post schema sits within the broader schema.org type hierarchy as follows:

account_treeSchema.org Hierarchy for BlogPosting
  • Thing → CreativeWork → Article → SocialMediaPosting → BlogPosting
  • BlogPosting inherits all properties from every type above it in the hierarchy
  • It is the most specific type available for a standard blog post
  • All three types — Article, NewsArticle, and BlogPosting — are Google-recognised for rich results

Understanding this hierarchy matters because it means a BlogPosting has access to every property defined for Article, CreativeWork, and Thing — giving you a rich vocabulary to describe your content with precision.

Why Blog Post Schema Matters

In 2026, blog post schema is no longer a nice-to-have — it's a foundational SEO signal. Here's why it matters across every dimension of search visibility:

1. Rich Result Eligibility

Pages with valid BlogPosting or Article schema are eligible for enhanced SERP features — including article thumbnails in mobile results, author bylines, publication dates, and Top Stories carousel placements. None of these are available without schema markup.

2. Google Discover Visibility

Google Discover — which surfaces content to users before they search — strongly favours structured articles. A missing or broken image property alone can disqualify a post from Discover, costing significant passive traffic.

3. Author and Publisher Trust (E-E-A-T)

Schema markup lets you attach a named author entity with a URL and a publisher organisation with a logo to every blog post you publish. This directly reinforces Google's E-E-A-T signals — Experience, Expertise, Authoritativeness, Trustworthiness — which influence how your content is ranked and cited.

4. AI Overview and Answer Engine Visibility

AI Overviews and AI-powered search assistants rely on structured, machine-readable signals to decide which content to cite in generated answers. Structured data is precisely the kind of context they need. A blog post with complete schema is far more likely to be surfaced in AI-generated summaries than one without it.

5. Knowledge Graph Entity Association

When you use @id identifiers to link your author, organisation, and content together in schema markup, you're creating a mini knowledge graph that Google can anchor to its own entity database. Over time, this builds brand authority and improves how your content is understood across all your pages.

check_circle
The bottom line

Blog post schema is how you teach search engines not just what you said, but who you are, why you're credible, and what your content is worth surfacing — in rich results, in Discover, and in AI-generated answers.

What You Lose Without Blog Post Schema

Choosing not to implement blog post schema isn't a neutral decision — it's a measurable competitive disadvantage. Here's exactly what's at stake:

  • Rich result exclusion. Without valid schema, your blog posts will never appear with image thumbnails, author names, or date stamps in search results. Competitors who have schema markup command significantly more visual attention in the same SERP.
  • Discover disqualification. Google Discover requires a valid image in schema and a high-quality article signal. Missing BlogPosting schema removes you from eligibility entirely.
  • Weaker entity association. Without @id identifiers linking your author and publisher entities, Google cannot confidently associate your content with a known, trusted source. This weakens both E-E-A-T signals and Knowledge Graph inclusion.
  • AI citation gaps. AI systems generating answers from web content prioritise pages where the headline, author, publisher, and subject matter are explicitly declared via schema. Without it, your content is harder to cite with confidence.
  • Lost CTR to schema-equipped competitors. Rich results consistently outperform plain blue links in click-through rate. Every unschema'd blog post is leaving measurable organic traffic on the table.
warning_amber
A common misconception

Many bloggers assume their CMS or theme adds schema automatically. In most cases, the auto-generated schema is incomplete, missing recommended properties, or uses a generic Article type where a more specific BlogPosting would be more appropriate. Always verify your schema with Google's Rich Results Test.

Article vs BlogPosting Schema — What's the Difference?

This is one of the most common questions in structured data implementation. The answer lies in understanding schema.org's type hierarchy and Google's practical guidance.

The Three Google-Recognised Article Types

Google's official documentation for Article rich results explicitly recognises three types:

  • Article — The general type for editorial content. Use this for magazine-style articles, white papers, opinion pieces, and any long-form content that doesn't fit a more specific type.
  • NewsArticle — Specifically for news publications and content intended for Google News. Use this if you're a news publisher targeting the Top Stories carousel and Google News indexing.
  • BlogPosting — Specifically for blog posts. This is the correct and most semantically precise type for any content published in a blog format, with a byline, date, and conversational or instructional tone.

When to Use BlogPosting vs Article

Use BlogPosting when your content is a blog post — it's published in a blog section of a site, has a named author, and is dated. Use Article for general editorial content that doesn't fit the blog format. Use NewsArticle if you're a registered news publisher. When in doubt for a blog, BlogPosting is the right call — it's the most semantically honest type and tells Google exactly what kind of content it's dealing with.

What About Subtypes — TechArticle, AnalysisNewsArticle, and Others?

Schema.org defines many subtypes of Article — including TechArticle, SocialMediaPosting, AnalysisNewsArticle, ReportageNewsArticle, and more. According to testing documented by Flawless Schema, Google's Rich Results Test recognises most of these subtypes as valid Article-based structured data — with one notable exception: the Report type is not currently recognised as an Article rich result type.

info
Best practice for niche subtypes

If you're using a subtype that may not be fully recognised (e.g., Report), use Article or BlogPosting as your primary @type and add the specific subtype via "additionalType": "https://schema.org/Report". This keeps you eligible for rich results while adding semantic precision. See the Report schema example → .

Google's Guidelines and Rich Result Eligibility

Google's structured data documentation sets out specific guidelines for Article schema that apply equally to BlogPosting. Meeting these guidelines is a prerequisite for rich result eligibility — not just for ranking, but for being considered at all.

Key Google Guidelines for Blog Post Schema

  • Schema must describe visible page content. Every property you mark up must correspond to content users can actually see on the page. Marking up content that isn't visible to users is a policy violation and can result in a manual action.
  • The headline must be 110 characters or fewer. Google explicitly recommends keeping article headlines under 110 characters in schema markup, even if your display title is longer.
  • Images must meet minimum dimensions. For rich result eligibility, article images should be at least 1200px wide and in a format Google can crawl (JPG, PNG, GIF, WebP). Google strongly prefers images that appear directly on the page.
  • Dates must be ISO 8601 formatted. Both datePublished and dateModified must use ISO 8601 format — e.g., 2026-05-12T09:00:00.000Z. Incorrect date formats silently invalidate these properties.
  • One schema block per article type per page. Avoid conflicting or duplicate Article/BlogPosting blocks on the same page. Use a single, comprehensive block.

Which Types Qualify for Rich Results?

According to Flawless Schema's documentation, Google's official documentation supports Article, NewsArticle, and BlogPosting as the three primary types for rich results. In practice, the Rich Results Test recognises a broader range of subtypes — but for maximum compatibility, use one of these three as your primary @type.

After implementing schema, always validate using Google's Rich Results Test and the Schema.org Validator. Monitor ongoing performance in Google Search Console → Enhancements → Articles.

Required Properties for Blog Post Schema

Google distinguishes between required properties — without which your schema won't qualify for rich results — and recommended properties that enhance eligibility and semantic value. Here are the properties every blog post schema block must include:

check_circleRequired and Strongly Recommended Properties
  • @context — Always "https://schema.org". Declares the vocabulary being used.
  • @type — Set to "BlogPosting" for blog content. This is the type declaration.
  • headline — Your blog post title, maximum 110 characters per Google's recommendation.
  • author — A Person or Organization entity. Required for rich results and E-E-A-T. Should include name and url.
  • datePublished — Publication date and time in ISO 8601 format. Essential for content freshness signals.
  • image — A URL pointing to the post's featured image, minimum 1200px wide. Required for Discover eligibility and rich results.
  • publisher — An Organization entity with a name, url, and logo (as an ImageObject). Required for article rich results.
  • mainEntityOfPage — A WebPage entity with @id set to the canonical URL. Establishes the page as the primary representation of this post.

Contextual and Semantic Properties

Beyond the required minimum, a well-implemented blog post schema block includes contextual and semantic properties that make your markup richer, more AI-readable, and more useful to Google's Knowledge Graph. These properties go beyond eligibility — they're what separates passable schema from excellent schema.

Content Description Properties

  • description — A concise summary of the post (ideally 150–160 characters). Used by search engines and AI systems to understand the post's scope without parsing the full body.
  • articleBody — A text excerpt from the post content. This gives AI Overview systems a direct text sample to evaluate the quality and relevance of your content.
  • articleSection — The category or topic area of the post (e.g., "Structured Data"). Helps search engines classify the content within your site's thematic structure.
  • keywords — A comma-separated list of topically relevant keywords. While not a direct ranking factor, it reinforces the topical signal of the post.
  • inLanguage — The language code of the post content (e.g., "en"). Important for multilingual sites and international search targeting.

Freshness and Engagement Properties

  • dateModified — The date and time the post was last meaningfully updated. A strong freshness signal — especially important for evergreen content that is regularly revised.
  • wordCount — The approximate word count of the post. A content depth signal that helps search engines understand the comprehensiveness of the article.
  • timeRequired — Estimated reading time expressed as an ISO 8601 duration (e.g., "PT7M" for 7 minutes). Communicates content depth and helps readers in Discover and AI results.
  • isAccessibleForFree — Set to true for publicly accessible posts. Explicitly communicates paywall transparency to Google.

Entity and Ownership Properties

  • isPartOf (Blog entity) — Links the post to its parent blog as a named, structured entity with its own @id. This is the property that elevates a blog post from an isolated document to a node in a content network Google can understand.
  • copyrightHolder — An Organization or Person entity that holds copyright. Reinforces IP ownership and publisher identity signals.
  • backstory — A short explanation of why or how the article was created. An emerging property that provides valuable context for AI parsing and citation decisions.
tips_and_updates
Pro tip: Use @id consistently

If your publisher, copyrightHolder, and isPartOf > publisher all refer to the same organisation, use the same @id URI for all of them (e.g., "https://yoursite.com/#organization"). This tells Google's Knowledge Graph that these references all resolve to the same entity — dramatically strengthening your entity authority.

Standard Blog Post Schema Example

The following is a complete, production-ready BlogPosting schema example for a blog post with a named Person author and an Organisation publisher. This is the recommended starting point for any blog implementing structured data for the first time.

JSON-LD · Standard BlogPosting Schema Example
{
  "@context": "https://schema.org",
  "@type": "BlogPosting",
  "mainEntityOfPage": {
    "@type": "WebPage",
    "@id": "https://www.example.com/blog/your-blog-post-slug"
  },
  "url": "https://www.example.com/blog/your-blog-post-slug",
  "isPartOf": {
    "@type": "Blog",
    "name": "Your Blog Name",
    "publisher": {
      "@type": "Organization",      
      "name": "Your Publisher Name",
      "url": "https://www.example.com",
      "logo": {
        "@type": "ImageObject",
        "url": "https://www.example.com/images/logo.png"
      }
    }
  },
  "headline": "Your Blog Post Title Goes Here",
  "description": "A concise summary of what this blog post covers — 150 to 160 characters is ideal.",
  "image": "https://www.example.com/images/blog/post-featured-image.jpg",
  "articleBody": "A brief excerpt or opening paragraph of your blog post content...",
  "articleSection": "Your Blog Category",
  "keywords": "primary keyword, secondary keyword, related term",
  "datePublished": "2026-05-12T09:00:00.000Z",
  "dateModified": "2026-05-12T09:00:00.000Z",
  "isAccessibleForFree": true,
  "wordCount": "1500",
  "timeRequired": "PT7M",
  "inLanguage": "en",
  "author": {
    "@type": "Person",
    "name": "Jane Doe",
    "url": "https://www.example.com/author/jane-doe"
  },
  "publisher": {
    "@type": "Organization",
    "name": "Your Publisher Name",
    "url": "https://www.example.com",
    "logo": {
      "@type": "ImageObject",
      "url": "https://www.example.com/images/logo.png"
    }
  },
  "copyrightHolder": {
    "@type": "Organization",
    "name": "Your Publisher Name",
    "url": "https://www.example.com"
  }
}

Entity-Based BlogPosting Schema — The Next Level

Standard blog post schema describes the content. Entity-based schema goes further — it connects your content to a network of persistent, named entities that Google can recognise and anchor to its Knowledge Graph. This is where structured data moves from an SEO tactic to a long-term brand authority strategy.

What Makes Schema "Entity-Based"?

The key mechanism is the @id property. When you assign a canonical URI as an @id to an entity — your organisation, your author, your blog — you create a persistent, machine-readable identifier for that entity. Google can now link that entity across multiple pages, multiple schema blocks, and ultimately to its own Knowledge Graph entries.

Entity-based schema typically features:

  • @id on all major entities — organisation, author, and the blog itself
  • Consistent @id reuse — the same URI used whenever the same entity is referenced across the schema block
  • isPartOf with a named Blog entity — connecting the post to a parent blog object with its own identity
  • copyrightHolder as an entity — reinforcing IP ownership with a named, resolvable organisation

Entity-Based BlogPosting Schema Example

The following example is modelled on the schema implementation used on this site. It demonstrates how a fully entity-linked blog post schema block should be structured:

JSON-LD · Entity-Based BlogPosting Schema
{
  "@context": "https://schema.org",
  "@type": "BlogPosting",
  "mainEntityOfPage": {
    "@type": "WebPage",
    "@id": "https://www.example.com/blog/your-post-slug"
  },
  "url": "https://www.example.com/blog/your-post-slug",
  "isPartOf": {
    "@type": "Blog",
    "@id": "https://www.example.com/blog",
    "name": "Your Named Blog",
    "publisher": {
      "@type": "Organization",
      "@id": "https://www.example.com/#organization",
      "url": "https://www.example.com",
      "name": "Your Organisation Name",
      "logo": {
        "@type": "ImageObject",
        "url": "https://www.example.com/images/logo.png"
      }
    }
  },
  "headline": "Your Blog Post Headline (max 110 characters)",
  "description": "A precise description of the post for search engines and AI systems.",
  "image": "https://www.example.com/images/blog/featured.jpg",
  "articleBody": "An excerpt from your post that represents the main content theme...",
  "articleSection": "Your Category",
  "keywords": "keyword one, keyword two, keyword three",
  "datePublished": "2026-05-12T09:00:00.000Z",
  "dateModified": "2026-05-12T09:00:00.000Z",
  "isAccessibleForFree": true,
  "wordCount": "1800",
  "timeRequired": "PT9M",
  "inLanguage": "en",
  "backstory": "This article was written to address common questions about blog post schema implementation.",
  "copyrightHolder": {
    "@type": "Organization",
    "name": "Your Organisation Name",
    "@id": "https://www.example.com/#organization",
    "url": "https://www.example.com"
  },
  "publisher": {
    "@type": "Organization",
    "@id": "https://www.example.com/#organization",
    "url": "https://www.example.com",
    "name": "Your Organisation Name",
    "logo": {
      "@type": "ImageObject",
      "url": "https://www.example.com/images/logo.png"
    }
  },
  "author": {
    "@type": "Organization",
    "@id": "https://www.example.com/#organization",
    "name": "Your Organisation Name",
    "url": "https://www.example.com"
  }
}

The critical pattern here is that publisher, author, copyrightHolder, and isPartOf > publisher all share the same @id. Google's Knowledge Graph interprets these as a single, unified entity — building a durable, authoritative signal around your brand with every post you publish.

That said, the publisher, author, and copyrightHolder do not have to be the same entity. A post written by a named staff writer, published by a media company, and whose copyright is held by a parent corporation represents three distinct entities — each with their own @id. The same principle applies: by assigning a unique, persistent URI to each entity and referencing it consistently wherever that entity appears in your schema, you give search engines an unambiguous map of who created the content, who distributed it, and who owns it. Whether your schema has one shared @id or three distinct ones, the underlying goal is the same — every entity reference resolves to something Google can identify, trust, and connect to a broader knowledge graph.

How to Add Schema Markup to a Blog Post

There are three practical methods for adding blog post schema to your pages. The right choice depends on your CMS, technical setup, and how much control you want over the output.

Method 1: Manual JSON-LD in <head>

Copy your generated JSON-LD schema block and paste it inside the <head> element of your blog post template. This is the cleanest, most direct approach — no plugin dependencies, no CMS limitations, full control over every property.

  • Best for: developers, custom-built sites, PHP/template-based sites
  • Place the <script type="application/ld+json"> block anywhere in <head> or before </body>
  • Update the block whenever the post is significantly revised (especially dateModified)

Method 2: CMS Plugin (WordPress)

Plugins like Yoast SEO, RankMath, and Schema Pro can auto-generate basic Article or BlogPosting schema from your post data. These are convenient but often generate incomplete schema — missing contextual properties like isPartOf, backstory, wordCount, and entity-level @id linking. Always verify plugin-generated schema with Google's Rich Results Test.

Method 3: Use a Schema Generator (Recommended)

A dedicated schema generator gives you the best of both worlds — the completeness of manual implementation with the speed of an automated tool. The Flawless Schema Article Schema Generator is purpose-built for this, covering all three Google-recognised Article types with full support for required, recommended, and contextual properties.

fact_check
Always validate after implementation

Regardless of which method you use, validate your schema with Google's Rich Results Test after every implementation or update. This is the only way to confirm your schema is eligible for rich results and error-free.

Generate Blog Post Schema for Free — Flawless Schema Article Schema Generator

The Flawless Schema Article Schema Generator is a free, browser-based tool that generates complete, Google-approved JSON-LD for blog posts, news articles, and editorial content — in seconds, without writing a line of code.

What Makes It Different

Most schema generators give you a barebones block with five or six properties. The Flawless Schema generator is built to produce markup that's genuinely complete — covering every property Google recommends, not just the minimum required to pass validation.

auto_fix_highGenerator Features
  • All three Google-recognised types: Choose from Article, NewsArticle, or BlogPosting — and then narrow down to a specific subtype (e.g., TechArticle, AnalysisNewsArticle, SocialMediaPosting) using the Article Subtype and Specific Article Type fields. The generator pulls the full set of schema.org-defined types and subtypes so you can be as semantically precise as your content warrants.
  • Multiple author support: Add multiple authors, each as a Person or Organization entity, with names, URLs, and job titles.
  • Full contextual property support: Fields for wordCount, timeRequired (auto-converted to ISO 8601 duration), isAccessibleForFree, backstory, identifier, pageStart, pageEnd, inLanguage, articleSection, and keywords.
  • Field-level validation: URLs, image formats, email addresses, and ISO dates are all validated in real time — preventing the kind of silent errors that invalidate schema without triggering obvious warnings.
  • One-click copy or JSON download: Copy the generated JSON-LD directly to your clipboard or download it as a file for version control.
  • Google Rich Result Eligible output: Every property included is aligned with Google's structured data guidelines and schema.org standards.

The generator also follows an important best practice flagged in its documentation: if you use a subtype that isn't fully recognised by Google's validator (such as Report), the correct approach is to use Article or BlogPosting as the primary @type and add the specific subtype via additionalType. The Flawless Schema generator handles this automatically.

open_in_new
Try the free Article Schema Generator

Generate complete, Google-compliant BlogPosting schema for your next post in under two minutes — no account required. Open the Article Schema Generator →

Frequently Asked Questions

What is blog post schema markup?

Blog post schema markup is structured data — specifically, JSON-LD using the BlogPosting type from schema.org — that communicates the key attributes of a blog post (title, author, publisher, date, image) to search engines and AI systems in a machine-readable format.

What is the difference between BlogPosting and Article schema?

BlogPosting is a subtype of Article — it is more semantically specific and is intended for blog content. Article is the general type for any editorial content. Both are recognised by Google for rich results. Use BlogPosting for blog posts and Article for general editorial pieces where the blog format doesn't apply.

Is blog post schema required for SEO?

Schema is not a direct ranking factor, but it is required for rich result eligibility, Google Discover visibility, and AI citation consideration. Without it, your posts are excluded from these features — making it a significant indirect SEO disadvantage.

Which schema type should I use for my blog — Article or BlogPosting?

Use BlogPosting for blog content. It is the most semantically accurate type and is explicitly supported by Google for article rich results. Article is an acceptable alternative, but BlogPosting gives search engines a clearer signal about the content format.

Does blog post schema help with Google Discover?

Yes — significantly. Google Discover requires a valid, high-resolution image declared in schema, and an article-type schema block. Without BlogPosting or Article schema including a compliant image property, your posts are ineligible for Discover placement.

What properties are required in BlogPosting schema?

The required properties for Google rich result eligibility are: headline, author, datePublished, image, publisher (with logo), and mainEntityOfPage. All other properties discussed in this guide are recommended or contextual.

How do I validate my blog post schema markup?

Use Google's Rich Results Test to check eligibility and errors, and the Schema.org Validator to verify structural correctness. Fix all errors; address warnings where possible. Then monitor performance in Google Search Console under Enhancements → Articles.

Can I use BlogPosting schema on a news site?

Technically yes, but it's not recommended. News publishers should use NewsArticle, which is specifically recognised by Google News and is required for Top Stories carousel eligibility. BlogPosting is best reserved for genuine blog content.

How do I add entity-based schema to my blog posts?

Assign a canonical URI as @id to each major entity in your schema — your author (e.g., https://yoursite.com/author/name), your organisation (e.g., https://yoursite.com/#organization), and your blog (e.g., https://yoursite.com/blog). Reuse the same @id every time that entity is referenced within the schema block. Use isPartOf to connect each post to its parent blog entity.

Blog post schema is one of the highest-return structured data investments you can make for a content site — and with a free generator available, there's no reason to leave it off your pages. If your existing posts need a schema audit or a full custom implementation, our Schema Audit service covers everything. Or generate your first complete BlogPosting schema block right now at flawlessschema.com/article-schema-generator.