Schema markup: the complete implementation guide by page type

TL;DR: Schema markup is JSON-LD code that tells search engines what a page is about in a machine-readable format, and it does not directly move rankings, but it does enable rich results and helps AI systems parse your content faster. Google has quietly killed two of the most popular types (FAQ and HowTo), so this guide gives you working JSON-LD templates for the 12 page types that still matter, plus the validation steps to confirm they actually work.

What schema markup actually does for SEO
JSON-LD vs microdata vs RDFa
The rich results Google still shows in 2026
Organization and homepage schema
Local business schema
Article and blog post schema
Product and merchant listing schema
Review and rating schema: the self-serving rule
Event schema
Job posting schema
Video schema
Breadcrumb schema
Software and SaaS application schema
Does schema markup help with AI Overviews and ChatGPT?
How to validate your schema markup
Common schema mistakes that get you disqualified
Frequently asked questions
Key takeaways

What schema markup actually does for SEO

Schema markup is structured data written in a vocabulary called schema.org, a shared standard founded by Google, Microsoft, Yahoo, and Yandex, and governed since April 2015 by the W3C Schema.org Community Group. As of this writing, the vocabulary defines 823 types, 1,529 properties, 19 datatypes, 96 enumerations, and 535 enumeration members, according to schema.org’s own type list. You will use fewer than 20 of them.

Google is explicit that structured data is not a ranking factor. Its own documentation states that adding structured data “can enable search results that are more engaging to users and might encourage them to interact more with your website,” calling these enhanced displays “rich results” rather than ranking improvements (Google Search Central). Schema does not push you up the results page. It changes how your existing position looks and what a crawler can extract from it without guessing.

That distinction matters more than most guides admit. A product page with flawless Merchant Listing markup and a page five with zero markup can rank identically. What schema buys you is a star rating under your blue link, a price and availability badge, an event date in the SERP, or a paragraph that an AI system can lift cleanly because the facts are already labeled instead of buried in prose. It is a formatting and extraction layer, not a ranking lever.

Google also does not guarantee display. Its structured data guidelines state plainly that “Google does not guarantee that your structured data will show up in search results, even if your page is marked up correctly” (Google Search Central structured data guidelines). Correct markup is a prerequisite for eligibility, not a promise of a rich result. Every template below gets you eligible. None of them guarantees the badge.

JSON-LD vs microdata vs RDFa

Google supports three structured data formats: JSON-LD, Microdata, and RDFa, and it names JSON-LD as the recommended format in its own guidelines (Google Search Central). JSON-LD lives in a single <script type="application/ld+json"> block in the page head or body, separate from the visible HTML. Microdata and RDFa are inline attributes attached directly to the HTML elements they describe.

The practical difference is maintenance cost. Inline formats break when a designer changes a <div> structure, because the markup is welded to the layout. JSON-LD is a standalone block a developer can generate, template, or inject through a CMS field without touching the template’s HTML at all. Every template in this guide uses JSON-LD for that reason, and it is what you should default to unless a specific plugin or platform only outputs microdata.

One rule governs all three formats: the markup has to match what a visitor actually sees on the page. Google’s guidelines say directly, “Don’t mark up content that is not visible to readers” (Google Search Central). Marking up a price, rating, or availability status that is not visible on the rendered page is a policy violation, not a growth hack.

The rich results Google still shows in 2026

Two of the most widely implemented schema types in the last decade are dead. Google removed HowTo rich results from both desktop and mobile in September 2023, stating in its changelog that “this rich result is no longer shown in search results” (Google Search Central changelog). FAQ rich results followed the same path: Google restricted FAQ display to “well-known, authoritative government and health websites” starting in September 2023, added a formal deprecation notice on May 8, 2025 stating the feature “will no longer appear in Google Search starting May 7, 2026,” and removed the documentation entirely in its June 15, 2025 changelog (Google Search Central).

If your SEO checklist still tells you to wrap every FAQ section in FAQPage schema for a rich result, that checklist is at least two years out of date. You can leave the markup in place; Google’s guidance does not require removal, and other engines may still read it. But budget zero expectation of a SERP feature from it.

