A Working Breadcrumb Markup Example, Explained Line by Line

By Matt Griffin, Founder, Formative Digital · Published 2026-07-19

Breadcrumb markup has a strange reputation. It is the easiest schema type to write, three properties per level, no nesting puzzles, and yet a 2026 audit by Crawlix found roughly 40% of sites carry at least one BreadcrumbList error. The gap between "simple to write" and "frequently broken" is the whole story of this page. Below is a complete example you can copy, built on a real hierarchy from this site, followed by the rules that decide whether Google actually uses it. In our methodology this is Vector 6, Structure: giving the machine an unambiguous map of where a page lives.

What breadcrumb markup changes in a search result

BreadcrumbList tells Google where a page sits inside a site's hierarchy, and Google uses that trail to replace the grey URL line in a desktop result with readable path segments. Per Google Search Central's breadcrumb documentation, the markup helps Search "categorize the information from the page" in the context of the query.

The visible benefit is modest but real: a result reading formativedigital.com › Research › Citation Study tells a searcher what kind of page they are about to open, while a raw slug tells them nothing. The invisible benefit matters more. The trail is a hierarchy declaration, and hierarchy is one of the signals crawlers and AI retrieval systems use to decide what a page is about and which section of a site owns a topic. A clean trail on every page adds up to a machine-readable sitemap expressed one page at a time.

One expectation to set immediately: Google removed breadcrumb trails from mobile search results in 2025, showing only the root domain there, as Sitebulb's guide to the change documents. Desktop results still render trails, Search Console still reports on the markup, and the hierarchy signal still feeds ranking systems. The display shrank; the data pipeline did not.

The complete example, taken from this site

Abstract examples about example.com dresses teach syntax and nothing else, so here is a trail you can inspect in the wild. Our research library lives at formativedigital.com/research/, and each study inside it sits three levels deep: Home, then Research, then the study itself. The BreadcrumbList for one of those study pages looks like this, and the block below is valid JSON-LD exactly as written once unescaped:

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "BreadcrumbList",
  "itemListElement": [
    {
      "@type": "ListItem",
      "position": 1,
      "name": "Home",
      "item": "https://formativedigital.com/"
    },
    {
      "@type": "ListItem",
      "position": 2,
      "name": "Research",
      "item": "https://formativedigital.com/research/"
    },
    {
      "@type": "ListItem",
      "position": 3,
      "name": "AI Search Citation Study",
      "item": "https://formativedigital.com/research/ai-search-citation-study/"
    }
  ]
}
</script>

Paste it into the Rich Results Test and it passes. Swap the three names and three URLs for your own hierarchy and it remains eligible, provided you respect the rules in the next section. The script belongs anywhere in the head or body of the page it describes; we ship ours inside the page's main schema graph, which the closing section covers.

Reading the block property by property

Every working BreadcrumbList reduces to the same four decisions, and each line above encodes one of them.

• itemListElement is the array holding the trail. Order inside the array does not technically matter because position carries the ordering, but writing it top-down keeps humans sane during audits.
• position is an integer starting at 1, incrementing by exactly one per level. Not 0. Not 1, 2, 4. The counting rule sounds trivial until you meet a template that loops over a category array and skips a level when a category is hidden.
• name is the label a searcher would see, so "Research", not "research-hub-v2". Google displays these strings; write them like navigation labels, not slugs.
• item is the full absolute URL of that level, protocol included. Google resolves the trail against its index, and it indexes absolute URLs. This one property causes more breadcrumb failures than every other property combined.

The final ListItem, the current page, may omit item entirely; Google infers the URL from the page it found the markup on. We include it, matched exactly to the canonical, because an explicit value is one less thing an auditor has to infer six months later.

How the trail actually renders in results

On desktop, Google replaces the URL line beneath the title with the trail, separated by chevrons, usually truncating the deepest levels when space runs out. Only intermediate levels render as path segments; the root shows as the domain and the current page is represented by the result itself. So the three-level example above renders as formativedigital.com › Research, not as all three names in a row.

