BreadcrumbList Schema

TL;DR — BreadcrumbList is a bit of code (usually JSON-LD) that tells Google the trail showing where a page sits on your site — Home > Category > Page. Google can use it to show that readable path in the search result instead of a messy URL, and it uses the trail to understand how the page is categorized. You need at least a couple of steps in the trail, each with a position, a name, and a link — except the last step (the current page), which doesn’t need a link.

What BreadcrumbList schema is

A breadcrumb is the little navigation trail near the top of a page that shows where you are: Home > Shoes > Running Shoes. BreadcrumbList is the schema.org type you use to describe that trail in a machine-readable way so search engines can read it directly instead of guessing. Evidence for this claim Schema.org defines BreadcrumbList as an ItemList representing a chain of linked web pages. Scope: Schema.org vocabulary; Google has separate breadcrumb feature requirements. Confidence: high · Verified: 2026-07-14 Schema.org: BreadcrumbList

Most people add it as JSON-LD — a small block of code in the page’s HTML. (Google also accepts Microdata and RDFa, but JSON-LD is the format it recommends.)

Why it’s worth doing

Two reasons:

1. A nicer search result. Google can show your breadcrumb trail in the search snippet in place of the raw URL, so people see example.com › Shoes › Running instead of a long address. Evidence for this claim Google says breadcrumb markup can categorize page information and can be used in search-result breadcrumbs. Scope: Google Search breadcrumb documentation; display is not guaranteed. Confidence: high · Verified: 2026-07-14 Google: Breadcrumb structured data
2. It helps Google categorize the page. Google reads the breadcrumb trail to understand where the page fits — which is why the same page can show up under different trails depending on what someone searched for.

The minimum you need

A BreadcrumbList holds an ordered list called itemListElement. Each step in the trail is a ListItem with three things:

• position — the step number, starting at 1.
• name — what to call that step (e.g., “Running Shoes”).
• item — the URL that step links to.

The one exception: the last item (the current page) doesn’t need an item URL, because that’s the page you’re already on.

Two things people get wrong

• It’s not a ranking factor. Breadcrumb schema affects how your result looks and how Google categorizes the page — it doesn’t push you up the rankings.
• The trail should match how people navigate, not your URL folders. Google actually recommends this. If your URL is a flat /product-123/ but users reach it through Home > Shoes > Running, mark up the navigation path.

Also worth knowing: adding the schema does not put a visible breadcrumb on your page for human visitors — that’s separate HTML you build yourself. If you want the navigation-and-UX side of breadcrumbs (visible trails, internal-link value), that’s its own topic; this page is about the markup.

Want the required-vs-optional property breakdown, a broken-vs-clean code example, how to validate it, and an honest take on whether Google still shows breadcrumbs in 2026? Switch to the Advanced tab.

TL;DR — BreadcrumbList marks up a page’s breadcrumb trail as structured data (JSON-LD recommended; Microdata/RDFa also supported). It does two jobs: it’s eligible to render a breadcrumb path in Google’s snippet in place of the URL, and — in Google’s words — Google “uses breadcrumb markup in the body of a web page to categorize the information from the page in search results,” which is why one page can surface under different trails for different queries. Required shape: BreadcrumbList.itemListElement is an ordered array of ListItems, each with position, name, and item — item is optional only on the final (current) item. Google recommends the trail reflect a typical user path, not the URL structure, and says you can omit a ListItem for both the homepage and the current page. It’s not a ranking signal, valid markup never guarantees the rich display, and rich-result eligibility runs through Mueller’s three layers (valid markup → policy compliance → site-quality trust). Whether Google still reliably shows breadcrumbs in the 2026 SERP is genuinely disputed — implement it anyway (categorization value, low cost, no downside) and check your own results.

What it is, precisely

BreadcrumbList is a schema.org type. schema.org defines it as “an ItemList consisting of a chain of linked Web pages, typically described using at least their URL and their name, and typically ending with the current page.” In practice you build a BreadcrumbList whose itemListElement is an ordered array of ListItem entries — one per step in the trail. Evidence for this claim Google's breadcrumb examples use ordered ListItem entries with position, name, and item, with documented flexibility for the final item. Scope: Google Search breadcrumb feature requirements; schema.org permits a broader vocabulary. Confidence: high · Verified: 2026-07-14 Google: Breadcrumb structured data