Here is what is still live, per Google’s structured data gallery (Google Search Central):

Category	Live schema types
Content	Article, Breadcrumb, Discussion Forum, Profile Page, Q&A Page
Commerce	Product, Review Snippet, Merchant Listing, Carousel
Local and org	Local Business, Organization, Image Metadata
Employment	Job Posting, Employer Aggregate Rating
Media	Video, Recipe, Movie, Event
Specialized	Speakable, Subscription/Paywalled Content, Software App, Book Actions, Course, Dataset, Math Solver

That is roughly twenty active types out of 823 defined on schema.org. Everything below covers the ones that show up on a normal commercial site.

Organization and homepage schema

Organization schema tells search engines who owns the site, and it is the foundation everything else references back to through @id. Put it on your homepage, once.

{
  "@context": "https://schema.org",
  "@type": "Organization",
  "@id": "https://example.com/#organization",
  "name": "Example Co",
  "url": "https://example.com",
  "logo": "https://example.com/logo.png",
  "sameAs": [
    "https://www.linkedin.com/company/example-co",
    "https://x.com/examplecoinc"
  ],
  "contactPoint": {
    "@type": "ContactPoint",
    "telephone": "+1-555-555-0100",
    "contactType": "customer service"
  }
}

The sameAs array is the field most sites skip. It links your official social and knowledge-graph profiles to the same entity, which helps Google (and increasingly, AI systems doing entity resolution) confirm you are one consistent organization rather than several unrelated mentions across the web. Feed it real, active profile URLs. An empty or stale array is worse than omitting the property.

Product-led teams building SaaS SEO programs usually pair Organization schema with SoftwareApplication markup on the product page itself, covered later in this guide.

Local business schema

If you have a physical location or a defined service area, LocalBusiness schema (or one of its 50+ subtypes, like Restaurant or Dentist) is the single highest-value type on this list, because it feeds directly into how Google understands your entity for Maps and the local pack. Pair it with an optimized Google Business Profile rather than treating either as a substitute for the other.

{
  "@context": "https://schema.org",
  "@type": "LocalBusiness",
  "name": "Example Dental Clinic",
  "image": "https://example.com/storefront.jpg",
  "address": {
    "@type": "PostalAddress",
    "streetAddress": "123 Main St",
    "addressLocality": "Austin",
    "addressRegion": "TX",
    "postalCode": "78701",
    "addressCountry": "US"
  },
  "geo": {
    "@type": "GeoCoordinates",
    "latitude": 30.2672,
    "longitude": -97.7431
  },
  "telephone": "+1-512-555-0100",
  "openingHoursSpecification": [
    {
      "@type": "OpeningHoursSpecification",
      "dayOfWeek": ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday"],
      "opens": "09:00",
      "closes": "17:00"
    }
  ],
  "priceRange": "$$"
}

Run this on every location page independently, with its own address, geo coordinates, and hours. Do not copy one block across a multi-location site and swap only the city name; the geo coordinates and openingHoursSpecification need to be accurate per location or you create a trust problem, not an SEO win. Industries under closer scrutiny, like law firms and financial advisors, should treat every field here as a factual claim, because it is one.

Article and blog post schema

Article schema (and its BlogPosting and NewsArticle subtypes) is what makes your post eligible for the Article rich result and top stories carousels, and it is a baseline signal for how AI crawlers attribute authorship and freshness.

{
  "@context": "https://schema.org",
  "@type": "BlogPosting",
  "headline": "Schema markup: the complete implementation guide by page type",
  "image": "https://example.com/images/schema-guide-cover.jpg",
  "author": {
    "@type": "Person",
    "name": "Jane Doe",
    "url": "https://example.com/authors/jane-doe"
  },
  "publisher": {
    "@type": "Organization",
    "name": "Example Co",
    "logo": {
      "@type": "ImageObject",
      "url": "https://example.com/logo.png"
    }
  },
  "datePublished": "2026-08-02",
  "dateModified": "2026-08-02",
  "mainEntityOfPage": {
    "@type": "WebPage",
    "@id": "https://example.com/blog/schema-markup-complete-guide"
  }
}

