Skip to content

Schema Markup in WordPress: The Complete Guide to Shipping JSON-LD Right

Search engines don’t read your site the way your readers do. They parse it. Schema.org markup is the contract that tells Google, Bing, DuckDuckGo, and every AI search engine built on top of them exactly what every page on your site is — an article, a product, a recipe, a FAQ — and which fields mean what. Get it right and you earn rich snippets, sitelinks, AI citations, and a meaningful ranking bump. Get it wrong and you quietly serve invalid JSON that nobody sees.

This is the WordPress-focused walk-through: what schema actually is, which formats to use (and avoid), the handful of types that cover 95% of sites, and how to ship clean JSON-LD without reinventing the ecosystem.

What Is Schema Markup, Really?

Schema.org is a shared vocabulary — roughly 800 types and 1,400 properties — defined jointly by Google, Microsoft, Yandex, and Yahoo in 2011. It gives you a stable, machine-readable way to declare “this page represents a BlogPosting with headline X, author Y, and publish date Z”.

Three formats exist for embedding it:

  • JSON-LD — a <script type="application/ld+json"> block, ideally in <head>. Decoupled from the visible HTML.
  • Microdata — itemscope/itemtype/itemprop attributes inline in the HTML.
  • RDFa — a more expressive set of inline attributes, rarely used.

Use JSON-LD. Everyone else does. Google has explicitly preferred it since 2015. It’s easier to maintain, easier to validate, and doesn’t force your markup and your data to fight each other for layout.

The Schema Types That Matter for 95% of WordPress Sites

TypeUse it forRich result
WebSiteHomepage, alwaysSitelinks search box
OrganizationHomepage, alwaysKnowledge panel, logo in results
Article / BlogPostingEvery blog postHeadline, author, date in SERP
ProductEvery WooCommerce productPrice, reviews, availability
FAQPagePages with FAQsExpanded Q&A accordion in SERP
BreadcrumbListEvery pageBreadcrumb path in SERP
Recipe, HowTo, Event, LocalBusinessNiche but high-impact where applicableDedicated SERP treatments

Focus on the top four. The rest are multipliers for specific content types — add them when the content warrants it, skip them otherwise.

A Minimal, Correct Article Schema Block

Here’s what every WordPress blog post should ship in its <head>:

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "BlogPosting",
  "headline": "The Complete Guide to WordPress Schema Markup",
  "datePublished": "2026-04-19T10:00:00+00:00",
  "dateModified": "2026-04-19T10:00:00+00:00",
  "author": {
    "@type": "Person",
    "name": "Jane Author"
  },
  "publisher": {
    "@type": "Organization",
    "name": "Emnes",
    "logo": {
      "@type": "ImageObject",
      "url": "https://emnes.co/logo.png"
    }
  },
  "mainEntityOfPage": "https://emnes.co/schema-guide/",
  "image": "https://emnes.co/app/uploads/2026/04/cover.webp",
  "description": "How to ship valid JSON-LD in WordPress without reinventing the wheel."
}
</script>

Fields to always include: @type, headline, datePublished, author, publisher, image. Those are the fields Google’s rich-snippet validator checks first.

Common Mistakes That Invalidate Your Schema

  • Missing publisher.logo. Google silently drops the snippet without warning.
  • Date fields in the wrong format. Must be ISO 8601 (2026-04-19T10:00:00+00:00), not the 2025-style 04/19/2026 string.
  • Image URL that 404s. Validator accepts it; real Googlebot requests it and rejects when missing.
  • Duplicate JSON-LD blocks. When two plugins both emit Article schema, Google accepts one and logs an error for the other.
  • Putting schema in the footer. Technically allowed, but bot budget is tight — put it in <head>.

FAQ Schema: The Highest-ROI Addition Most Sites Miss

An FAQ block at the bottom of every long post, marked up as FAQPage schema, gets you an expanded SERP treatment that can double your click-through rate on competitive queries. The markup is small:

{
  "@context": "https://schema.org",
  "@type": "FAQPage",
  "mainEntity": [
    {
      "@type": "Question",
      "name": "How long does schema take to show up in search?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Google recrawls your content on its own schedule. Most sites see rich snippets within 1-2 weeks of adding valid schema."
      }
    }
  ]
}

Rules:

  • The questions and answers must also appear in the visible page content — duplicate-content schema is against policy.
  • Answers can contain inline HTML. Keep them under 300 words each.
  • Don’t use FAQPage for product pages — Google treats that as misuse.