You can express it in JSON-LD, Microdata, or RDFa. JSON-LD is the format Google recommends and the one I’d default to: it lives in a single script block, doesn’t tangle with your visible markup, and is the easiest to template and debug.

The two jobs breadcrumb markup does

This is the framing most competitor pages miss — they jump straight to “paste this JSON-LD.” Breadcrumb markup does two separate things:

1. It’s eligible for a rich SERP display. Google can render the breadcrumb trail in the search snippet in place of the raw URL. Note the word eligible — having valid markup makes you a candidate, it does not guarantee the display (more on that below).

2. It’s a categorization signal Google reads internally. Straight from Google’s docs: “Google Search uses breadcrumb markup in the body of a web page to categorize the information from the page in search results.” This is the underrated half. It’s why the same URL can appear under different breadcrumb trails for different queries — Google is using the trail as context, not just decoration. That value exists even on queries where no visible breadcrumb ever renders.

Concretely, Google’s own documentation shows this as multiple separate BreadcrumbList objects on the same page — one complete JSON-LD block per path a user might realistically take to reach it — rather than one trail that somehow adapts itself per query. If a page is genuinely reachable through more than one category (a common ecommerce case), mark up each path as its own BreadcrumbList and keep every alternate trail independently valid — each still needs every ListItem to carry its own position, name, and item per the rules below. Don’t treat one “primary” trail as covering the categorization value for paths it doesn’t actually describe.

Required and optional properties

Here’s the accuracy spine — get this right and the rest is detail.

Required:

• BreadcrumbList.itemListElement — “An array of breadcrumbs listed in a specific order.” This is the ordered list of steps.
• ListItem.position — “The position of the breadcrumb in the breadcrumb trail. Position 1 signifies the beginning of the trail.” Start at 1 and increment.
• ListItem.item (with a name) — the URL (and label) for each step. This is required for every item except the last one, which is the current page and can omit the URL.

Google puts the last-item exception plainly: “It is not required to include a breadcrumb ListItem for the top level path (your site’s domain or host name), nor for the page itself.” So both the homepage and the current page are optional to include — a genuinely common misconception is that you must have them.

A valid trail needs at least two ListItems to be meaningful — a single-step “breadcrumb” isn’t a trail.

User path vs. URL structure

This is the nuance worth internalizing, because Google states it explicitly and most guides skip it: “We recommend providing breadcrumbs that represent a typical user path to a page, instead of mirroring the URL structure.”

In other words, the breadcrumb trail is a navigational statement, not a directory one. Where these diverge — flat URL structures with deep categorization, tag pages, or heavily faceted navigation where a product is reachable through many paths — mark up the path a user would actually take, not the folders in the URL. This matters most on ecommerce sites, where a single product legitimately lives under multiple category paths (which is also, not coincidentally, a place where faceted navigation and URL structure get messy). Pick the primary user path for that page’s markup.

It is not a ranking factor

Say it plainly, because “does it help rankings?” is one of the most common searcher questions: nothing in Google’s guidance ties BreadcrumbList to rankings. It affects SERP presentation and internal categorization — not ranking position. Adding it won’t move you up; not having it won’t hold you down. The reason to implement is the categorization signal plus the potential display, at a low implementation cost.

Validating and rolling it out

Google prescribes a straightforward workflow:

1. Add the required properties in your chosen format, following Google’s placement guidance.
2. Validate with the Rich Results Test and fix any critical errors.
3. Deploy on a few pages first, confirm with URL Inspection in Search Console, then roll out site-wide.

Search Console has a dedicated Breadcrumbs enhancement report that surfaces errors and warnings across your site once it’s live — that’s where you monitor ongoing health.

Why isn’t my breadcrumb rich result showing?

Valid markup is necessary but not sufficient. John Mueller has laid out a useful three-layer model for rich-result eligibility generally (paraphrasing his framing): first, the markup has to be technically valid; second, it has to comply with Google’s structured-data policies; and third, there’s a broader, usually site-wide quality/trust signal — whether Google trusts your site enough to show enhanced results from your structured data at all.

Mueller has also offered a rough diagnostic: run a site: query for your own domain and see whether the rich results show there. Roughly, if the enhancement appears for site: queries but not for normal ones, that points less at your markup and more at a site-quality/trust issue than a technical one.

