Schema Markup

Schema Markup Implementation

Production-grade structured data implementation covering 20+ schema types, rich result eligibility rules, AI search optimization, and CMS-specific deployment patterns. Handles auditing existing markup, implementing new schema, and fixing validation errors.

Table of Contents

• Operating Modes
• Schema Type Selection Matrix
• Implementation Patterns
• Rich Result Eligibility Rules
• AI Search Optimization
• Knowledge Graph Strategy
• CMS Deployment Guide
• Validation and Testing
• Common Errors and Fixes
• Audit Framework
• Output Artifacts
• Related Skills

Clarify First

Before generating the schema, confirm these inputs. If any is unknown or vague, ASK — do not assume:

• Page type & operating mode — audit existing, implement new, or fix errors; and on what page type (Article, Product, FAQPage, LocalBusiness…) — selects the schema type and workflow
• Target rich result or AI-search goal — which rich result or citation you want to win — sets the required-field checklist and eligibility rules
• CMS / deployment platform — WordPress, Webflow, Shopify, Next.js, or static — drives the deployment method and known warnings (e.g. GTM injection)
• Source page content — the real headline/author/price/Q&A to populate — schema must match visible content or Google penalizes it

Stop rule: ask only the 2-3 that most change the output. If the user says "just draft it," proceed and list your assumptions at the top of the artifact.

Operating Modes

Mode 1: Audit Existing Markup

1. Extract all JSON-LD blocks from the page source
2. Validate required vs recommended fields per schema type
3. Cross-reference with Google's current rich result requirements
4. Score completeness 0-100 per schema block
5. Deliver prioritized fix list with corrected JSON-LD

Mode 2: Implement New Schema

1. Identify page type and matching schema types
2. Select primary + supporting schema combination
3. Generate complete, copy-paste-ready JSON-LD populated with page content
4. Advise on placement method (inline head, CMS plugin, server-side rendering)
5. Test before deployment

Mode 3: Fix Validation Errors

1. Map Google Search Console errors to specific fields
2. Identify root cause (missing field, wrong format, content mismatch)
3. Deliver corrected JSON-LD with change log
4. Explain the fix to prevent recurrence

Schema Type Selection Matrix

Primary Schema by Page Type

Stacking Rules

Always add:

• BreadcrumbList to any non-homepage if breadcrumbs exist on the page
• Organization to the homepage (site-wide identity)

Common valid stacks:

• Article + BreadcrumbList + Person + ImageObject (blog posts)
• Product + Offer + AggregateRating + BreadcrumbList (product pages)
• LocalBusiness + OpeningHoursSpecification + GeoCoordinates + Review (local pages)
• Article + BreadcrumbList + ImageObject (guides; HowTo markup optional, no rich result)

Never combine:

• Product on a page that does not sell a product (Google penalizes misuse)
• Multiple Organization blocks for the same entity (combine into one)
• FAQPage on pages where the Q&A is not visible to users

Implementation Patterns

JSON-LD Format (Always Use This)

JSON-LD is the only format worth implementing. Google recommends it, it lives in the <head>, and it does not touch your HTML markup. Microdata and RDFa are legacy -- do not use them for new implementations.

Placement

<head>
  <script type="application/ld+json">
  {
    "@context": "https://schema.org",
    "@type": "Article",
    "headline": "Your Article Title",
    "author": {
      "@type": "Person",
      "name": "Author Name",
      "url": "https://example.com/authors/name",
      "sameAs": ["https://linkedin.com/in/name", "https://twitter.com/name"]
    },
    "datePublished": "2026-01-15",
    "dateModified": "2026-03-01",
    "image": "https://example.com/images/article-hero.jpg",
    "publisher": {
      "@type": "Organization",
      "name": "Company Name",
      "logo": {
        "@type": "ImageObject",
        "url": "https://example.com/logo.png"
      }
    }
  }
  </script>
</head>

Multiple <script type="application/ld+json"> blocks per page are valid. Use separate blocks for unrelated schema types. Nest related types within one block.

Scope Rules

Rich Result Eligibility Rules

Google does not give rich results for all valid schema. These are the current requirements (as of September 2026). Check the live Search Gallery before promising a rich result — types get retired.