How to Ship Schema in WordPress Without Plugin Wars

Three options, roughly in order of maintainability:

  1. Use one SEO plugin and let it handle every schema type. Don’t combine Yoast + Rank Math + AIOSEO — they stomp on each other. Our own Emnes SEO emits Article, WebSite, Organization, Breadcrumb, and (with WooCommerce) Product out of the box.
  2. Hand-roll it in your theme if you have one or two very specific content types. Works, but bugs are all on you.
  3. Use the Schema.org WordPress plugin (maintained by the WebSchemas team at Google) for niche types like MedicalStudy or SoftwareApplication.

Whatever you pick, validate with Google’s Rich Results Test before shipping. The tool reads your real URL, reports invalid schema, and previews the SERP treatment you’ll get.

How Search Engines Actually Consume Schema Markup

Schema.org isn’t just for Google. In 2026 the consumer list is genuinely multi-entity, and every one of them has a slightly different weighting on different types. Knowing who reads what helps you prioritise which types to ship first.

ConsumerWhat they use it forBiggest wins
Google SearchRich results, knowledge panels, AI OverviewsArticle, Product, FAQ, HowTo, Recipe, Event
Google AI OverviewsDeciding which sources to synthesizeArticle, FAQ — clean schema boosts citation likelihood
BingRich snippets; ChatGPT browsing via Bing indexSame types as Google
Perplexity AISource ranking and citationArticle, Organization
Apple Spotlight / SiriLocal business cardsLocalBusiness, Restaurant, Event
PinterestRich PinsArticle, Product, Recipe
Facebook / LinkedInFalls back to Open Graph before schemaOG tags primary; Article schema secondary

Note what’s absent: DuckDuckGo (uses Bing’s index), Kagi (uses Google + custom ranking), and most AI assistants don’t crawl schema directly — they consume it via the search engine they’re wrapping. Solving for Google and Bing covers the long tail.

The Graph Pattern: Why It’s Worth Adopting

Most plugins emit a single JSON-LD script per schema type. That’s technically valid but inefficient: Google parses each script independently and has to reason about which entities refer to each other.

A better pattern is the @graph array — one script tag containing every entity on the page, each with a stable @id URI, and with @id references between them. Search engines treat this as a connected entity graph and can resolve relationships (this article’s author is this Person, who works for this Organization) without guesswork.

{
  "@context": "https://schema.org",
  "@graph": [
    {
      "@type": "WebSite",
      "@id": "https://example.com/#website",
      "name": "Example",
      "url": "https://example.com/"
    },
    {
      "@type": "Organization",
      "@id": "https://example.com/#organization",
      "name": "Example Inc",
      "logo": {"@type": "ImageObject", "url": "https://example.com/logo.png"}
    },
    {
      "@type": "BlogPosting",
      "@id": "https://example.com/post/#article",
      "headline": "My Article",
      "isPartOf": {"@id": "https://example.com/#website"},
      "publisher": {"@id": "https://example.com/#organization"},
      "author": {"@type": "Person", "name": "Jane Author"}
    }
  ]
}

The @id cross-references mean you only define the Organization once and reference it from every BlogPosting. Maintenance cost drops substantially for large sites.

WooCommerce Product Schema: The Fields That Actually Matter

Product schema is worth more than any other type because Google’s rich results for products are dramatically more visual than article snippets. But most WooCommerce sites emit weak Product schema — the plugin defaults cover only the minimum fields.

Fields that materially affect rich-result eligibility:

  • name, image, description — required.
  • offers.price, offers.priceCurrency, offers.availability — required for the price+availability rich result.
  • offers.priceValidUntil — required for discounted-price display.
  • aggregateRating.ratingValue, aggregateRating.reviewCount — required for the star-rating snippet.
  • review (array) — individual reviews, contributes to review-snippet eligibility.
  • brand — helps Google understand which brand the product belongs to.
  • gtin, mpn, sku — international product identifiers. Required for Google Shopping inclusion.

Missing priceValidUntil is the single most common reason WooCommerce sites lose rich-result eligibility. It’s not required by Schema.org, but Google’s Rich Results validator flags its absence as a warning, and in practice the price disappears from SERP when the warning appears.

The FAQPage Schema That Still Works (With Caveats)