On breadcrumbs specifically, Mueller has downplayed policy risk — his gist being that breadcrumbs are one of the harder structured-data types to get wrong in a way that trips policy, since a breadcrumb trail is a fairly literal thing. Treat that as reassurance that if your breadcrumb rich result isn’t showing, the cause is more likely the display/quality layer than a policy violation in the breadcrumb markup itself.

The one policy backstop that does apply: Google’s general structured data guidelines require markup to reflect real, on-page content. Don’t fabricate a breadcrumb trail that doesn’t match your actual site structure to game a rich result — markup that deviates from the guidelines can, in principle, trigger a manual action.

Does Google still show breadcrumbs in the SERP? (an honest 2026 answer)

This is where I want to be careful rather than confident, because the sources genuinely disagree. Some 2025–2026 posts claim Google removed breadcrumb display (desktop first, then mobile); other 2026-dated guides describe BreadcrumbList as one of the more stable schema types with the trail still appearing. Google’s own breadcrumb documentation, as of mid-2026, still scopes the feature to “desktop in all regions and languages where Google Search is available” and carries no deprecation notice.

I’m not going to resolve that disagreement with a flat “Google shows this” or “it’s dead” — the display side is visibly in flux and secondhand claims (some citing image-embedded screenshots or single-region observations) aren’t a reliable basis. My recommendation is decision-first: implement it regardless. The categorization value doesn’t depend on the visible trail rendering, the implementation cost is low, and there’s no downside. Then check your own SERPs for your own query set — on the surfaces and regions you care about — rather than trusting a blog post’s screenshot. That’s the honest posture on a live, unsettled question.

(If you specifically want the navigation-and-UX angle — visible breadcrumbs as internal links, PageRank flow, accessibility — that’s a sibling topic on this site, covered under website structure. This page deliberately stays on the markup.)

Bing and other engines

BreadcrumbList is a standard schema.org type, not a Google-proprietary one, and Bing has long stated it supports the schema.org vocabulary (JSON-LD, Microdata, RDFa) for structured data broadly. I didn’t find a dedicated Bing documentation page for breadcrumb schema specifically, so I’d describe Bing’s support as generic schema.org support rather than pointing you at a breadcrumb-specific Bing rich-result guarantee. The markup you write for Google is valid for Bing too; whether and how Bing renders a breadcrumb enhancement is a separate, less-documented question.

The bottom line

• Minimum valid structure: BreadcrumbList → itemListElement array of ListItems, each with position (from 1), name, and item — item optional on the last item only.
• Google recommends the user path, not the URL structure; homepage and current page are optional to include.
• It’s not a ranking factor; valid markup never guarantees the display.
• SERP display is genuinely disputed in 2026 — implement for the categorization value and verify on your own results.

AI summary

A condensed take on the Advanced version:

• BreadcrumbList = the schema.org type for a page’s breadcrumb trail, added as JSON-LD (recommended; Microdata/RDFa also work).
• Two jobs: (1) eligible to render a breadcrumb path in Google’s snippet in place of the URL; (2) a categorization signal — Google “uses breadcrumb markup in the body of a web page to categorize the information,” which is why one page can appear under different trails for different queries.
• Required shape: BreadcrumbList.itemListElement is an ordered array of ListItems; each needs position (starting at 1), name, and item. item is optional only on the final (current-page) item.
• Optional to include: the homepage and the current page — Google says neither is required.
• User path, not URL structure: Google recommends breadcrumbs reflect a typical user path, not the URL folders — important for flat URLs, tag pages, and faceted nav.
• Not a ranking factor. It affects display and categorization, not position.
• Validate with the Rich Results Test → confirm with URL Inspection → roll out; monitor via Search Console’s Breadcrumbs report.
• Rich-result troubleshooting (Mueller’s layers, paraphrased): valid markup → policy compliance → site-quality/trust. A site: query is a rough diagnostic — showing there but not on normal queries points at quality, not markup.
• 2026 display is disputed: some sources claim removal, others claim continued stability; Google’s docs still scope it to desktop with no deprecation notice. Implement regardless and check your own SERPs.
• Bing: supports schema.org broadly; no dedicated Bing breadcrumb doc was found, so treat cross-engine support as generic, not a breadcrumb-specific guarantee.

Official documentation

Primary-source documentation for BreadcrumbList markup.

