To add breadcrumbs that Google can show and crawlers can follow, do two things. Put a visible trail of real links on the page, and add a BreadcrumbList in JSON-LD that describes the same trail. Number the items from 1 at the top of the trail, and the last item may omit its URL [2].

What the markup changes is narrower than most guides imply. Google still supports breadcrumb markup, but since January 23, 2025 it no longer shows breadcrumbs on mobile search results. Desktop results still show them [5]. No source in our notes quantifies any ranking or click effect, so treat the markup as a clear description of where a page sits, not a lever.

What the two parts do

The visible trail and the JSON-LD do different jobs.

PartWho uses itWhat it needs
Visible trail (HTML links)Visitors, and crawlers that follow linksReal <a href> elements, server-rendered if possible
BreadcrumbList JSON-LDParsers that read structured dataItems that match the visible trail, in order

The visible trail is also internal linking. Each ancestor link gives crawlers a path up the hierarchy. See the internal linking guide for how that fits into the wider link structure.

Step 1: Build the visible trail

Use plain HTML. Mark the current page as text, not a link.

<nav aria-label="Breadcrumb">
  <ol>
    <li><a href="https://example.com/">Home</a></li>
    <li><a href="https://example.com/shoes/">Shoes</a></li>
    <li><a href="https://example.com/shoes/running/">Running shoes</a></li>
    <li aria-current="page">Trail Runner 2</li>
  </ol>
</nav>

Check that the trail is in the HTML the server returns, not only built by JavaScript after load. View the page source (not the inspector) and search for the links.

Step 2: Add the matching JSON-LD

<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": "Shoes",
      "item": "https://example.com/shoes/"
    },
    {
      "@type": "ListItem",
      "position": 3,
      "name": "Running shoes",
      "item": "https://example.com/shoes/running/"
    },
    {
      "@type": "ListItem",
      "position": 4,
      "name": "Trail Runner 2"
    }
  ]
}
</script>

Rules this follows:

  • Names match the visible labels. If the page says "Running shoes", the markup says "Running shoes", not a keyword-stuffed variant.
  • URLs are absolute and match the pages the links point to. Use the canonical URL of each ancestor. If your ancestors have duplicate URL variants, sort that out first with canonical tags.
  • **Every ListItem has a position and a name** [2].

Position numbering

Schema.org defines a BreadcrumbList as ordered ascending, with lower position values listed first, from the top of the trail toward the current page [1]. In practice:

  • Start at 1 and increase by 1 with no gaps or repeats.
  • Position 1 is the highest-level item you include. The current page gets the highest number.
  • The order in the array and the position values should agree.

Google does not require an item for the top-level path (the domain or host name) or for the page itself [3]. So a trail that starts at "Shoes" is acceptable. Including Home mirrors what most visible trails show, and keeping markup and visible trail identical is the simpler rule to maintain.

The last item without a URL

Google's examples show the final ListItem without an item property [2]. That is what the code above does for "Trail Runner 2". The current page's URL is already known from the page itself, so leaving it off avoids a mismatch. If you do include it, use the page's canonical URL.

A mistake to avoid: don't put a placeholder such as "item": "#" or an empty string on the last item. Omit the property.

Multiple trails

A product often lives under more than one category. Choose how to handle it deliberately:

  1. One visible trail, one BreadcrumbList. Pick the primary path (the main category, or the path the visitor came from) and mark up only that. This is the lowest-risk option.
  2. Several visible trails, one BreadcrumbList each. If the page genuinely shows two trails, mark up each as its own object. Put them in an array inside one script block, or in separate script blocks.
[
  {
    "@context": "https://schema.org",
    "@type": "BreadcrumbList",
    "itemListElement": [
      {"@type": "ListItem", "position": 1, "name": "Shoes", "item": "https://example.com/shoes/"},
      {"@type": "ListItem", "position": 2, "name": "Trail Runner 2"}
    ]
  },
  {
    "@context": "https://schema.org",
    "@type": "BreadcrumbList",
    "itemListElement": [
      {"@type": "ListItem", "position": 1, "name": "Sale", "item": "https://example.com/sale/"},
      {"@type": "ListItem", "position": 2, "name": "Trail Runner 2"}
    ]
  }
]

Don't mark up a trail that visitors cannot see on the page. Markup for hidden or invented paths is the fastest way to create a mismatch between what the page shows and what the data claims.

If you also publish Organization, WebSite or Article markup, a BreadcrumbList can sit in the same graph. JSON-LD @id and @graph covers how to connect them.

Validate it

  1. Rich Results Test. Paste the URL or the code. The tool supports JSON-LD, RDFa and Microdata, and lists breadcrumb as a supported rich result type [4]. Fix any errors it reports for missing position or name.
  2. View source. Confirm the script block is in the delivered HTML and parses as valid JSON. Typos in @type, trailing commas and late JavaScript injection are the usual reasons markup goes undetected; JSON-LD errors that hide structured data lists them.
  3. Search Console. Rich result reports are per rich-result type, and they are not a complete inventory of everything detected on your site [6]. A page missing from the Breadcrumbs report is not proof the markup is absent, so test individual URLs.
  4. After fixing a reported issue, use Validate fix. Validation can take two weeks or more, depending on crawl frequency, and you can follow progress on the issue details page [7].

For Google-specific behavior, rely on Google Search Central rather than schema.org [8]. Schema.org defines the type; Google's documentation says what it does with it.

Common mistakes

MistakeFix
Markup with no visible trailAdd the HTML trail, or remove the markup
Positions start at 0 or skip numbersStart at 1, step by 1
Last item carries a URL different from the pageOmit item or use the canonical URL
Trail built only by client-side JavaScriptRender it on the server
Labels in markup differ from visible textGenerate both from one data source
Site-wide static trail copied to every templateBuild it from the page's real position in the hierarchy

Generating both outputs from a single data structure in your template prevents most of these. Loop over the same array to render the <li> elements and the ListItems.

What to do next

  1. Pick one page template (product, article, category) and add the visible trail if it is missing.
  2. Generate the JSON-LD from the same data and deploy it to that template.
  3. Run three URLs through the Rich Results Test.
  4. Roll out to the other templates, then check the Breadcrumbs report in Search Console once it has data.
  5. Read Schema.org markup for AI search for the other types worth adding alongside it.