Breadcrumb schema: a JSON‑LD implementation guide

Structured breadcrumbs, or BreadcrumbList in the Schema specification, are the markup that lets Google display a readable navigation path in SERPs instead of a raw URL. The minimum implementation requires a BreadcrumbList containing several ListItem elements, each with item (a URL or @id) and position (an integer starting at 1) properties. The recommended format is JSON‑LD, placed in the page's <head>.

Here is a minimal example ready to deploy:

<script type="application/ld+json"> { "@context": "https://schema.org", "@type": "BreadcrumbList", "itemListElement": [ { "@type": "ListItem", "position": 1, "name": "Accueil", "item": "https://exemple.fr/" }, { "@type": "ListItem", "position": 2, "name": "Blog", "item": "https://exemple.fr/blog/" }, { "@type": "ListItem", "position": 3, "name": "Mon article", "item": "https://exemple.fr/blog/mon-article/" } ] } </script>

Pro tip: always test the markup in a staging environment whose canonical URLs are identical to production before deploying. A canonical pointing to staging invalidates the test.

JSON‑LD BreadcrumbList schema, validated through Rich Results Test and aligned with your canonicals, is the most accessible technical way to make your SERP results easier to read.

BreadcrumbList is a structured data type defined jointly by Google Search Central and Schema.org. Technically, it is an ItemList whose elements are ordered ListItem entries representing levels in the website hierarchy.

In SERPs, Google replaces the URL displayed beneath the title with a readable path such as ‘Home › Blog › My article’. This makes the result easier to read and may improve click-through rates, particularly on mobile where long URLs are truncated. Google does not guarantee breadcrumb display even with valid markup, but clean schema significantly increases the chances of obtaining this presentation.

The most relevant use cases:

The Schema.org BreadcrumbList specification and Google's guidelines define a precise set of properties. Here is what you need to know before writing the first line of code.

According to Schema.org's ListItem specification, position must be an integer, never a string such as "1" or a decimal value. The recommended order is ascending (ItemListOrderAscending), from the most general level to the most specific.

Some additional rules from Google's guidelines:

Pro tip: use `@id` rather than a simple `item` property when your website already uses Schema.org identifiers for its pages — this strengthens the structured data graph's consistency and makes it easier for Search Console to detect inconsistencies.

<script type="application/ld+json"> { "@context": "https://schema.org", "@type": "BreadcrumbList", "itemListElement": [ { "@type": "ListItem", "position": 1, "name": "Accueil", "item": { "@id": "https://exemple.fr/", "name": "Accueil" } }, { "@type": "ListItem", "position": 2, "name": "Catégorie", "item": { "@id": "https://exemple.fr/categorie/", "name": "Catégorie" } }, { "@type": "ListItem", "position": 3, "name": "Page courante" } ] } </script>

The third element deliberately omits item: Google uses the current page's URL, which Google Search Central confirms is the expected behaviour.

Microdata and RDFa remain valid alternatives, but maintenance is more demanding because the markup is intertwined with the HTML. A minimal microdata example:

<ol itemscope itemtype="https://schema.org/BreadcrumbList"> <li itemprop="itemListElement" itemscope itemtype="https://schema.org/ListItem"> <a itemprop="item" href="https://exemple.fr/"> <span itemprop="name">Accueil</span> </a> <meta itemprop="position" content="1" /> </li> <li itemprop="itemListElement" itemscope itemtype="https://schema.org/ListItem"> <span itemprop="name">Page courante</span> <meta itemprop="position" content="2" /> </li> </ol>

JSON‑LD ideally goes in the <head> of each relevant page. If technical constraints (a CMS without direct <head> access) require it, placing it immediately before </body> remains valid for Google — but <head> placement is preferable for code readability and consistency with other structured data.

Canonical alignment is the most commonly neglected point. Every item or @id in your BreadcrumbList must match the represented page's canonical URL exactly. If your product page's canonical is https://exemple.fr/produit/chaussure-x/, that URL must appear in the ListItem, not a variant with a UTM parameter or a session URL.

Placement best practices:

Pro tip: on headless architectures (Next.js, Nuxt), inject JSON‑LD through the framework's `<Head>` component to ensure it appears in server rendering (SSR), rather than being added only on the client — crawlers would not execute it reliably.

Validation follows a logical sequence: check JSON syntax, test rich results, then monitor in production.

Specific points to watch:

Pro tip: integrate Rich Results Test into your CI/CD pipeline through the Google Search Console API or a tool such as Screaming Frog configured to audit structured data on every scheduled crawl. This detects regressions before they reach production.

JSON‑LD schema is invisible to the user. Breadcrumbs displayed on screen must meet WCAG accessibility standards independently of the structured markup.

The French government design system provides a reference model for accessible HTML code, applicable to any French web project subject to digital accessibility requirements (RGAA). The recommended structure:

<nav role="navigation" aria-label="Vous êtes ici :"> <ol> <li> <a href="https://exemple.fr/">Accueil</a> </li> <li> <a href="https://exemple.fr/categorie/">Catégorie</a> </li> <li aria-current="page"> Page courante </li> </ol> </nav>