Google

• Breadcrumb (BreadcrumbList) structured data — the required properties, JSON-LD/Microdata/RDFa examples, the user-path recommendation, and the validation/rollout workflow.
• General structured data guidelines — the policy backstop: markup must reflect real on-page content; violations can trigger a manual action.
• Rich Results Test — validate your BreadcrumbList markup before and after deploy.

schema.org

• schema.org/BreadcrumbList — the type definition (“a chain of linked Web pages… typically ending with the current page”).
• schema.org/breadcrumb — the breadcrumb property that attaches a BreadcrumbList to a WebPage.
• schema.org/ListItem — the item type used for each step (position, name, item).

Bing / Microsoft

• No dedicated Bing breadcrumb-schema documentation page was found. Bing supports the schema.org vocabulary (JSON-LD, Microdata, RDFa) for structured data broadly, and BreadcrumbList is a standard schema.org type — so the same markup is valid for Bing, but there’s no breadcrumb-specific Bing rich-result guarantee to cite.

Quotes from the source

On-the-record statements from Google and schema.org. Each verbatim quote links to the exact passage on the source page.

schema.org — what BreadcrumbList is

• “A BreadcrumbList is an ItemList consisting of a chain of linked Web pages, typically described using at least their URL and their name, and typically ending with the current page.” — schema.org. Jump to the type page

Google — the categorization signal

• “Google Search uses breadcrumb markup in the body of a web page to categorize the information from the page in search results.” — Google Search Central docs. Jump to quote

Google — user path, not URL structure

• “We recommend providing breadcrumbs that represent a typical user path to a page, instead of mirroring the URL structure.” Jump to quote

Google — homepage and current page are optional

• “It is not required to include a breadcrumb ListItem for the top level path (your site’s domain or host name), nor for the page itself.” Jump to quote

Google — what the properties are

• On itemListElement: “An array of breadcrumbs listed in a specific order.” On position: “The position of the breadcrumb in the breadcrumb trail. Position 1 signifies the beginning of the trail.” — Google Search Central docs (breadcrumb structured-data reference).

A broken BreadcrumbList — and why it fails

Here’s a JSON-LD block that looks fine at a glance but has several real problems. Spot the issues before reading the notes:

{
  "@context": "https://schema.org",
  "@type": "BreadcrumbList",
  "itemListElement": [
    {
      "@type": "ListItem",
      "name": "Shoes",
      "item": "https://example.com/shoes/"
    },
    {
      "@type": "ListItem",
      "position": 2,
      "item": "https://example.com/shoes/running/"
    },
    {
      "@type": "ListItem",
      "position": 2,
      "name": "Trail Runner 5",
      "item": "https://example.com/shoes/running/trail-runner-5/"
    }
  ]
}

What’s wrong:

• The first item has no position. Every ListItem needs a position, and the trail must start at 1.
• Positions are duplicated and don’t start at 1. Two items claim position: 2 and there’s no position: 1. Positions must be a clean, ascending sequence starting at 1.
• The second item has no name. name is required on every step — a bare item URL isn’t enough.
• The last item includes an item URL. That’s not invalid, but it’s the one place the URL is optional (it’s the current page), so many implementations drop it there.

The clean version

Same trail, done right — two levels above the current page, positions ascending from 1, every step with a name, and the final (current-page) item with its item omitted:

{
  "@context": "https://schema.org",
  "@type": "BreadcrumbList",
  "itemListElement": [
    {
      "@type": "ListItem",
      "position": 1,
      "name": "Shoes",
      "item": "https://example.com/shoes/"
    },
    {
      "@type": "ListItem",
      "position": 2,
      "name": "Running Shoes",
      "item": "https://example.com/shoes/running/"
    },
    {
      "@type": "ListItem",
      "position": 3,
      "name": "Trail Runner 5"
    }
  ]
}

Things to notice:

• position runs 1 → 2 → 3, one per ListItem, in trail order.
• Every step has a name.
• The final item omits item because it’s the current page — that’s the one allowed omission. (You can include it; it’s just optional here.)
• There’s no homepage ListItem. Google says the top-level/domain step is optional; this trail starts at the first real category. Include a Home step only if it reflects how users actually navigate.
• The trail reflects the navigation path, not necessarily the URL folders. Here they happen to line up, but if the product’s URL were a flat /trail-runner-5/, you’d still mark up Shoes > Running Shoes > Trail Runner 5 because that’s the user path Google recommends representing.