In August 2023 Google narrowed FAQ rich-result eligibility to “well-known, authoritative government and health websites”. Most sites panicked, assumed FAQ schema was dead, and ripped it out. A year and a half on, the situation is more nuanced:

  • FAQ rich results still appear for authoritative sites — government, healthcare, educational institutions.
  • For commercial sites, FAQ schema no longer triggers the expanded Q&A accordion in SERP.
  • But FAQ schema is still ingested by Google — it helps with AI Overviews selection, “People Also Ask” extraction, and voice assistant answers.

Verdict: keep shipping FAQ schema. The direct CTR bump from the accordion is gone for commercial sites, but the indirect signals remain. And if Google ever re-broadens eligibility, you’ll benefit immediately rather than having to retrofit.

HowTo Schema: Underused, High-Impact

HowTo schema is for any step-by-step instructional content: tutorials, recipes, DIY guides, software walkthroughs. It’s less famous than Article or Product but has one of the strongest rich-result treatments when it triggers — Google sometimes displays the entire step list inline in the SERP.

Required fields: name, step (an array of HowToStep), and typically image and totalTime. Each step needs its own name and text.

Common mistake: treating every H2 in a tutorial as a HowToStep. The step array should represent procedural instructions, not topical sections. “Understanding Redis” isn’t a step; “Install Redis via apt” is.

Video Schema: Don’t Miss the Quiet Ranking Boost

If a post embeds video, ship VideoObject schema. The rich-result treatment is subtle but valuable: Google adds a video thumbnail next to your SERP entry, which roughly doubles click-through rate on text-heavy result pages.

Required fields: name, description, thumbnailUrl, uploadDate, contentUrl or embedUrl. For best results add duration (ISO 8601 format: PT5M30S), transcript, and chapter markers via hasPart.

Debugging Schema That Isn’t Triggering Rich Results

A common frustration: schema validates perfectly in Google’s Rich Results Test but no rich snippet appears in production SERP. Reasons, in order of likelihood:

  1. Google hasn’t recrawled yet. Give it 2–4 weeks. Request indexing via URL Inspection to speed it up.
  2. The page doesn’t match the rich-result eligibility rules even though the schema is valid. Rich results require both valid markup and qualifying content. A product page with no real customer reviews won’t show star-snippets even with perfect aggregateRating schema.
  3. Quality threshold not met. Google maintains internal quality thresholds for rich results. Thin, ad-heavy, or poorly-structured pages won’t earn rich snippets regardless of schema.
  4. Manual action on the site. Check Search Console’s Manual Actions report. Structured-data spam penalties specifically disable rich results.
  5. Duplicate schema conflict. Multiple plugins emitting competing markup. Disable all but one SEO plugin.

Shipping Schema in WordPress Without Picking the Wrong Plugin

The market has consolidated around five schema-capable WordPress plugins. Each has trade-offs:

PluginSchema coveragePlays nice with othersBest for
Yoast SEOArticle, WebSite, Org, Product, FAQ, HowTo, LocalBusinessNo — emits full graphExisting Yoast users who want one plugin
Rank Math25+ types including niche onesNo — emits full graphHeavy rich-result users, e-commerce
All in One SEOStandard typesNoFreemium users with upgrade path
Emnes SEOArticle, WebSite, Org, Breadcrumb, ProductYes — detects competitors and defersTeams wanting a clean, PHP 8.3-modern plugin
Schema Pro (RankMath sister)Widest type coverageCan — designed as an addonSpecialist use cases needing rare types

For most WordPress sites, pick one SEO plugin and delete all others. Schema-plugin conflicts are one of the most common causes of duplicate-JSON-LD warnings in Search Console.

A Production Schema Checklist

  1. Every blog post emits BlogPosting + BreadcrumbList inside a single @graph.
  2. Homepage emits WebSite (with potential SearchAction) + Organization.
  3. WooCommerce products emit Product with price, availability, priceValidUntil, GTIN/MPN.
  4. Tutorial content emits HowTo when genuinely step-based.
  5. Posts with embedded video emit VideoObject.
  6. Validate every template type in Rich Results Test before shipping.
  7. Monitor Search Console’s Enhancements reports for indexed-schema counts. Regressions show up there first.
  8. Disable competing SEO plugins to avoid duplicate-schema warnings.

Internationalised Schema: hreflang and Language-Specific Types

Multilingual WordPress sites need a schema approach that respects language. Two specific additions beyond the baseline:

  • inLanguage property on every Article. ISO 639-1 code (e.g. “en”, “fr”). Tells Google which language version of your content this is.
  • translationOfWork pointing at the canonical original article when translations exist. Helps Google understand which language version is the source of truth.