Accessibility checklist to validate before going live:

SEOPress automatically generates HTML breadcrumbs and provides a dedicated JSON‑LD option for crawlers, with control over separators and path templates. Activate it under Appearance › SEOPress › Breadcrumbs, then enable ‘Enable JSON‑LD breadcrumbs’. Other plugins such as Breadcrumb NavXT (available on WordPress.org) offer similar customization options.

For websites with multiple categories, SEOPress lets you define a primary term for each article, preventing inconsistent paths between pages of the same content type.

If you prefer controlling JSON‑LD without depending on a plugin, add this hook to functions.php:

```php add_action( 'wp_head', 'mon_breadcrumb_jsonld' ); function mon_breadcrumb_jsonld() { if ( ! is_singular() ) return; $items = [];

// Exemple minimal pour une page de catégorie : $items[] = [ 'position' => 1, 'name' => 'Accueil', 'item' => home_url('/') ]; $items[] = [ 'position' => 2, 'name' => get_the_title(), 'item' => get_permalink() ]; $schema = [ '@context' => 'https://schema.org', '@type' => 'BreadcrumbList', 'itemListElement' => array_map( function($i) { return [ '@type' => 'ListItem' ] + $i; }, $items ), ]; echo '<script type="application/ld+json">' . wp_json_encode($schema) . '</script>'; } ```

Pro tip: after activating a plugin or deploying the PHP hook, always clear the cache (caching plugin + CDN), then immediately test a representative URL with Rich Results Test. Cache errors are the main cause of undetected markup after deployment.

WordPress post-activation checklist:

Most production BreadcrumbList errors fall into four categories.

Non-integer positions. A "1" value (string) instead of 1 (integer) produces a warning in Rich Results Test. Check that your JSON serializer does not surround integers with quotation marks.

URLs inconsistent with canonicals. If item points to https://exemple.fr/produit/?ref=newsletter while the canonical is https://exemple.fr/produit/, Search Console detects an inconsistency. Always use the clean canonical URL.

Marking up non-navigation links. A search filter, JavaScript anchor link or pagination link is not a navigation level. BreadcrumbList must represent a path a user can actually follow by clicking.

A path that does not reflect actual navigation. Marking up the raw URL structure rather than the logical user journey is a common mistake. If your URL is /fr/blog/2024/categorie/article/, the breadcrumbs do not necessarily need all these segments — only those corresponding to real navigation pages.

Pre-deployment checklist:

Pro tip: for multilingual websites, generate a distinct `BreadcrumbList` for each language version, with URLs matching each language's hreflang canonicals. Do not share one schema across several versions.

Structured breadcrumbs are often treated as an end-of-sprint task, added afterwards. This is a prioritisation mistake. On e-commerce and documentation websites we audit at Pharelia, missing or incorrectly configured BreadcrumbList is among the most frequently absent structured data, although it is one of the simplest to implement correctly.

What strikes me more is the persistent confusion between visible HTML breadcrumbs and JSON‑LD schema. Some developers implement one without the other, or both inconsistently — different URLs in the structured markup and HTML links. Google reconciles both signals: an inconsistency between them can reduce confidence in the schema.

The process we consistently recommend: a technical audit of existing structured data, staging implementation with canonical URLs identical to production, automated Rich Results Test validation, then gradual deployment with Search Console monitoring active from D+1. Automating BreadcrumbList audits in the CI/CD pipeline reduces regressions during template updates — a point teams underestimate until their first post-deployment incident.

An incorrectly configured BreadcrumbList generates no visible error — it goes unnoticed until the next Search Console audit. Pharelia handles the full technical scope: auditing existing structured data, fixing canonical/@id inconsistencies, validating through Rich Results Test and continuously monitoring Search Console. We deploy into your current stack — WordPress, Shopify, Webflow or any custom architecture — without reconfiguring your environment.

Every engagement starts with a free visibility audit covering crawling, structured data and organic performance signals. For teams wanting to go further with visibility in generative engines, our AI search optimization resources complement the technical work.

Contact us.

Official resources and validation tools for exploring and maintaining your implementation:

Breadcrumbs are a navigation element showing users their position in a website's hierarchy as a clickable path (e.g. Home › Category › Page). In SEO, the term also refers to BreadcrumbList markup, which communicates this hierarchy to Google as structured data.

HTML breadcrumbs are the visible on-screen component users navigate. JSON‑LD schema is an invisible metadata block placed in the <head>, communicating the same hierarchy to Google for SERP display. The two must be consistent.

No. Google explicitly states that valid BreadcrumbList markup increases the chances of a navigation path appearing in results, but does not guarantee it. Other factors matter, including overall page quality and relevance signals.

A minimum number of elements is required under Google Search Central's guidelines to form a valid navigation path.

Define a documented priority rule for each article's primary term, and configure your plugin (SEOPress, for example) to use that primary term consistently in the path. Apply the rule uniformly to avoid inconsistent paths between pages of the same content type.