Drop either block into the Rich Results Test to see the broken one flag errors and the clean one pass.

BreadcrumbList mistakes and myths to avoid

Myth: “Adding BreadcrumbList schema will boost my rankings.” It won’t. Nothing in Google’s guidance ties breadcrumb markup to ranking position — it affects SERP presentation and internal categorization, not where you rank. Treat it as a low-cost display and categorization play, not a ranking lever.

Myth: “I have to include a homepage step and a current-page step in every trail.” Google explicitly says neither is required — you can omit a ListItem for the top-level/domain step and for the current page. A trail that starts at the first real category and ends without an item URL on the last step is still fully valid.

Mistake: positions that don’t start at 1, skip a number, or repeat. Each ListItem.position has to be a clean, ascending sequence starting at 1 — one per step, in trail order. Two ListItems claiming the same position, or a trail that starts at 2, is a structural error that will fail validation (see the Examples tab for a broken sample).

Mistake: leaving name off a step. name is required on every ListItem, not just the ones with a link. A bare item URL without a name is incomplete markup, even though it’s easy to miss at a glance.

Mistake: mirroring your URL folder structure instead of the path users actually take. Google recommends the trail represent a typical user path to the page, not the URL directory structure. This bites hardest on flat URLs, tag pages, and faceted navigation where a single page is reachable through several category paths — pick the primary user path for the markup, don’t just echo the folders in the address bar.

Myth: “Adding the schema puts a visible breadcrumb trail on my page for human visitors.” It doesn’t. BreadcrumbList is machine-readable structured data only — the visible, clickable breadcrumb trail on the page is separate HTML you build yourself. Shipping the schema without the visible navigation gets you the categorization signal and rich-result eligibility, but no on-page breadcrumb UI for users.

Mistake: marking up a trail that doesn’t match your real site structure. Google’s general structured-data guidelines require markup to reflect real, on-page content. Fabricating a breadcrumb trail to game a rich result — one that doesn’t correspond to how the page is actually reachable or categorized — can, in principle, trigger a manual action under those guidelines, not just a missed display.

BreadcrumbList properties at a glance

Required structure

Optional-to-include steps

Markup formats Google accepts

Fast facts

• A valid trail needs at least two ListItems — a single-step “breadcrumb” isn’t a trail.
• Positions must be a clean ascending sequence starting at 1, not just unique numbers.
• The trail should reflect a typical user path, not necessarily the URL folder structure.
• BreadcrumbList is not a ranking factor — it affects SERP display and categorization only.
• Valid markup makes the rich display eligible, never guaranteed.
• The schema does not create a visible breadcrumb trail for human visitors — that UI is separate.
• A page reachable through more than one path can carry multiple separate BreadcrumbList objects — one per path — each independently valid, rather than one trail that adapts per query.

Tools for building and checking BreadcrumbList markup

My Schema Markup Validator is where I’d start once you’ve written the JSON-LD. Paste the block (or a full page) and it runs severity-tiered checks against schema.org’s BreadcrumbList/ListItem vocabulary and Google’s rich-result requirements — it catches the exact structural mistakes covered on the What Not to Do and Examples tabs, like a missing position, duplicate positions, or a ListItem with no name, and hands back a corrected, copy-pasteable JSON-LD block.

My Rich-Result Eligibility Checker answers a different question: not “is this valid JSON-LD” but “does this specific page qualify for Google’s breadcrumb rich result.” Paste JSON-LD, an HTML page, or fetch a live URL, and it shows whether the Breadcrumb type is eligible, with the exact missing required field flagged if it isn’t.

If you’re starting from a blank page rather than fixing existing markup, my Schema Markup Generator has a focused form for building a BreadcrumbList without hand-writing the JSON-LD — it walks through each ListItem’s position, name, and item, and flags which properties Google requires versus recommends as you fill it in.

Once markup passes those checks, run the page through Google’s own Rich Results Test — it’s the tool Google actually uses to decide eligibility, so it’s the final word before you ship.

Common BreadcrumbList problems and how to fix them

The Rich Results Test or Schema Markup Validator flags an error on my BreadcrumbList