dateModified is the field most content teams let rot. If you refresh a post’s stats and claims, as part of a content refresh cycle, update this timestamp to match. A page claiming a dateModified of last week with visibly stale 2023 statistics is exactly the kind of mismatch Google’s structured data policy is written to catch, and it undermines the freshness signal you were trying to send in the first place.

Product and merchant listing schema

Google splits product markup into two tracks: Product Snippets, for editorial or review pages where a visitor cannot buy directly, and Merchant Listings, for pages where the product is actually purchasable, which support fields like shipping cost, return policy, and size variants (Google Search Central). Google’s own guidance is to include as much of the optional detail as you have data for: “it is recommended to provide as much rich product information as available.”

{
  "@context": "https://schema.org",
  "@type": "Product",
  "name": "Example Running Shoe",
  "image": "https://example.com/images/running-shoe.jpg",
  "description": "Lightweight trainer with breathable mesh upper.",
  "sku": "RS-2026-BLK-10",
  "brand": {
    "@type": "Brand",
    "name": "Example Athletic"
  },
  "offers": {
    "@type": "Offer",
    "url": "https://example.com/products/running-shoe",
    "priceCurrency": "USD",
    "price": "89.99",
    "availability": "https://schema.org/InStock",
    "shippingDetails": {
      "@type": "OfferShippingDetails",
      "shippingRate": {
        "@type": "MonetaryAmount",
        "value": "0",
        "currency": "USD"
      }
    },
    "hasMerchantReturnPolicy": {
      "@type": "MerchantReturnPolicy",
      "returnPolicyCategory": "https://schema.org/MerchantReturnFiniteReturnWindow",
      "merchantReturnDays": 30
    }
  },
  "aggregateRating": {
    "@type": "AggregateRating",
    "ratingValue": "4.6",
    "reviewCount": "218"
  }
}

Google added shippingDetails and hasMerchantReturnPolicy as required fields for merchant listing eligibility, not optional extras, so ecommerce teams that only markup price and availability are leaving eligibility on the table. This is the same category page discipline that matters for ecommerce category pages: the product-level detail has to be accurate at the individual SKU, not aggregated at the category.

Review and rating schema: the self-serving rule

This is the type most sites get wrong, and the mistake actively disqualifies you rather than just underperforming. Google’s review snippet guidelines state that “if the entity that’s being reviewed controls the reviews about itself, their pages that use LocalBusiness or any other type of Organization structured data are ineligible for star review feature” (Google Search Central). This rule went into effect in September 2019 and it is still enforced.

In practice: you cannot markup your own testimonials page with AggregateRating schema and expect stars in the SERP. That is a self-serving review by definition, and Google’s algorithm is built specifically to exclude it. The exception is Product schema, which is allowed to carry ratings even when they are collected and displayed by the product owner, because that pattern (think retail sites) is treated differently from an organization vouching for itself.

Google also requires that ratings be “sourced directly from users” and explicitly prohibits letting human editors “create, curate, or compile ratings for local businesses” (Google Search Central). If your review widget lets an internal team hand-pick which five-star quotes get published as structured ratings, that violates the policy even if every quote is real.

Schema use case	Eligible for star rating?
Product page, ratings collected via your own review system	✓ Yes, via `Product` + `AggregateRating`
Third-party review platform embed (Trustpilot, G2) on your own domain	✓ Yes, if sourced from real user reviews
Organization or LocalBusiness page, self-collected testimonials	✗ No, ineligible under the self-serving rule
Editorially curated “best quotes” selected by your team	✗ No, violates the “sourced directly from users” requirement
Third-party editorial review of your product (someone else’s site)	✓ Yes, using `Review` schema on their page

Event schema

Event schema is the cleanest win-to-effort ratio on this list for anyone running webinars, conferences, or in-person events, because the eligibility bar is low and the SERP feature (date, location, and ticket link directly in the result) is still fully live.

