Breadcrumb Schema: Implementing BreadcrumbList JSON-LD That Still Earns Rich Results

Breadcrumb schema is one of the few pieces of structured data I still add to every content template without a second thought — because it is one of the few whose rich result Google has kept while quietly retiring others. I write code and I do SEO, so I care about the parts of the schema stack that actually survive contact with Google’s shipping decisions. BreadcrumbList is that rare thing: cheap to implement, hard to get wrong once you know the traps, and still eligible for a visible search feature in 2026. This is the implementation guide — the exact JSON-LD, the mistakes that break it, and why it now does double duty as a site-hierarchy signal for AI engines.

Breadcrumb schema is BreadcrumbList structured data that describes a page’s position in your site hierarchy as an ordered trail of links — telling Google, and the AI engines reading your raw HTML, where a page sits and how it connects to the rest of the site.

Key takeaways

• Breadcrumb schema is still a live rich result. Google uses breadcrumb markup to categorize a page in search results and still lists Breadcrumb in its structured data gallery — unlike FAQ and HowTo, which it removed.
• The markup is small. A BreadcrumbList is just an ordered array of ListItem objects, each with position, name, and (usually) item.
• The last item can omit its URL. Google says item is not required for the final breadcrumb — it uses the containing page’s URL instead.
• Most breadcrumb bugs are mismatches. Positions out of order, item URLs that don’t resolve, or a schema trail that doesn’t match the on-page navigation are what quietly suppress the rich result.
• It doubles as a GEO signal. The same ordered trail that Google reads for its rich result gives AI crawlers an explicit map of your site hierarchy — a structured-data win beyond rankings.

What breadcrumb schema is, and what it does in search

A breadcrumb trail is the row of links near the top of a page — Home › Insights › Breadcrumb Schema — that shows where the page sits in your site’s hierarchy. Breadcrumb schema is the machine-readable version of that trail. In schema.org’s vocabulary, 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.”

The reason it matters for search is specific and documented. Google’s breadcrumb documentation states plainly that “Google Search uses breadcrumb markup in the body of a web page to categorize the information from the page in search results.” When it works, the grey URL line in a search result is replaced by your breadcrumb trail — example.com › Insights › Breadcrumb Schema — which reads as more navigable and gives Google an explicit statement of hierarchy rather than one it has to infer from your URL structure.

This is a different job from most of the schema I write about in structured data for AI search, where the payoff is entity attribution and citation confidence. Breadcrumb schema is narrower and more mechanical: it describes position in a hierarchy, nothing more. That narrowness is exactly why it has aged so well.

The BreadcrumbList JSON-LD markup

Here is a complete, copy-pasteable breadcrumb schema block. Google supports JSON-LD, Microdata, and RDFa for breadcrumbs; I use JSON-LD because it lives in one place and doesn’t entangle your markup with your presentation.

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "BreadcrumbList",
  "itemListElement": [
    {
      "@type": "ListItem",
      "position": 1,
      "name": "Home",
      "item": "https://example.com/"
    },
    {
      "@type": "ListItem",
      "position": 2,
      "name": "Insights",
      "item": "https://example.com/insights/"
    },
    {
      "@type": "ListItem",
      "position": 3,
      "name": "Breadcrumb Schema"
    }
  ]
}
</script>

Three things are doing the work here. The itemListElement array is the trail, in order. Each ListItem carries a position (Google’s docs specify that “position 1 signifies the beginning of the trail”), a name — “the title of the breadcrumb displayed for the user” — and an item, “the URL to the webpage that represents the breadcrumb.”

Notice the last item has no item. That is deliberate and correct. Google’s documentation is explicit: “If the breadcrumb is the last item in the breadcrumb trail, item is not required. If item isn’t included for the last item, Google uses the URL of the containing page.” So the final breadcrumb — the current page — only needs a name. You can include a self-referential item URL if you prefer explicitness; both are valid.