That truncation behaviour has a practical consequence: the levels closest to the root are the ones searchers see most often, so their names deserve the most care. A generic middle level like "Pages" or "Content" wastes the one hierarchy slot Google reliably displays. On mobile, since the 2025 change, none of this renders at all; searchers see the bare domain. If your analytics show a mostly mobile audience, breadcrumb markup is now a crawler-facing signal for you rather than a snippet enhancement, and it is still worth shipping for exactly that reason.

AI answer engines are the third rendering surface, and the least discussed. When an assistant cites a page, it frequently names the site section it drew from, and structured hierarchy is the cheapest way to hand it that context. We covered the broader mechanics of machine-readable page identity in our Article schema example, and breadcrumbs are the companion signal: Article says what the page is, BreadcrumbList says where it lives.

Matching the visible trail to the markup

Google's guidelines require structured data to reflect what a user can see, and breadcrumbs are the schema type where sites drift out of compliance without noticing. The visible navigation gets redesigned, a category gets renamed in the CMS, and the JSON-LD keeps announcing a hierarchy that no longer exists on screen. Trails that contradict the page read as manipulation to quality systems, and the rich result is the first casualty.

The matching standard is structural, not typographic. If the on-page trail reads Home > Research > AI Search Citation Study, the markup should carry those three levels with those labels. Minor differences survive review; a schema trail with levels the user cannot find anywhere on the page does not. Three habits keep the two in sync:

• Generate both from one source. Whatever data structure renders the visible breadcrumb should also emit the JSON-LD. Two templates maintained separately will disagree eventually, and nobody will notice until Search Console does.
• Rename in one place. When "Research" becomes "Studies" in navigation, the schema label must change in the same commit.
• Audit quarterly. Pull ten deep pages, compare screen against source. Ten pages catches template-level drift, which is the only kind static sites and CMS themes produce.

A wrinkle worth knowing: Google accepts breadcrumb markup on pages with no visible trail, and plugins add it silently all the time. It tends to work, but you have surrendered the guarantee that the two stay consistent, because one of them no longer exists where anyone can check it.

Error one: relative URLs in the item property

The single most common breadcrumb defect is writing "item": "/research/" instead of "item": "https://formativedigital.com/research/". Relative paths feel natural because that is how internal links are written in HTML, where the browser resolves them against the current origin. JSON-LD gets no such courtesy in practice. Parsers across Google, Bing, and AI retrieval systems vary in how they resolve partial URLs, and the only value every consumer reads identically is the full absolute form with protocol.