{
  "@context": "https://schema.org",
  "@type": "Event",
  "name": "SEO Strategy Workshop 2026",
  "startDate": "2026-09-15T14:00:00-05:00",
  "endDate": "2026-09-15T16:00:00-05:00",
  "eventAttendanceMode": "https://schema.org/OnlineEventAttendanceMode",
  "eventStatus": "https://schema.org/EventScheduled",
  "location": {
    "@type": "VirtualLocation",
    "url": "https://example.com/webinar"
  },
  "offers": {
    "@type": "Offer",
    "url": "https://example.com/webinar/register",
    "price": "0",
    "priceCurrency": "USD",
    "availability": "https://schema.org/InStock"
  },
  "organizer": {
    "@type": "Organization",
    "name": "Example Co",
    "url": "https://example.com"
  }
}

Set eventStatus correctly and update it. An event marked EventScheduled after it has been cancelled or rescheduled is a direct violation of the “matches visible content” rule, and Google has dedicated status values (EventCancelled, EventPostponed, EventRescheduled) specifically so you do not have to delete the markup, just update one field.

Job posting schema

JobPosting schema is required, not optional, if you want listings to appear in Google’s job search experience at all. Without it, your postings are invisible to that surface regardless of how well the page otherwise ranks.

{
  "@context": "https://schema.org",
  "@type": "JobPosting",
  "title": "Senior Backend Engineer",
  "description": "Build and maintain our core API infrastructure.",
  "datePosted": "2026-08-01",
  "validThrough": "2026-10-01T00:00:00-05:00",
  "employmentType": "FULL_TIME",
  "hiringOrganization": {
    "@type": "Organization",
    "name": "Example Co",
    "sameAs": "https://example.com",
    "logo": "https://example.com/logo.png"
  },
  "jobLocation": {
    "@type": "Place",
    "address": {
      "@type": "PostalAddress",
      "addressLocality": "Austin",
      "addressRegion": "TX",
      "addressCountry": "US"
    }
  },
  "baseSalary": {
    "@type": "MonetaryAmount",
    "currency": "USD",
    "value": {
      "@type": "QuantitativeValue",
      "minValue": 140000,
      "maxValue": 180000,
      "unitText": "YEAR"
    }
  }
}

validThrough is the field that quietly kills most JobPosting implementations. Leave a listing live past its expiration date and Google will eventually flag the domain for stale job postings, which can suppress the whole feed. If you are automating listings as part of a broader SEO automation pipeline, this is one of the few fields worth a hard expiry job rather than manual cleanup.

Video schema

VideoObject schema is what makes a video eligible for a thumbnail and duration badge directly in search, and it is increasingly what AI systems use to cite a specific timestamp inside a video rather than the whole page. Full implementation detail, including how it interacts with YouTube’s own indexing, lives in the video schema markup guide and the broader YouTube SEO guide. The core block:

{
  "@context": "https://schema.org",
  "@type": "VideoObject",
  "name": "How to implement schema markup in 10 minutes",
  "description": "A walkthrough of JSON-LD structured data implementation.",
  "thumbnailUrl": "https://example.com/video-thumb.jpg",
  "uploadDate": "2026-08-02",
  "duration": "PT10M32S",
  "contentUrl": "https://example.com/videos/schema-walkthrough.mp4",
  "embedUrl": "https://example.com/embed/schema-walkthrough"
}

duration uses ISO 8601 format (PT10M32S means 10 minutes, 32 seconds), and it is the field most CMS video embeds get wrong by omitting it entirely, since it is not visually obvious the way a thumbnail is.

BreadcrumbList is the lowest-effort, highest-adoption type on this list, because it maps directly to a navigation element most sites already have. It replaces the raw URL in the SERP with a readable path (Home > Category > Product), which is a small but real click-through improvement.

{
  "@context": "https://schema.org",
  "@type": "BreadcrumbList",
  "itemListElement": [
    {
      "@type": "ListItem",
      "position": 1,
      "name": "Home",
      "item": "https://example.com"
    },
    {
      "@type": "ListItem",
      "position": 2,
      "name": "Blog",
      "item": "https://example.com/blog"
    },
    {
      "@type": "ListItem",
      "position": 3,
      "name": "Schema markup guide",
      "item": "https://example.com/blog/schema-markup-complete-guide"
    }
  ]
}

