A site adds BreadcrumbList markup, waits for a recrawl, and then asks why nothing changed in the search results. The markup validates. The trail is there in the source. And the result looks exactly as it did before.
Three things are usually true at once. The site was checking on a phone, where breadcrumbs have not appeared since January 2025. The expectation was a new element in the result, when breadcrumbs are a segment of an existing one. And the theme was already emitting a trail, so the new markup either duplicated it or contradicted it.
Each of those is fixable. None of them is fixed by adding more markup.
The Feature Has Two Halves
Google’s breadcrumb documentation opens with what the trail is for:
A breadcrumb trail on a page indicates the page’s position in the site hierarchy, and it may help users understand and explore a site effectively.
Then it explains what the markup does:
Google Search uses breadcrumb markup in the body of a web page to categorize the information from the page in search results.
Both halves matter. The markup describes a trail that exists on the page. If the page has no visible trail, the markup is describing something a visitor cannot see, and the general structured data guidelines treat that as a content problem rather than a technical one.
So there are two separate jobs: put a usable trail on the page, and describe that same trail in JSON-LD. Most WordPress sites do one of them twice and the other one badly.
Desktop Only, and That Has Been True Since January 2025
The documentation’s feature availability section is one sentence:
This feature is available on desktop in all regions and languages where Google Search is available.
That sentence exists because of a documentation update on January 22, 2025, which recorded the reasoning:
Because of how breadcrumbs get truncated on smaller screens, we’ve found this feature isn’t as useful to people who are searching on mobile. Breadcrumbs will continue to appear on desktop search results.
The practical consequences are easy to state and easy to forget:
- A mobile result will never show the trail. If most of your traffic is mobile, a breadcrumb project has a smaller ceiling than the numbers in an SEO tool suggest.
- Device splits in Search Console are the honest measurement. A desktop-only feature shows up as a desktop-only change, and a sitewide average can hide it entirely.
- The visible trail still earns its place on mobile. A breadcrumb improves navigation and orientation on small screens whether or not Google displays the markup. That is a UX reason to keep it, not a search reason.
It Is Not a Card in the Result
The most common wrong mental model is that breadcrumbs add a row to a search result. They do not. Google’s visual elements gallery describes the visible URL as having exactly two parts:
A visible URL has two parts: domain and breadcrumb.
The domain is your site address. The breadcrumb is “the trail that shows the page’s position within the site’s hierarchy”. In other words, the trail replaces the path portion of the URL line, which is why a correct implementation can look like nothing happened: example.com › services › consulting instead of example.com/services/consulting/.
That reframing changes what “fixing” means. You are not adding a feature. You are changing how the path reads, from a slug to a category. For a page whose URL is /2026/11/18/post-2847/, the improvement is visible. For a page whose URL is already clean, the change is subtle and the work may not be worth it.
The Rules That Decide Whether It Renders
The requirements are short enough to check by hand.
| Property | Required | Notes |
|---|---|---|
BreadcrumbList | Yes | The container; must hold at least two ListItem objects |
itemListElement | Yes | The array of items |
position | Yes per item | Integer; position 1 is the beginning of the trail |
name | Yes per item | The title shown to the user |
item | Yes, except the last | The URL of that breadcrumb’s page |
Three details from that table cause most of the failures.
At least two items. A trail of one is not a trail. A plugin that emits only “Home” on the homepage, or a template that emits the current page as its own ancestor, produces a BreadcrumbList that cannot be eligible.
item is optional only for the last item. The documentation is specific:
If the breadcrumb is the last item in the breadcrumb trail, item is not required. If item isn’t included for the last item, Google uses the URL of the containing page.
Omitting item on a middle item is a different thing entirely: Google has no URL for that step, so the step is not a link and the trail is broken.
position starts at 1 and follows the trail. Gaps and duplicates are a parsing problem, not a cosmetic one.
Multiple Trails Are Allowed, Contradictions Are Not
Google explicitly supports more than one trail for a page:
If there are multiple ways to navigate to a page on your site, you can specify multiple breadcrumb trails for a single page.
The documentation’s own example has a book award page reachable through both Books › Science Fiction › Award Winners and Literature › Award Winners. Both are real paths, and both are marked up.
That permission is narrower than it sounds. It covers several genuine navigation routes. It does not cover two emitters producing the same trail twice, or one trail derived from categories and another invented from the URL. When the trails disagree about where a page sits, the page’s position is unclear, and the disagreement is the problem.
Use the Path a Reader Takes, Not the Path in the URL
The guidelines include a line that decides most WordPress implementations:
We recommend providing breadcrumbs that represent a typical user path to a page, instead of mirroring the URL structure. It is not required to include a breadcrumb ListItem for the top level path (your site’s domain or host name), nor for the page itself.
This matters because WordPress permalinks are usually flat. Set the permalink structure to /%postname%/ and every post URL is one level deep, with no hierarchy for a URL-based breadcrumb to read. A plugin that builds the trail from REQUEST_URI then has two options: emit Home › The Post Title, or emit nothing. Neither is the trail the reader took to arrive.
The real path comes from somewhere else:
- Pages have a genuine hierarchy through
post_parent, which is what the builder below reads. - Posts usually belong to a category, and the category may have a parent.
- Products have
product_cat, which can nest several levels deep. - Custom post types have whatever taxonomy you gave them, and nothing otherwise.
If a page has no meaningful parent, the honest trail is Home › Section › Page, where the section exists in the navigation. It is not Home › Uncategorized › Page, which is what several plugins produce when the category lookup fails.
The Two-Emitters Problem
Most WordPress sites have at least two things that want to output breadcrumbs: the theme’s template and an SEO plugin. One usually emits microdata or RDFa inside the <nav>; the other emits a JSON-LD block in the head. Both are valid on their own. Together they produce two trails, which is either permitted (two real paths) or noise (the same path twice).
You cannot tell which case you are in by looking at the admin. Look at the rendered HTML:
# Fetch the page once, then count what it actually emits.
curl -s https://yourdomain.com/services/consulting/ > page.html
# JSON-LD trails (one count per BreadcrumbList object)
grep -o 'BreadcrumbList' page.html | wc -l
# Items across all trails
grep -o '"ListItem"' page.html | wc -l
# A theme-emitted microdata trail, if the theme uses microdata
grep -c 'itemprop="itemListElement"' page.html
Read the output as a story. One BreadcrumbList with three items gives 1 and 3, and the microdata count is 0. Two trails give 2 and the total items across both. If the numbers do not match the trail you can see in the source, an emitter is doing something the admin screen does not show.
A microdata count above zero alongside a JSON-LD trail means both emitters are live. Pick one. In practice that means turning the breadcrumb schema off in whichever plugin offers the switch, and keeping the visible <nav> where the theme already renders it.
A Builder That Follows the Page Hierarchy
If you are generating the markup yourself, the hierarchy is already in the database. get_post_ancestors() returns the parent chain for a page, nearest parent first, which is the reverse of the order a trail needs.
function wpf_breadcrumb_items( $post_id ) {
$items = array(
array(
'name' => __( 'Home', 'wpfrank' ),
'url' => home_url( '/' ),
),
);
foreach ( array_reverse( get_post_ancestors( $post_id ) ) as $parent_id ) {
$items[] = array(
'name' => get_the_title( $parent_id ),
'url' => get_permalink( $parent_id ),
);
}
$items[] = array(
'name' => get_the_title( $post_id ),
'url' => '',
);
return $items;
}
add_action( 'wp_head', function () {
if ( ! is_singular( 'page' ) ) {
return;
}
$post_id = get_queried_object_id();
$items = wpf_breadcrumb_items( $post_id );
if ( count( $items ) < 3 ) {
return;
}
$list = array();
foreach ( $items as $index => $item ) {
$entry = array(
'@type' => 'ListItem',
'position' => $index + 1,
'name' => $item['name'],
);
if ( '' !== $item['url'] ) {
$entry['item'] = $item['url'];
}
$list[] = $entry;
}
$schema = array(
'@context' => 'https://schema.org',
'@type' => 'BreadcrumbList',
'itemListElement' => $list,
);
echo '<script type="application/ld+json">'
. wp_json_encode( $schema, JSON_UNESCAPED_SLASHES | JSON_UNESCAPED_UNICODE )
. '</script>' . "\n";
} );
Why it is built this way:
array_reversefixes the order.get_post_ancestors()returns nearest first; a trail needs the top level first.- The last item has no
item. That reproduces Google’s own example and lets Google use the page’s URL, without hard-coding a permalink that changes with a slug edit. - The
< 3guard is deliberate. Home plus one parent plus the page is the shortest trail worth emitting. Below that, the site has no hierarchy to describe, and a two-item trail of Home and the page adds nothing. wp_json_encodewith the unescaped-slash flags. WordPress’s wrapper handles encoding failure and keeps URLs readable in the source.
Two limits worth stating. This handles pages only; posts and products need their taxonomy trail instead, which is a separate function. And it does not render anything visible, which is the next problem.
Print the Trail You Are Describing
The markup is a description. The page needs the thing being described. WordPress themes vary, but the shape is stable:
<nav class="breadcrumb" aria-label="Breadcrumb">
<ol>
<li><a href="https://yourdomain.com/">Home</a></li>
<li><a href="https://yourdomain.com/services/">Services</a></li>
<li aria-current="page">Consulting</li>
</ol>
</nav>
Three details make it match the markup and work for more readers:
- The labels are identical. If the trail says “Services”, the
nameis “Services”, not “Our Services” and not the slug. A mismatch is the sort of thing Google’s guidelines call out as describing content that differs from the page. - The separator is CSS, not text.
li + li::before { content: "\203A"; }keeps the “›” out of the accessibility tree. Typing the character into the HTML gets read aloud by some screen readers, usually as “single right-pointing angle quotation mark”. aria-current="page"marks the last item. It tells a screen reader which step is the current page, which is information the visual styling carries and the markup alone does not. The accessibility guide covers the broader pattern.
The labels also need to survive slug edits. A builder that reads get_the_title() follows a renamed page automatically; a hard-coded array does not.
WooCommerce Needs Its Own Trail
Products break the page builder in two ways: they are not pages, and their hierarchy lives in a taxonomy. The trail readers expect is Home › Shop › Category › Subcategory › Product.
The term chain comes from get_ancestors(), which returns term IDs nearest first — the same order as get_post_ancestors() — so the array needs reversing before it can become a trail:
$category_ids = $product->get_category_ids();
$terms = array();
if ( $category_ids ) {
$terms = array_reverse(
get_ancestors( $category_ids[0], 'product_cat', 'taxonomy' )
);
}
Three WooCommerce-specific decisions follow:
- Use the product’s primary category, not all of them. A product in four categories has four possible trails. Pick the one that matches the visible breadcrumb and use it for both.
- Attribute and tag archives usually have no hierarchy. A trail of
Home › Shop › Blueinvents a level that does not exist in the catalogue. If the archive has no parent term, the honest trail is the shop page plus the archive itself, which tells Google nothing the result does not already say. Omitting the markup is the better call. - Keep the Shop page. It is the top of the commercial hierarchy and readers expect it. Dropping it to shorten the trail breaks the match with the visible breadcrumb.
The semantic SEO guide covers why the category structure itself matters beyond the markup. A deep, well-named category tree produces a useful trail. A flat catalogue with 200 uncategorised products produces a trail that reads Home › Shop › Product, which is accurate and tells Google nothing.
What Breadcrumbs Cannot Do
Four expectations worth dropping before the work starts:
They are not a ranking factor. The markup makes a page eligible for the trail in the visible URL of a desktop result. It does not move the page up, and the ranking guide covers what does.
They do not repair site structure. If the navigation is flat, the trail is flat. Markup describes the hierarchy; it does not create one.
They do not replace internal links. A breadcrumb is a navigation aid at the top of a page. The contextual links inside the content are what pass readers and crawlers to related pages, and the internal linking guide covers that job. A trail is not a substitute for a body link.
They do not make an orphan page findable. A page nobody links to is still an orphan with a tidy trail. The broken link guide is the more useful starting point for that problem.
Verify It
The Rich Results Test is the fastest check for a single URL: it reports whether the BreadcrumbList parses and whether the items carry the required properties. Paste the URL, not a code fragment, so the test sees what Google sees.
For the sitewide view, URL Inspection shows what Google parsed for a live page, and Search Console’s structured data reports aggregate the valid and invalid items for the features it tracks. Both are more reliable than a plugin’s own dashboard, which usually reports what the plugin intended to output rather than what survived the theme.
Two checks worth running before and after any change:
- Does the number of trails match the number of real paths? One path, one trail. Two real paths, two trails.
- Does the visible trail say the same words as the markup? Read the
<nav>on the page, then read the JSON-LD in the source. They should be identical apart from the separator.
That is the same discipline the SEO basics guide applies to every technical fix: verify what the page actually renders, not what the dashboard reports.
FAQ
Do breadcrumbs still show in Google results?
Yes, on desktop. Google’s documentation states the feature is available on desktop in all regions and languages, and a January 2025 update confirmed that breadcrumbs continue to appear in desktop results but not on mobile.
Why don’t I see breadcrumbs on my phone?
Because Google stopped showing them there in January 2025. The stated reason was truncation on smaller screens, which made the trail less useful to mobile searchers. The visible trail on your site still works on mobile; only the search result display changed.
Is breadcrumb schema a ranking factor?
No. It makes a page eligible for the trail to appear in the visible URL of a desktop result. It does not affect position, and eligibility is never a guarantee that Google will display it.
How many items does a breadcrumb trail need?
At least two ListItem objects inside the BreadcrumbList. A single item is not a trail and cannot be eligible. Home plus one category plus the page is the shortest useful version.
Does the last breadcrumb need a URL?
No. item is not required for the last item, and Google then uses the URL of the containing page. Every other item needs a URL, or the step becomes non-navigable.
Can I have more than one breadcrumb trail on a page?
Yes, when the page genuinely has multiple navigation paths. Google documents this and provides an example with two trails. Two emitters producing the same trail twice is duplication, not a second path.
Should I use a plugin or code?
Either, as long as one thing emits the markup and it matches the visible trail. The failure mode is two things emitting: a theme microdata trail plus a plugin JSON-LD trail. Check the rendered HTML before assuming the plugin’s output is the only output.
Does the trail have to match my URL structure?
No, and it usually should not. Google recommends a typical user path rather than a mirror of the URL. On a WordPress site with flat permalinks, the category or page hierarchy is the better source, because the URL has no hierarchy to read.
Leave a Reply