WPML and Polylang both emit language metadata but inconsistently plug into schema plugins. Verify with Rich Results Test on a sample page in each language.

Schema for E-commerce Beyond WooCommerce

Sites on Shopify, BigCommerce, or headless commerce platforms often layer WordPress as a content CMS. The schema picture gets messier:

  • Product pages rendered by the commerce platform emit Product from that platform’s SEO tooling.
  • WordPress-rendered editorial content emits Article.
  • Navigation, organization, and WebSite schema typically live on the commerce platform to match the primary domain.

The trap: both platforms emit Organization and WebSite schema, and they fight. Disable one side. For most setups, the commerce platform “owns” sitewide schema and WordPress emits only Article.

Debug Workflow for Schema Warnings

  1. Run the page through Google’s Rich Results Test.
  2. Note every warning and error. Errors block the rich result; warnings don’t block but reduce eligibility.
  3. For each error, find the emitting template/plugin, fix the field.
  4. For each warning, decide whether to fix or accept. Missing author email is a warning; leaving it unfilled is often reasonable.
  5. Re-run the Rich Results Test. Confirm clean.
  6. Fetch the URL in Search Console’s URL Inspection tool. Request indexing.
  7. Wait 3–5 days. Check SERP for rich snippet appearance.

AI Overviews and Structured Data

Google’s AI Overviews (launched in 2024, expanded in 2025) synthesize answers from multiple sources. Structured data is a strong signal for source selection. Articles with valid BlogPosting schema + FAQPage schema + unambiguous author data get cited more often than equivalently ranked articles without schema.

This isn’t speculation — Google’s public documentation on AI Overviews explicitly calls out structured data as a quality signal.

Related Reading

JSON-LD vs Microdata: Why Google’s Preference Matters

Google prefers JSON-LD and publicly recommends it. The practical reasons: JSON-LD lives in a dedicated script tag, decoupled from visible HTML. It doesn’t fight your markup or layout. Updates are isolated. Microdata is tangled with every element it annotates and breaks when theme templates change. For a WordPress site in 2026, JSON-LD is the only format worth maintaining — and it’s what every major SEO plugin emits by default. If you’re inheriting a site that uses inline microdata, migrate it.

Validation Tooling

  • Google Rich Results Test — canonical validator. Shows eligible rich-result types and any errors/warnings.
  • Schema.org Validator — catches syntactic errors the Google validator glosses over.
  • Yandex Structured Data Validator — useful for sites targeting Russian/CIS markets.

Quick-Reference: The Minimum Viable Schema Stack

If you’re shipping schema from scratch, the minimum viable stack for a blog-plus-company WordPress site: WebSite + Organization on every page, BlogPosting + BreadcrumbList on every article, Product on every WooCommerce product. Validate with Google’s Rich Results Test. Done.

Add HowTo when you publish tutorials. Add VideoObject when embedding video. Ignore everything else until a specific use case demands it.

Site-Level vs Post-Level Schema Strategy

A common misconception is that every post needs its own Organization and WebSite schema. In practice, those two belong at the site level — defined once on the homepage and referenced by @id everywhere else. Per-post schema should only include entities specific to that post: the BlogPosting itself, its author as a Person, and a BreadcrumbList.

This structure keeps JSON-LD payloads small (important for CWV), removes duplicate-entity warnings in Google’s validator, and makes site-wide changes (e.g. updated company phone number) a one-place edit instead of a bulk update.

Frequently Asked Questions

Do I need schema markup if my content is already good?

Schema doesn’t replace good content — it translates it. Without schema, Google has to guess that your blog post is a blog post. With schema, it knows. On competitive queries, that certainty routinely wins two-to-three-position rank improvements.

Will AI search engines use schema markup?

Yes. Every major AI search product — ChatGPT’s browsing, Perplexity, Google AI Overviews, Claude’s web search — uses structured data to decide which sources to cite. Clean schema is a first-class AI-discoverability signal in 2026.

Can I have multiple schema types on one page?

Yes, and you should. Every blog post should carry BlogPosting + BreadcrumbList + FAQPage (when applicable). Group them in a @graph array to avoid duplicate script tags.

Does schema work on custom post types?

Only if your SEO plugin knows about them. Most plugins default to Article for all custom post types, which is usually fine. For niche types (e.g. a “Case Study” CPT that should be TechArticle or ScholarlyArticle), set the schema type explicitly on each post.