Automate this from your actual URL hierarchy or CMS taxonomy rather than hand-writing it per page. Manual breadcrumb markup drifts out of sync with real navigation the first time someone restructures the site, and a mismatch between the markup and the live breadcrumb trail is exactly the visible-content violation Google’s guidelines flag.

Software and SaaS application schema

SoftwareApplication schema is built for downloadable or web-based software and supports a rating and price display directly in the SERP. For SaaS product and pricing pages, it is one of the few remaining rich-result types with real commercial pull, and it belongs alongside the broader page architecture covered in the SaaS SEO guide.

{
  "@context": "https://schema.org",
  "@type": "SoftwareApplication",
  "name": "Example Analytics",
  "applicationCategory": "BusinessApplication",
  "operatingSystem": "Web",
  "offers": {
    "@type": "Offer",
    "price": "49.00",
    "priceCurrency": "USD"
  },
  "aggregateRating": {
    "@type": "AggregateRating",
    "ratingValue": "4.7",
    "ratingCount": "312"
  }
}

The same self-serving review rule from earlier applies here if your aggregateRating is sourced from testimonials you curated yourself. Pull the rating from an actual review platform, or from your own in-product review collection where every submitted rating is published, not cherry-picked.

Does schema markup help with AI Overviews and ChatGPT?

Google is direct about this: “You don’t need to create new machine readable files, AI text files, or markup to appear in these features. There’s also no special schema.org structured data that you need to add” (Google Search Central, AI features documentation). That statement covers AI Overviews and AI Mode specifically. Structured data is not a listed requirement for either.

That is not the same as saying schema is useless for AI visibility, and the distinction is worth sitting with rather than collapsing into a slogan. AI systems, whether Google’s own or ChatGPT and Perplexity pulling from the open web, still have to parse your page to generate an answer. A page with clean Product, Article, or FAQ-adjacent structured facts gives a language model a pre-labeled set of entities and values to lift, which reduces the chance of misreading a price or a date buried three paragraphs into unstructured prose. Schema does not buy citation eligibility. It reduces extraction error once you are already being considered. Ahrefs’ own guide to schema markup notes that practitioner testing on schema’s influence on AI search results (including informal experiments by SEO consultant Mark Williams-Cook) remains anecdotal rather than backed by a controlled, published study, which is a fair summary of where the evidence actually stands right now (Ahrefs). For the fuller breakdown of what does and does not carry weight for AI citation specifically, see the structured data and AI search necessity guide and run your site through the AI visibility audit checklist before assuming markup is your bottleneck.

flowchart TD
    A[Do you have a physical location or service area?] -->|Yes| B[LocalBusiness schema]
    A -->|No| C[What type of page is this?]
    C --> D[Blog post or article]
    C --> E[Product for sale]
    C --> F[Event, webinar, or class]
    C --> G[Job listing]
    C --> H[Video content]
    C --> I[Software or SaaS product]
    D --> D1[Article / BlogPosting schema]
    E --> E1[Product + Merchant Listing schema]
    F --> F1[Event schema]
    G --> G1[JobPosting schema]
    H --> H1[VideoObject schema]
    I --> I1[SoftwareApplication schema]
    B --> J[Add Organization schema site-wide]
    D1 --> J
    E1 --> J
    F1 --> J
    G1 --> J
    H1 --> J
    I1 --> J
    J --> K[Add BreadcrumbList on every indexable page]
    K --> L[Validate with Rich Results Test before deploy]

How to validate your schema markup

Two tools do this job and they check different things. Google’s Rich Results Test checks whether your markup makes the page eligible for a specific Google rich result feature, and it is the one to use before shipping anything you expect to show up in Google’s SERP. The Schema Markup Validator, maintained by the schema.org community independent of any single search engine, checks whether your JSON-LD is syntactically valid against the schema.org vocabulary itself, regardless of whether Google supports a rich result for that type.