Retired Google rich results (markup is still valid schema.org, but produces no Google search feature):

Article Rich Result

Product Rich Result

FAQPage and HowTo (no Google rich result)

If you still emit FAQPage or HowTo for other consumers, keep it valid and honest: mainEntity as an array of Question items with acceptedAnswer.text (FAQPage), step as an array of HowToStep items (HowTo), and every Q&A pair or step visible on the page. Do not report these as rich-result wins.

AI Search Optimization

AI search systems (Google AI Overviews, Perplexity, ChatGPT Search, Bing Copilot) may use structured data for content understanding and entity recognition. Google states that no special schema.org markup is required to appear in AI Overviews or AI Mode (AI features and your website, as of September 2026) — schema supports understanding; it is not an AI-citation switch.

Why Schema Matters for AI Search

1. Content type classification -- AI systems use @type to determine if content is a how-to, product listing, FAQ, or opinion piece
2. Extractable structure lives on the page -- AI systems extract visible Q&A and step-by-step content; FAQPage/HowTo markup is optional and has no demonstrated citation lift from Google's side
3. Freshness signals -- datePublished and dateModified help AI systems filter by recency
4. Authority signals -- author with sameAs links to known profiles boosts entity recognition
5. Entity connection -- Organization with sameAs links to Wikidata, LinkedIn, and social profiles strengthens entity resolution

AI Search Schema Playbook

Knowledge Graph Strategy

Getting into Google's Knowledge Graph means your entity (person, company, product) is recognized and displayed in panels, AI answers, and cross-referenced searches.

Knowledge Graph Entry Requirements

1. Wikidata entry -- Create or claim your entity on Wikidata.org
2. Wikipedia presence -- A Wikipedia article dramatically increases KG entry probability
3. Consistent NAP -- Name, Address, Phone must be identical across all citations
4. sameAs network -- Organization schema must link to all official profiles

sameAs Best Practices

{
  "@type": "Organization",
  "name": "Your Company",
  "url": "https://yourcompany.com",
  "sameAs": [
    "https://www.wikidata.org/wiki/Q12345678",
    "https://en.wikipedia.org/wiki/Your_Company",
    "https://www.linkedin.com/company/yourcompany",
    "https://twitter.com/yourcompany",
    "https://www.crunchbase.com/organization/yourcompany",
    "https://github.com/yourcompany"
  ]
}

Order of importance for sameAs links:

1. Wikidata (strongest entity signal)
2. Wikipedia
3. LinkedIn
4. Official social profiles
5. Industry directories (Crunchbase, G2, Capterra)

CMS Deployment Guide

WordPress

• Yoast SEO / Rank Math: Auto-generate Article, Organization, BreadcrumbList. Their FAQ/HowTo blocks still emit markup, but it no longer yields Google rich results.
• Custom schema: Add via wp_head action hook or a custom plugin.
• Avoid: Plugins that inject schema via JavaScript (Google may not render it).

Webflow

• Per-page: Add custom code in page settings > Custom Code > Head
• CMS-driven: Use Webflow CMS to generate dynamic JSON-LD via embedded code blocks with CMS field references
• Site-wide: Add Organization schema in Project Settings > Custom Code > Head

Shopify

• Product schema: Auto-generated by most themes. Verify it includes Offer and AggregateRating.
• Article/Blog schema: Usually missing -- add manually via theme.liquid or a schema app.
• Organization: Add to theme.liquid <head> section.

Next.js / Custom React

• Server-side rendering: Generate JSON-LD in the page component and render in <Head>.
• next-seo library: Provides schema components for common types.
• Dynamic pages: Generate schema from your data layer, not hardcoded.

Static sites (Hugo, Jekyll, Gatsby)

• Template-level: Add JSON-LD to layout templates using template variables.
• Per-page: Use frontmatter data to populate schema fields dynamically.

Google Tag Manager (GTM)

• Warning: GTM-injected schema is often NOT indexed by Google because it renders client-side after JavaScript execution.
• Use only when: No other option exists (no CMS access, no dev resources).
• Better alternative: Server-side injection via CMS or template engine.

Validation and Testing