Aizii Learn · AI Search

[← Back to Learn](https://aizii.ai/learn)

# How to add breadcrumb schema for AI

A breadcrumb is the trail of links near the top of a page that shows where the page sits in your site, such as Home, then Cookware, then a single pan. Breadcrumb schema is the machine-readable version of that trail, written as a BreadcrumbList in JSON-LD, with one ListItem per level, each carrying a position, a name, and the address of that level. Google uses breadcrumb markup in the body of a web page to categorize the information from the page in search results, and the feature is available on desktop in all regions and languages where Google Search is available. For AI search, the value is narrower and worth stating plainly: Google says structured data is not required for generative AI search, and there is no special schema.org markup you need to add to appear in AI Overviews or AI Mode. Add breadcrumbs because they make your site hierarchy legible to every reader, human and machine, not because they buy a citation.

A breadcrumb trail matters to AI systems for a simple reason. An assistant that reads a product page needs to know what the product is and where it belongs: which collection, which category, which brand. A page with no trail is a page with no context. Breadcrumbs do not carry prices, stock, or reviews. Those belong in the product markup on the same page.

## Where it goes wrong

Breadcrumb markup fails in a few specific ways, and most of them come from generating the trail from the address instead of from the navigation a shopper actually uses.

-   The markup mirrors the address instead of the user path. Google recommends providing breadcrumbs that represent a typical user path to a page, instead of mirroring the address structure. A product that lives under a long filtered address gets a trail of filter values instead of a trail of categories. Build the trail from the category path a shopper follows, not from the segments of the address.
-   The markup does not match the visible trail. The links a shopper sees say one thing and the JSON-LD says another: different names, different destinations, or a different number of levels. Generate both from the same source, so they cannot drift apart.
-   The positions are wrong. The position values must be integers starting at 1, in order, with the first item at the top of the trail. Schema.org says the order of elements in the markup alone is not enough to show the order, and the position property is what reconstructs it.
-   The trail has only one item. A BreadcrumbList needs at least two ListItem entries to be useful, because a single item is not a trail. A product page with only its own name and no parent category has nothing to say about where it sits. Give every page below the home page at least one parent level.
-   The last item links to itself, or carries a wrong address. The item property is the address of that level, and it is optional on the final entry, the page the reader is already on, since that page does not need to link to itself. If you include it, it must be the canonical address of the current page.
-   The trail includes levels that are not pages. Filter values, sort orders, search terms, and pagination states are not levels in your site hierarchy, and they do not belong in the trail. A trail that lists a filter as a level tells the reader the store has a category it does not have.
-   The same product gets a different trail on every page that links to it. Google allows more than one breadcrumb trail for a single page when there are several ways to reach it, with each trail written as its own BreadcrumbList. Pick one rule and apply it to every product.
-   The markup uses an old vocabulary. Markup from data-vocabulary.org is no longer eligible for Google rich result features. Use the schema.org BreadcrumbList type, with JSON-LD as the format, since Google recommends JSON-LD where your setup allows it.

## The steps

**Step 1. Decide the trail for each page type.** The marketer lists the levels a shopper follows to reach each kind of page: home, then a collection, then a subcollection, then the product. A category page gets home, then the parent collection, then itself. A guide gets home, then the guides section, then itself. Write the trails down before anyone writes code, and keep them short: three or four levels is enough for most stores. A trail with eight levels is a trail nobody reads.

**Step 2. Build the visible trail and the markup from the same source.** The developer changes the template so the visible breadcrumb links and the JSON-LD block are generated from the same list of levels. The visible trail shows the names as links, with the current page as plain text at the end. The JSON-LD block carries the same names and addresses, with a position starting at 1 for the first level.

**Step 3. Write the JSON-LD block in the page head.** The developer adds a script block of type application slash ld plus json to the head of each template, containing a BreadcrumbList with an itemListElement array of ListItem entries. Each ListItem carries a position, a name, and an item address, except the last entry, where the item address is optional. Use absolute addresses, not relative ones, so a reader that picks up the block on its own can still follow the links. Keep the block on every page below the home page, and leave it off the home page itself, where there is no trail to describe.

**Step 4. Handle products in more than one collection.** The marketer picks the rule for products that sit in two collections: either the trail follows the collection the shopper came from, or the template always uses one canonical collection for that product. If the store needs both trails on one page, the developer writes each trail as its own BreadcrumbList block, since Google supports more than one trail for a single page. Pick one rule, write it down, and apply it to every product. A rule that changes per page is not a rule.

**Step 5. Validate the markup before it goes live.** The developer pastes a page from each template into the Rich Results Test and fixes any errors it shows, such as a missing position, a wrong type, or an address that does not load. Then the developer deploys the templates to a few pages first and uses the URL Inspection tool to test how Google sees the page. Do not roll the markup out to the whole catalog until the sample pages pass.

**Step 6. Recheck the trails when the catalog changes.** The marketer and the developer recheck the trails when a collection is renamed, moved, or removed. A renamed collection must change the visible trail and the markup at the same time. A trail that lags the catalog teaches the reader last season's store.

## The machine-readable piece

This is the JSON-LD block for a product page in a kitchenware store, following the Google breadcrumb example. The visible trail on the page reads Home, then Cookware, then Pots and Pans, then the product name. The last entry has no item address, because it is the page the reader is already on. Replace the placeholders with your own addresses and names.

```
<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "BreadcrumbList",
  "itemListElement": [{
    "@type": "ListItem",
    "position": 1,
    "name": "Home",
    "item": "https://[yourdomain.com]/"
  },{
    "@type": "ListItem",
    "position": 2,
    "name": "Cookware",
    "item": "https://[yourdomain.com]/collections/cookware"
  },{
    "@type": "ListItem",
    "position": 3,
    "name": "Pots and Pans",
    "item": "https://[yourdomain.com]/collections/pots-and-pans"
  },{
    "@type": "ListItem",
    "position": 4,
    "name": "Example Stainless Steel Fry Pan"
  }]
}
</script>
```

And this is the visible trail that goes with it, on the same page, built from the same levels. A shopper sees the names as links, with the current page as plain text at the end.

```
<nav aria-label="Breadcrumb">
  <ol>
    <li><a href="https://[yourdomain.com]/">Home</a></li>
    <li><a href="https://[yourdomain.com]/collections/cookware">Cookware</a></li>
    <li><a href="https://[yourdomain.com]/collections/pots-and-pans">Pots and Pans</a></li>
    <li>Example Stainless Steel Fry Pan</li>
  </ol>
</nav>
```

Check the block before you publish it. Paste a page from each template into the Rich Results Test and fix any errors it shows. Open the live page and confirm the visible trail and the markup carry the same names in the same order. Do not add a level, a name, or an address you cannot verify against the live site.

## What it looks like when it works

On the page, a shopper sees a short trail near the top: Home, then Cookware, then Pots and Pans, then the pan. Each level except the last is a link, and the shopper can step up one level at a time. Under the surface, the same trail sits in the page head as JSON-LD, with the same names, the same addresses, and positions starting at 1. An assistant asked about the pan can see it belongs in pots and pans, inside cookware, and can say so with the collection pages to back it up.

Say you run a kitchenware store, selling cookware, knives, and bakeware, with a stainless steel fry pan that sits in the pots and pans collection inside cookware. The marketer writes the trail down first: Home, Cookware, Pots and Pans, then the pan. The developer changes the product template so the visible trail and the JSON-LD block are generated from the same list, with positions starting at 1 and the last entry carrying no address. The developer validates a sample product page in the Rich Results Test and deploys the template. When the store renames the pots and pans collection, the visible trail and the markup change together. A shopper asks an assistant for a stainless steel fry pan that works on induction. The assistant can find the pan, see where it sits in the catalog, and cite the store with the collection to back it up.

### The fundamentals

These mechanics are shared across every engine and covered in full in their own guides:

-   •The llms.txt format and a complete sample, see our [guide to writing a good llms.txt file](https://aizii.ai/learn/ai-search/how-to-write-a-good-llms-txt-file)
-   •The markup AI systems read to verify facts, see our [product schema guide](https://aizii.ai/learn/ai-search/how-to-add-product-schema-markup-for-ai-search)
-   •The complete crawler rule reference, see our [robots.txt guide for AI search](https://aizii.ai/learn/ai-search/how-to-write-robots-txt-for-ai-search)

## What this guide does not cover

This guide covers adding breadcrumb schema so a page shows where it sits in your site. It does not cover the full technical audit that checks every crawler and every page, the transaction layer that lets an agent complete a purchase, or the per-engine playbooks for getting each assistant to find you. It does not cover product markup for prices and availability, review markup, or organization markup, which have their own guides. Those are separate jobs, and this guide is the map, not the whole trip.

## Check your own store now

Run the free scan. One click, no signup, and it shows whether AI crawlers can read your store today: aizii.ai/aeo-scan

[Run the free scan](https://aizii.ai/aeo-audit)

## Sources

-   Google Search Central, Breadcrumb structured data (specific): [https://developers.google.com/search/docs/appearance/structured-data/breadcrumb](https://developers.google.com/search/docs/appearance/structured-data/breadcrumb)
-   Schema.org, BreadcrumbList type (specific): [https://schema.org/BreadcrumbList](https://schema.org/BreadcrumbList)
-   Google Search Central, Optimizing your website for generative AI features on Google Search (specific): [https://developers.google.com/search/docs/fundamentals/ai-optimization-guide](https://developers.google.com/search/docs/fundamentals/ai-optimization-guide)
-   Google Search Central, Product structured data (specific): [https://developers.google.com/search/docs/appearance/structured-data/product](https://developers.google.com/search/docs/appearance/structured-data/product)
-   Schema.org, Product type (specific): [https://schema.org/Product](https://schema.org/Product)

Note: links marked specific point to the page that supports the claim in this guide. Links marked general docs point to the vendor's general docs section for that topic, not to a page that proves every step. Check the vendor docs for the current path before relying on a menu name or click path in this guide.