Run both, in this order: syntax validation first, then rich-result eligibility. A block can pass the Schema Markup Validator (it is valid JSON-LD, correctly typed) and still fail the Rich Results Test, because Google enforces its own eligibility rules on top of pure syntax, like the self-serving review restriction covered above. Passing only the syntax check tells you the code will not throw an error. It does not tell you Google will show anything for it.

Re-run validation after every template change and on a recurring schedule, not just at launch. A CMS update, a plugin change, or a developer editing the page template can silently break a JSON-LD block that was working fine for months, and nothing in your normal QA process will surface that unless structured data checks are part of it.

Common schema mistakes that get you disqualified

Most schema problems are not exotic. They are the same handful of errors repeated across different page types.

Markup that does not match visible content. A price in the schema that differs from the price on the page, or a rating that appears in the JSON-LD but nowhere on the rendered page, violates Google’s core structured data policy directly and can cost you eligibility for the entire type, not just that one field.

Copy-pasted LocalBusiness blocks across locations. Reusing one location’s address, geo coordinates, or hours across a multi-location site’s other pages creates factually wrong markup on every page except the original.

Self-serving reviews on Organization or LocalBusiness pages. Covered in detail above; this is the single most common reason a site expects star ratings and never gets them.

Orphaned or duplicate @id references. When multiple schema blocks reference the same @id but describe conflicting details (two different addresses for the same Organization @id, for instance), validators may pass individual blocks while the combined graph is contradictory.

Missing required fields for the type. Merchant Listing eligibility specifically requires shippingDetails and hasMerchantReturnPolicy now, not just price and availability. Older templates built before these requirements existed silently fall short.

Markup for deprecated rich results. FAQPage and HowTo markup is harmless to leave in place, but treating it as an active SEO investment in 2026 wastes engineering time that could go toward types Google still displays.

Frequently asked questions

What is schema markup in SEO?

Schema markup is structured data, usually written as JSON-LD, that labels the content on a page (a product’s price, an article’s author, an event’s date) in a vocabulary search engines and AI systems can parse directly. It does not change rankings; it changes whether Google can show a rich result and how cleanly a crawler or language model can extract facts from the page.

Does schema markup improve Google rankings?

No. Google states directly that structured data enables rich results, not ranking improvements. It can indirectly help click-through rate by making your result more visually prominent, but that is a distinct effect from ranking position, and a page can rank first with zero markup.

Is FAQ schema still worth implementing in 2026?

No, for Google. Google removed FAQ rich results from most sites in September 2023, restricted the remainder to authoritative government and health sites, and confirmed full removal effective May 7, 2026. You can leave existing FAQPage markup in place since Google does not require removal, but do not build new pages expecting an FAQ rich result.

Is HowTo schema still active?

No. Google removed HowTo rich results from both desktop and mobile search in September 2023. The markup itself does not violate anything if it stays on your site, but it produces no visible SERP feature in Google Search anymore.

What is the difference between JSON-LD, microdata, and RDFa?

All three are valid structured data formats Google accepts. JSON-LD is a standalone script block separate from your HTML, which makes it easier to generate and maintain. Microdata and RDFa are inline attributes embedded directly in HTML elements. Google recommends JSON-LD as the default choice.

Can I add multiple schema types to one page?

Yes. A single page commonly carries Organization, BreadcrumbList, and a content-specific type (Article, Product, or Event) simultaneously. Google recommends nesting related items or connecting them with shared @id references so the types describe one coherent entity rather than conflicting claims.

Why don’t I have star ratings even though I added review schema?

The most common cause is the self-serving review restriction: Google disqualifies LocalBusiness or Organization pages from star ratings when the entity being reviewed controls the reviews shown. Product schema is treated differently and can carry ratings even when self-collected, provided they come directly from real users.

How do I validate my schema markup is working?

Run it through Google’s Rich Results Test to check eligibility for a specific rich result, and through the schema.org community’s Schema Markup Validator to confirm the JSON-LD syntax itself is valid. Both checks answer different questions, so use both before and after any template change.

Does schema markup help my content get cited by ChatGPT or Perplexity?

