Breadcrumb schema for local sites: a technical guide
A local site with services and locations is a small hierarchy: a home page, service categories, individual services, and city pages hanging off them. Breadcrumbs are how you show that hierarchy to a visitor, and BreadcrumbList schema is how you show the same hierarchy to a search engine in a form it can parse without guessing. This guide covers the markup, the properties, and the mistakes that quietly break it.
Breadcrumb schema is structured data, written in JSON-LD using the schema.org BreadcrumbList type, that describes the path from a site home page to the current page as an ordered list. Each step is a ListItem with a position, a name, and usually an item URL, so search engines can read a page's place in the site hierarchy directly.
What are breadcrumbs, and what is BreadcrumbList schema?
Breadcrumbs are the small navigational trail near the top of a page that shows where it sits, such as Home / Services / Roof repair. BreadcrumbList is the schema.org type that expresses that same trail as machine-readable structured data. The visible breadcrumb helps a person orient; the BreadcrumbList markup hands a search engine the identical path as an ordered, parseable list.
A breadcrumb is a row of links that traces a page back to the home page, one level at a time. On a local services site it usually reads something like Home / Services / Drain cleaning, or Home / Locations / Naples. It exists so a visitor who lands mid-site from a search result can see the surrounding structure and step up a level.
BreadcrumbList is the schema.org type built for exactly this trail (schema.org, 2026)[1]. It holds an "itemListElement" array, and each entry describes one step in the path. The visible breadcrumb and the BreadcrumbList markup are two representations of the same thing: one rendered for people, one structured for machines. The goal is to keep them saying the same thing.
Breadcrumb schema is narrow on purpose. It answers one question cleanly: where does this page sit in the site? That is a different job from the entity description handled by LocalBusiness markup, which is why we treat the two as separate layers of the work on our schema markup services page.
Why do breadcrumbs clarify site hierarchy for search and users?
For users, a breadcrumb answers "where am I and how do I go up a level" at a glance, which matters most when someone arrives on a deep page straight from search. For search engines, BreadcrumbList states a page's position in the site structure explicitly, so an engine does not have to infer hierarchy from the URL or the menu. Both audiences get the same clear map.
Most visitors do not enter through the home page. They land on a specific service or city page from a search result, with no sense of the pages around it. A breadcrumb gives that visitor immediate orientation and a one-click path up to the broader category, which is a genuine usability gain rather than decoration.
Search engines benefit from the same clarity in a structured form. Google uses breadcrumb markup to categorize the page within the site and can display that trail in results (Google, 2026)[2]. An explicit ordered path removes ambiguity that URL structure alone can leave, especially where the URL does not mirror the logical hierarchy.
Google is specific about one nuance here: breadcrumbs should represent a typical user path to the page, not simply mirror the URL structure (Google, 2026)[2]. The trail should reflect how a person would navigate to the page, which is often cleaner than a raw URL. On a local site, that usually means a short, honest path through the category a customer would actually browse.
How do you write BreadcrumbList in JSON-LD?
Use a single script block of type application/ld+json. Set "@context" to "https://schema.org" and "@type" to "BreadcrumbList", then give it an "itemListElement" array. Each element is a ListItem carrying a "position", a "name", and an "item" URL. Google recommends JSON-LD for structured data, and keeping the whole trail in one block makes it easy to generate and audit (Google, 2026).
The outer object is a BreadcrumbList with one property that does the work: "itemListElement", an array listed in order from the home page down to the current page (Google, 2026)[2]. Everything about the trail lives inside that array, so a single script tag holds the complete path and nothing in the visible layout has to change to support it.
Each entry in the array is a ListItem with three fields. "position" is an integer marking the step, starting at 1. "name" is the title shown for that step, such as "Services" or "Roof repair". "item" is the URL that step points to. A typical local trail is three ListItems: the home page at position 1, the service category at position 2, and the specific service at position 3.
Render this in the initial server response, not through a client-side tag that builds it after load, because parsers that do not execute JavaScript will otherwise never see it. Because a local site's breadcrumbs follow a repeating pattern, the practical approach is to generate the BreadcrumbList from the same data that renders the visible trail, so the two can never drift apart.
What do position, name, and item each do?
These three ListItem properties define one step of the trail. "position" is the integer order, starting at 1, and it is what fixes the hierarchy rather than the order the items happen to appear in the code. "name" is the human-readable label for the step. "item" is the URL that step links to. Together they let an engine reconstruct the exact path without guessing.
The "position" property carries more weight than it looks. Position 1 signifies the beginning of the trail, and the integers ascend from there (Google, 2026)[2]. schema.org notes that ListItem exists precisely because markup order alone does not guarantee order, so the position number, not the sequence in the file, establishes the hierarchy (schema.org, 2026)[3]. Numbering the steps out of order is a real error even if the array looks right.
The "name" is the label a user would read for that step, such as "Locations" or "Naples". It should match the text of the visible breadcrumb for that step. This is the field that appears when the trail is shown, so it needs to be a clean, human title rather than a slug or a keyword-stuffed phrase.
The "item" is the URL the step represents. Every step except the last should carry an "item" pointing at that level's page; the final crumb, being the current page, can omit "item" because it does not need to link to itself (Google, 2026)[2]. Getting these URLs right, in canonical form, is what lets an engine tie each step to a real page.
How do breadcrumbs appear in search results?
When Google chooses to show them, breadcrumbs replace the raw URL in a search result with the readable trail, so a listing can display Home > Services > Roof repair instead of a long slug. Google categorizes the page using the markup and may show that trail based on the query. It is eligibility, not a guarantee, and Google decides per result whether to render it.
The visible payoff is in the search snippet. Instead of a bare URL under the title, a result can show the breadcrumb trail, which reads more clearly and tells a searcher where the page sits before they click. Google uses the markup to categorize the information from the page in results (Google, 2026)[2], and the trail it shows can reflect the query rather than one fixed path.
Be honest about what this is. Marking up breadcrumbs makes a page eligible for that display; it does not force it. Google decides per result whether to render the trail, and there is no markup that guarantees it will. Anyone promising a breadcrumb rich result from schema alone is overselling it, because the decision sits with Google, not with your code.
For a local site, the value holds even when Google does not draw the trail. The same markup still communicates hierarchy to ranking systems and to AI assistants that assemble answers from structured signals, and the visible breadcrumb still helps every visitor who lands on a deep page. The display is a bonus on top of work that pays off regardless.
What are the most common breadcrumb schema errors?
The frequent failures are predictable: marked-up breadcrumbs that do not match the visible trail, positions numbered in the wrong order, missing or non-canonical item URLs, and markup injected only by client-side script so crawlers never see it. Each feeds an engine a contradiction or a gap. Correct breadcrumb schema mirrors the visible trail exactly and states the path in the right order.
The first and most common error is a mismatch between the visible breadcrumb and the marked-up one. Google's guidance is that structured data should reflect the visible content of the page, so a BreadcrumbList that lists steps a user cannot see on the page, or that names them differently, is inconsistent by construction. Generate both from one source so they cannot diverge.
The second is order. Because "position" defines the hierarchy and not the array sequence, a trail whose positions are numbered wrong, or whose steps run child-to-parent instead of home-to-current, describes a path that does not exist. Google's guidance is that the trail should represent a typical user path rather than mirror the URL (Google, 2026)[2], so check that the order matches how a person would actually navigate.
The rest cluster around URLs and rendering. Every non-final step needs an accurate "item" URL in its canonical form, or the step points nowhere useful. And JSON-LD that only appears after a tag manager runs may never be read by crawlers that do not execute JavaScript, so render it server-side. Validate the result before shipping, and watch Search Console for breadcrumb issues after.
How do breadcrumbs fit a local site's service and location structure?
A local site typically branches two ways: by service and by location. Breadcrumbs make each branch explicit, so a service page reads Home / Services / Drain cleaning and a city page reads Home / Locations / Naples. Marking up each trail with BreadcrumbList tells an engine how your services and markets nest, which is exactly the structure a local business needs an engine to understand.
Think of the site as a shallow tree. The home page sits at the top; service and location categories sit one level down; individual service pages and city pages sit below those. A breadcrumb is just the path from the top of that tree to the page a visitor is on, and BreadcrumbList encodes that path in a form an engine reads directly.
Keep each trail to the path a customer would actually take. A page for drain cleaning in a specific city does not need to cram both the service branch and the location branch into one breadcrumb; pick the primary path a person would navigate and mark that up, consistent with Google's guidance to reflect a typical user path (Google, 2026)[2]. One clean trail beats a crowded one.
Breadcrumbs are one layer of a local site's technical foundation, not the whole of it. They sit alongside the LocalBusiness entity markup, internal linking, and the crawl and indexing work covered on our technical SEO services page. Together, a clear breadcrumb trail and a well-formed entity graph give an engine both a map of where each page sits and a precise description of the business behind it.
How do you validate breadcrumb markup?
Validate in two places. The Schema Markup Validator at validator.schema.org confirms the BreadcrumbList is syntactically valid schema.org. Google's Rich Results Test at search.google.com/test/rich-results confirms Google can read it and whether the page is eligible for the breadcrumb result. After a page is indexed, the breadcrumb reports in Google Search Console track valid, warning, and error items so you catch regressions.
Start with the Schema Markup Validator at validator.schema.org (schema.org, 2026)[4]. Paste the URL or the snippet and it parses every node, lists the properties it found, and flags anything that is not valid schema.org. It confirms the BreadcrumbList and its ListItems are well-formed and use real properties, which is the first gate to clear before worrying about how Google treats them.
Then run Google's Rich Results Test at search.google.com/test/rich-results (Google, 2026)[5]. It reports whether Googlebot can fetch and render the page, whether the page is eligible for the breadcrumb feature, and any errors against Google's stricter requirements. Because it renders as Googlebot, it also reveals whether script-injected markup actually appears or was missed.
Validation is not one-time. Once the page is indexed, Search Console's breadcrumb report tracks issues over time, which is how you catch a template change that quietly broke the markup on every page at once. The sequence is simple: build the JSON-LD, clear the validator, confirm eligibility in the Rich Results Test, then monitor Search Console.
Turn on what makes AI recommend you.
AI recommends the businesses it can read, trust and quote. Flip on the four signals we engineer, and watch your visibility climb and the answer rewrite itself.
Illustrative · the four signals are the real system we build
This article, answered.
The questions readers ask about this topic, answered the way an answer engine would. No forms, no sales pitch.
Pick a question on the left — you'll get the direct answer, the way an answer engine would give it.
LAST UPDATED July 10, 2026 · WRITTEN BY JAMIE KLONCZ, FOUNDER · SEO ELITE AGENCY, NAPLES FL
Enter a path and click verify.