The most common causes are the structural mistakes covered on the What Not to Do and Examples tabs: a ListItem missing its position, positions that repeat or don’t start at 1, or a step missing its required name. Check each ListItem in order — the fix is almost always a single malformed step, not the whole block.

My breadcrumb rich result never shows in the SERP, even though the markup validates clean

Valid markup only makes a page eligible for the display — it doesn’t guarantee it. John Mueller’s three-layer model for rich-result eligibility generally applies here: first the markup has to be technically valid, second it has to comply with Google’s structured-data policies, and third there’s a broader, usually site-wide quality/trust signal — whether Google trusts your site enough to show enhanced results from your structured data at all. Mueller’s rough diagnostic: run a site: query for your own domain and see whether the rich result shows there. If it appears for site: queries but not for normal ones, that points at a site-quality/trust issue more than a technical one — and Mueller has separately downplayed policy risk for breadcrumbs specifically, since a breadcrumb trail is a fairly literal thing that’s hard to get wrong in a policy-relevant way.

No visible breadcrumb trail shows on the page, even though I added the schema

That’s expected, not a bug. BreadcrumbList is machine-readable structured data only — it does not generate the visible, clickable breadcrumb UI on the page. You have to build that HTML separately; the schema and the on-page navigation are two different things that happen to describe the same trail.

I can’t tell if Google still shows breadcrumb rich results in 2026

This is a genuinely disputed question, not a settled one — some 2025-2026 sources claim Google removed breadcrumb display (desktop first, then mobile), while others describe BreadcrumbList as one of the more stable schema types with the trail still appearing. Google’s own breadcrumb documentation, as of mid-2026, still scopes the feature to desktop with no deprecation notice. My recommendation: implement it regardless of that disagreement — the categorization value doesn’t depend on the visible trail rendering — then check your own SERPs for your own query set rather than trusting a blog post’s screenshot.

Search Console’s Breadcrumbs report shows errors or warnings for pages I thought were fixed

Search Console has a dedicated Breadcrumbs enhancement report that surfaces markup errors and warnings once a page is live and recrawled. If a page you already fixed still shows there, either the fix hasn’t shipped to the live page Google actually crawled, or a different ListItem in the same trail has its own structural problem — re-run the live URL through the Rich Results Test rather than assuming the report is stale.

Proving your BreadcrumbList change worked

Test 1: JSON-LD structural validation

Test to run: Paste the updated JSON-LD into my Schema Markup Validator, or run the live page through Google’s Rich Results Test. Expected result: No errors on the BreadcrumbList block — every ListItem has a position in a clean ascending sequence starting at 1, a name, and an item URL on every step except the last. Failure interpretation: A flagged missing or duplicate property means the property genuinely isn’t right in the markup you shipped, not a caching or rendering issue — re-check the JSON-LD source directly. Monitoring window: Immediate — both tools read the markup as submitted, no crawl wait. Rollback trigger: Validation still fails after a direct fix — revert the template change and re-diff against the last known-good JSON-LD.

Test 2: Breadcrumb rich-result eligibility for the live URL

Test to run: My Rich-Result Eligibility Checker against the live URL. Expected result: The Breadcrumb type shows as eligible for the rich result. Failure interpretation: A missing-required-field flag here after Test 1 passed usually means the fetched live page doesn’t match what you validated — check for a deploy that hasn’t gone out, or markup that only exists in a staging copy. Monitoring window: Immediate. Rollback trigger: Still ineligible after a confirmed live-page fix — check for caching (CDN or page cache serving a stale version) before touching the markup again.

Test 3: Search Console’s Breadcrumbs enhancement report reflects the fix

Test to run: Search Console → Enhancements → Breadcrumbs, for the affected URLs. Expected result: The page moves out of the errors/warnings bucket and shows as valid, with the error count for that URL at zero. Failure interpretation: Still flagged after Google’s recrawl means either the fix didn’t reach the live page Google actually crawled, or a different ListItem in the trail has its own issue — re-run Test 1 against the live URL, not a staging copy. Monitoring window: A few days up to roughly a week for Google to recrawl and refresh the report — Search Console data lags the live page. Rollback trigger: The error count rises after a template rollout instead of falling — that’s a sign the change broke markup on other pages sharing the same template; pause the rollout.

Test 4: The breadcrumb trail actually appears in the live SERP