Google states no special structured data is required to appear in its own AI features. For third-party AI tools crawling the open web, clean structured data likely reduces extraction errors by pre-labeling facts, but it is not established as a direct citation trigger. Content clarity and factual accuracy carry more of that weight than markup alone.

What happens if my schema markup doesn’t match the visible page content?

It violates Google’s structured data guidelines directly, which state you should not mark up content that is not visible to readers. This can disqualify the page from that rich result type entirely, and repeated violations across a site can affect trust in your markup more broadly.

Do I need schema markup on every page of my site?

No. Prioritize by page type and commercial value: product and category pages for ecommerce, LocalBusiness on every location page, Article on blog content, JobPosting on every open role, and Organization site-wide once. Pages with no matching schema.org type do not need forced markup.

What is the `@id` property for and why does it matter?

@id gives an entity (an Organization, a Product, a Person) a stable identifier that other schema blocks on the same page, or across pages, can reference to confirm they describe the same thing. Without it, a crawler has no reliable way to connect an Article’s author to that same person’s full Person entity elsewhere on the site.

Is Product schema required for ecommerce sites?

Not strictly required to rank, but functionally required for Merchant Listing eligibility, which is what surfaces price, availability, shipping, and return policy directly in search results. Ecommerce sites skipping it are giving up a real SERP feature competitors are likely already using.

How often should I update my Article schema’s dateModified field?

Every time you materially update the page content, including statistics, claims, or structural changes. Leave it unchanged for typo fixes or formatting tweaks. A dateModified that says “today” on a page with three-year-old data is a mismatch Google’s guidelines are built to penalize.

Can I use schema markup that Google doesn’t support?

Yes. Schema.org defines 823 types; Google’s rich results gallery supports roughly twenty. Using an unsupported type produces no Google rich result, but other engines, tools, or your own site’s internal parsing may still use it. It is not harmful, just not rewarded by Google specifically.

What’s the difference between Product Snippets and Merchant Listings?

Product Snippets are for pages where a visitor cannot directly buy the item, like an editorial review page, and can include pros-and-cons style detail. Merchant Listings are for pages where the product is directly purchasable and require additional fields like shipping cost and return policy to be fully eligible.

No direct ranking effect, but it can improve click-through rate by replacing a raw URL in the SERP with a readable navigation path. It is low effort to implement if your site already has a consistent URL hierarchy or CMS-driven breadcrumb trail to pull from.

How do I mark up a webinar or virtual event?

Use Event schema with eventAttendanceMode set to OnlineEventAttendanceMode and location set to a VirtualLocation type pointing at the event URL. Keep eventStatus current if the event is rescheduled or cancelled; Google provides dedicated status values for both cases instead of requiring markup removal.

Is JobPosting schema mandatory to appear in Google’s job search feature?

Functionally, yes. Without JobPosting markup, individual job listings are not eligible to appear in Google’s dedicated job search experience regardless of how well the surrounding page otherwise performs in normal search.

What tools do SEO teams use to test schema at scale across many pages?

Google’s Rich Results Test and the Schema Markup Validator both support single-URL checks; for site-wide audits, most technical SEO teams pair those with a crawler (Screaming Frog or similar) configured to extract and validate JSON-LD blocks across every URL in a sitemap, then flag missing required fields in bulk.

Key takeaways

Schema markup is a formatting and extraction layer, not a ranking lever, and Google says so directly in its own documentation. FAQ and HowTo rich results are dead in Google Search as of the 2023-2026 deprecation cycle, so stop investing new effort there regardless of what older guides tell you. JSON-LD is the recommended format, self-serving reviews on Organization and LocalBusiness pages will never earn star ratings, and every Merchant Listing now needs shipping and return policy fields to be fully eligible. Validate with both the Rich Results Test and the Schema Markup Validator, because they check different things, and re-run that validation every time a template changes, not just at launch.

Start with Organization schema site-wide, add the page-type template that matches your highest-value pages first (LocalBusiness for physical locations, Product for ecommerce, Article for content), and expand from there once the foundation is validated and live.