If a page is reachable through more than one path, you don’t have to pick one. Google supports multiple breadcrumb trails on a single page — you emit multiple BreadcrumbList objects, one per navigational route, and it treats them as alternative trails.

In an Astro or component-based codebase, the move I recommend is to generate this from the same data structure that renders the visible breadcrumb, so the two can never drift. The schema should be a serialization of the on-page trail, not a hand-maintained parallel copy — that parallelism is where most breadcrumb bugs are born.

Breadcrumb rich results are still supported — unlike FAQ and HowTo

This is the part worth being precise about, because the structured-data landscape got noisier over the last three years. Google has been actively removing rich result types, and it is easy to assume breadcrumbs went with them. They didn’t.

In August 2023, Google announced it was reducing FAQ rich results to “well-known, authoritative government and health websites” and limiting HowTo rich results to desktop. HowTo was then removed entirely in September 2023, and FAQ rich results were fully deprecated in May 2026, including for the government and health sites that had kept them. Both schema types are still valid — they just produce no visible search feature anymore.

Breadcrumb survived all of it. Google still describes breadcrumb as a supported structured data feature — “navigation that indicates the page’s position in the site hierarchy” — and the breadcrumb rich result is available on desktop in all regions and languages where Google Search is available. The pattern behind Google’s decisions is instructive: the schema types it kept describe facts about the page and site (what this is, where it sits), while the ones it cut were prone to being gamed for SERP real estate. Breadcrumb schema is squarely in the durable camp, which is why I treat it as a permanent fixture rather than a trend.

The breadcrumb schema mistakes that quietly break rich results

Breadcrumb markup rarely throws a loud error. It just fails to produce the rich result, and you don’t notice until you check. These are the failure modes I actually find on audits:

1. Positions out of order or non-sequential. The position values must run 1, 2, 3… in the order of the trail. Starting at 0, skipping a number, or listing items out of sequence confuses the parse. Position 1 is always the top of the hierarchy (typically Home), not the current page.

2. item URLs that don’t resolve. Every item must be a real, canonical, absolute URL that returns a 200. Relative paths, URLs to redirected or 404 pages, or item values pointing at the wrong environment (staging URLs shipped to production is a classic) all break the trail. The URL in the schema should match the canonical URL of the page it represents.

3. Schema that doesn’t match the visible breadcrumb. Google’s guidance is that structured data should represent what’s actually on the page. A BreadcrumbList describing a trail the user never sees — or in a different order than the on-page navigation — is a mismatch. This is the strongest argument for generating both from one source.

4. Missing name or item where required. Every ListItem needs a name. Every item except the last needs an item URL. Drop either on an interior item and that step of the trail is invalid.

5. Breadcrumb JSON-LD injected client-side. If your BreadcrumbList is added after hydration rather than in the server-rendered HTML, Google may still render it in its second wave, but AI crawlers reading raw HTML never will. Breadcrumb schema belongs in the initial HTML response for the same reason all your structured data does.

How to validate breadcrumb schema with the Rich Results Test

▤ Screenshot slot Google Rich Results Test on a nadiamohamed.me page showing 5 valid items detected, including Breadcrumbs with 1 valid item detected Drop the image at /assets/screenshots/breadcrumb-schema/rich-results-test-breadcrumb.png

Never ship breadcrumb schema on trust. Google’s own guidance is to “validate your code using the Rich Results Test and fix any critical errors” before it goes live. The workflow I run:

1. Test the markup in isolation first. Paste the JSON-LD into the Rich Results Test using the “Code” tab. Confirm it detects “Breadcrumbs” as a valid enhancement with no errors and each item parsed in the right order.
2. Then test the live URL. Once deployed, run the “URL” tab against the real page. This catches the failures that only appear in production — client-side injection, wrong environment URLs, or markup stripped by a build step.
3. Read the parsed trail, not just the pass/fail. Expand the detected breadcrumb and check that position, name, and item are exactly what you intended for every step. A “valid” result with the wrong URLs is still wrong.
4. Cross-check against the raw HTML. Run curl -sA "Googlebot" https://example.com/your-page | grep -i breadcrumblist to confirm the JSON-LD is in the server response, not injected later. If it isn’t in that output, AI crawlers can’t see it either.