Adjacent variants of the same mistake: protocol-relative URLs (//formativedigital.com/research/), http on a site that serves https, a www prefix in the markup when the canonical is bare, and trailing-slash mismatches against the canonical. Each creates a URL that is technically reachable and canonically wrong, which means Google has to guess whether your trail refers to the pages it has indexed. Do not make the machine guess. Copy the canonical URL of each level into its item value, character for character.

Error two: position gaps and broken counting

Positions must start at 1 and increase by exactly one. The failure pattern is rarely a hand-typed mistake; it is a template that assigns positions from a database field or loop index. A category tree with a hidden middle tier produces 1, 2, 4. A loop counting from zero produces 0, 1, 2. An ecommerce platform merging two trail sources produces two position 2 entries. All three invalidate the list, and Schema.org's BreadcrumbList definition is explicit that position is what reconstructs the order of the chain.

The fix is to assign positions at render time from the final assembled trail, never from stored values. Build the array first, filter out whatever should not appear, then number what remains from 1 upward. Ten minutes of template logic ends the entire error class.

Error three: trails that describe a different site

The subtlest failures are trails that validate perfectly and lie. We see four recurring shapes in audits of Ontario business sites:

• The fossil trail. A section was restructured, the old hierarchy lives on in the schema. The item URLs now 301 or 404. Broken trail links degrade trust in the whole schema graph, not just the breadcrumb.
• The keyword trail. Levels stuffed with search phrases ("Best Foundation Repair Edmonton Alberta") that appear nowhere in navigation. This is spam by declaration and quality systems treat it as such.
• The flat trail. Every page marked up as Home > Page Name regardless of actual depth, usually a plugin default. Valid, useless, and a wasted hierarchy signal on every deep page.
• The duplicated-canonical trail. The markup points to URL variants (query strings, staging domains, http) that the canonical tags disown. The trail and the canonical must tell one story.

From Matt's audit work: "Breadcrumbs are where I look first when a site's rich results have quietly disappeared, because it is the schema type nobody rechecks after a redesign. On more than one Ontario audit the visible navigation had been rebuilt twice while the JSON-LD still described the site's 2022 structure." The observation generalizes: breadcrumb errors are rarely authored, they are inherited.

Patterns for deeper and messier hierarchies

Two-level sites barely need this schema type. The value compounds with depth, and depth introduces decisions the basic example never forces.

Four levels and beyond. An ecommerce path like Home > Bedroom > Mattresses > Queen > Product Name is five ListItems, positions 1 through 5, each with its absolute category URL. Google truncates the display; you do not truncate the markup. Declare the full trail and let the renderer decide what fits. On the Mattress Miracle engagement we shipped full-depth trails across the catalogue precisely because category-level hierarchy is what lets a machine distinguish a queen mattress page from a queen bed frame page carrying similar copy.

Pages reachable by two paths. A product living in both "Sale" and "Mattresses" can declare two BreadcrumbList blocks in one script, and Google chooses which trail to show. Declare the primary taxonomy first. Skip the second trail unless both paths genuinely exist in navigation.

Blogs and flat content libraries. If posts live at the root with no visible section, resist inventing one for the schema. A truthful two-level trail beats a fictional three-level one. If you want the deeper trail, build the section for users first; the markup follows the site, never the other way around.

Local and multi-location sites. Location pages benefit from a trail like Home > Locations > Brantford because it cleanly separates city pages that otherwise look near-identical to a crawler. Pair it with the entity work covered in our local business schema guide so the hierarchy and the entity data reinforce each other.

Where BreadcrumbList sits in the page's schema graph

A breadcrumb block floating alone in its own script tag works, but Google parses structured data as a connected graph, and the trail earns more trust when it is wired into it. On this page, the BreadcrumbList sits inside one @graph array alongside the Article, Organization, and WebSite nodes, sharing @id references so every object confirms the others. View source on this URL and you are looking at the pattern in production: the page describing breadcrumb markup is itself marked up the way it recommends.

Two integration notes. First, keep one BreadcrumbList per trail; do not repeat the same trail in a plugin block and a hand-written block, because duplicate conflicting lists are one more thing for a parser to reconcile. Second, the trail's final item URL must equal the canonical and the mainEntityOfPage of the Article node. When those three disagree, each individually valid block undermines the others. The wiring steps, including how to test the assembled graph, are laid out in our walkthrough on how to add schema markup.

A five-minute validation routine

Before shipping any BreadcrumbList, run the trail through this sequence. It catches every error class described above.

• Every item URL is absolute, https, and byte-identical to that page's canonical.
• Positions run 1, 2, 3, with no gaps, no zeros, no duplicates.
• Every name matches a label the user can see in the page's navigation or visible trail.
• Every URL in the trail returns 200, not a redirect chain.
• The Rich Results Test reports the BreadcrumbList as eligible, and Search Console's breadcrumb report stays clean after the next crawl.

The routine takes five minutes per template, and templates are where breadcrumbs live, so five minutes covers hundreds of pages. If the trail passes today, calendar the recheck for the next redesign; that is when it will quietly stop passing. Schema built once and verified on a schedule is most of what separates sites with durable rich results from sites that had them in 2023. If you would rather hand the whole discipline to a team that does it daily, that work lives under our schema markup service.