Test to run: A manual search (private/incognito window, to avoid personalization skew) for a query where the page ranks, checking whether the breadcrumb trail displays in place of the raw URL. Expected result: The trail renders in the snippet. Failure interpretation: Absence here, with a valid Search Console status, isn’t necessarily a failure to fix — display is genuinely disputed in 2026 and isn’t guaranteed by eligibility. Absence combined with an errors/warnings status in Search Console means go back to Test 1 or 3. Monitoring window: Google gives no fixed timeline for display; check periodically over the following weeks rather than expecting it immediately after validation passes. Rollback trigger: None on the markup side — there’s nothing to revert for a display decision Google controls. Only revisit if Search Console’s Manual Actions report flags the page.

Ongoing KPIs for BreadcrumbList markup

Metric: Valid items count (Search Console Breadcrumbs report) What it tells you: how many of your pages currently have error-free BreadcrumbList markup — the coverage side of the KPI. How to pull it: Search Console → Enhancements → Breadcrumbs. Benchmark / realistic range: no universal target — establish your own baseline from the count of pages that should carry the markup (your total pages with a real breadcrumb trail), and track valid items trending toward that number. Cadence: monthly, or immediately after any template/CMS change touching breadcrumb markup.

Metric: Error/warning items count (same report) What it tells you: how many pages have a structural problem — the quality side of the KPI, separate from coverage. How to pull it: the same Breadcrumbs report, the errors/warnings bucket. Benchmark / realistic range: the only honest target is zero; any nonzero count is a real broken page, not statistical noise. Cadence: monthly, and always after a deploy that touches the markup template.

Metric: Rich Results Test pass rate across templates What it tells you: whether every page template that should carry BreadcrumbList actually does so cleanly, not just the pages you happened to spot-check. How to pull it: sample one URL per template through the Rich Results Test or my Schema Markup Validator. Benchmark / realistic range: 100% is the defensible target here, since this is a binary validity check per template, not a vanity metric — a failing template means every page built from it is broken. Cadence: after any template change, and as a quarterly spot-check otherwise.

Metric: Breadcrumb display presence for a sample of your ranking queries What it tells you: whether the rich display is actually rendering in the SERP for pages that are markup-valid — the honest way to track this given how unsettled breadcrumb display is in 2026. How to pull it: manually check a consistent sample of your own ranking queries (private/incognito window) over time, per Mueller’s site: versus normal-query diagnostic covered on the Common Issues tab. Benchmark / realistic range: no defensible fixed number to cite — display is genuinely disputed and discretionary; track your own presence rate as a trend rather than against an external target. Cadence: quarterly, given how unsettled the display question currently is.

Test yourself: BreadcrumbList schema

Five quick questions on how BreadcrumbList markup works. Pick an answer for each, then check.

BreadcrumbList Schema

BreadcrumbList (schema.org/BreadcrumbList) is structured data — usually JSON-LD — that marks up a page's breadcrumb trail (Home > Category > Page) so search engines can read the page's position in the site hierarchy, drive a readable breadcrumb path in the search snippet, and use it to categorize the page.

Related: Breadcrumbs, Structured Data, Schema Markup, Rich Results

BreadcrumbList Schema

BreadcrumbList schema is the schema.org/BreadcrumbList structured-data type you add to a page — usually as JSON-LD — to describe its breadcrumb trail: the ordered chain of pages showing where it sits in the site hierarchy (for example, Home > Shoes > Running Shoes). It’s built from a BreadcrumbList container whose itemListElement is an ordered array of ListItem entries, each carrying a position (starting at 1), a name, and an item URL — the URL is optional only on the final item, which represents the current page.

Google uses breadcrumb markup for two things: it makes the page eligible to show a readable breadcrumb path in the search snippet in place of the raw URL, and — per Google’s docs — it’s a categorization signal Google reads from the page body, which is why the same page can surface under different breadcrumb trails for different queries. Google recommends the trail reflect a typical user path rather than mirroring the URL folder structure, and says a ListItem for the homepage and for the current page is optional.

BreadcrumbList schema is not a ranking factor, valid markup never guarantees the rich display, and it doesn’t create visible on-page breadcrumb navigation (that’s separate HTML). Validate it with the Rich Results Test and monitor it in Search Console’s Breadcrumbs report.

Related: Breadcrumbs, Structured Data, Schema Markup, Rich Results

Changelog