For ongoing coverage, Search Console’s breadcrumb enhancement report tracks valid and invalid items across your whole site, which is where you catch a template regression before it spreads.

Why breadcrumb schema helps AI engines, not just Google

The rich result is the visible payoff, but it is no longer the only reason I ship breadcrumb schema. The AI crawlers behind ChatGPT, Perplexity, and Google’s own AI surfaces read your raw HTML as text, and they benefit from explicit structure the same way Google’s index does. A BreadcrumbList hands them an unambiguous statement of where a page sits — Home › Insights › Breadcrumb Schema — instead of forcing them to infer hierarchy from URL slugs and navigation they may not parse.

That matters for how a page gets contextualized. When an AI engine understands that an article is a child of your “Insights” hub, which sits under your domain root, it has a clearer picture of the page’s topic and your site’s structure — useful signal for both retrieval and attribution. Breadcrumb schema is a small, durable contribution to the same site-hierarchy legibility that makes a site easier to crawl, index, and cite. It is not the headline move in a structured data strategy for AI search — Article, Person, and Organization carry more weight there — but it is close to free, and unlike some of its neighbours in the schema gallery, it isn’t going anywhere.

If you want a general grounding in JSON-LD before implementing (a broader how-to on rich snippets and JSON-LD is coming to this series), start with the two properties that decide everything: get position sequential and every item resolving to a canonical 200, and breadcrumb schema does its job on both fronts at once — one visible rich result in Google, one clean hierarchy signal for the engines reading underneath it.

FAQ

Does Google still support breadcrumb rich results in 2026?

Yes. Google still uses breadcrumb markup to categorize pages in search results and lists Breadcrumb as a supported feature in its structured data gallery. This is in deliberate contrast to FAQ rich results, which Google fully deprecated in May 2026, and HowTo rich results, which it removed in September 2023. Both of those schema types remain valid but no longer produce any visible search feature; breadcrumb still does.

What is the difference between BreadcrumbList and breadcrumb schema?

They refer to the same thing. “Breadcrumb schema” is the informal name; BreadcrumbList is the actual schema.org type you write in your markup. A BreadcrumbList contains an ordered itemListElement array of ListItem objects, each describing one step in the trail with a position, a name, and usually an item URL.

Does the last breadcrumb item need a URL?

No. Google’s documentation states that item is not required for the last item in the trail — if you omit it, Google uses the URL of the containing page. Every breadcrumb before the last one does need an item URL, and every item needs a name. Including a self-referential item on the final breadcrumb is also valid if you prefer to be explicit.

How do I validate breadcrumb schema?

Use Google’s Rich Results Test. Paste your JSON-LD into the Code tab to check the markup in isolation, then run the URL tab against the live page once it’s deployed to catch production-only issues. Confirm it detects “Breadcrumbs” with no errors and that every item’s position, name, and URL are correct. For site-wide monitoring, use the breadcrumb enhancement report in Search Console.

Why isn’t my breadcrumb rich result showing?

The most common causes are non-sequential position values, item URLs that don’t resolve to a canonical 200, a schema trail that doesn’t match the visible on-page breadcrumb, or JSON-LD injected client-side so crawlers reading raw HTML never see it. Validate the live URL in the Rich Results Test and confirm the markup is present in the server response with curl -sA "Googlebot" <url> | grep breadcrumblist.

Do AI search engines use breadcrumb schema?

Indirectly, yes. AI crawlers read your raw HTML and benefit from explicit structure. A BreadcrumbList gives them an unambiguous statement of where a page sits in your site hierarchy rather than making them infer it from URLs and navigation. It isn’t the highest-leverage schema for AI citation — Article, Person, and Organization matter more — but it’s a low-cost contribution to overall site legibility, provided it’s in the server-rendered HTML.