Breadcrumb Navigation for Ecommerce SEO: UX and Schema

Breadcrumb navigation ecommerce SEO guide: hierarchy vs history trails, products in many categories, mobile layout and BreadcrumbList markup with code to copy.

· BugViso Team

16 min read

Breadcrumb navigation is a trail of links showing where a page sits in an ecommerce catalog, such as Home > Shoes > Running.

For SEO it does three jobs. It gives crawlers an upward link path, passes internal link equity from product pages to category pages, and can earn BreadcrumbList rich results in Google.

The markup itself is covered in the BreadcrumbList JSON-LD implementation guide, and what schema markup is explains the basics. On Shopify, collection-based breadcrumbs often come from within: collection links, which point grids at non-canonical URLs; see Shopify duplicate content for the fix.

Large e-commerce websites frequently host tens of thousands—or even millions—of individual product URLs. In these sprawling environments, traditional top-down navigation menus cannot scale to link directly to every sub-category or product variation.

Without a disciplined breadcrumb architecture, deep product pages become isolated leaves at click depths of 5, 6, or 7, which can slow discovery and weaken their internal links.

Implementing breadcrumbs properly requires moving beyond basic HTML links to coordinate server-rendered DOM elements, clean semantic hierarchy, and Schema.org BreadcrumbList structured data. In this guide, we break down the engineering mechanics, equity flow models, and CMS-specific code patterns for Shopify and WooCommerce.


1. Breadcrumb Navigation for Ecommerce SEO: Three Technical Pillars

Breadcrumb navigation impacts search performance across three distinct operational layers:

  • The 3 Pillars of E-Commerce Breadcrumbs
  • Layer 1: Structural Link Equity (PageRank Flow)
  • Funnels internal link equity upward to category hubs
  • Flattens crawl depth across deep product taxonomies
  • Layer 2: SERP Presentation (BreadcrumbList Rich Snippets)
  • Replaces raw URL strings with readable category trails
  • Can make the result easier to scan, which may help clicks
  • Layer 3: Behavioral Usability (UX & Bounce Rate)
  • Provides 1-click upward recovery for organic visitors
  • Lowers bounce rates on deep search landing pages

Pillar 1: Upward Equity Funnels

In an e-commerce architecture, product pages naturally receive the majority of long-tail search traffic and user bookmarks. However, product pages typically contain very few editorial links back to category pages. By including a structured breadcrumb on every product page:

$$\text{Home} \longrightarrow \text{Category} \longrightarrow \text{Sub-Category} \longrightarrow \text{Product Page}$$

Every product page automatically passes internal PageRank back up to its immediate parent sub-category and primary category hub. Across a catalog of 20,000 products, this creates 20,000 structured internal links reinforcing your most competitive commercial ranking assets.

To understand how equity circulates across these paths, explore our technical breakdown of internal PageRank and link equity flow.

Pillar 2: Google SERP Rich Snippets

When Google encounters valid BreadcrumbList structured data, it transforms the display of your search snippets:

text
// Standard unformatted search result:
https://example.com/products/outdoor/footwear/hiking-boots-waterproof-v2

// Rich breadcrumb search result:
example.com > Outdoor > Footwear > Hiking Boots

This clean semantic path gives searchers immediate context and clarifies catalog depth. Whether that lifts clicks depends on the query and result; see whether rich snippets increase clicks.

Pillar 3: Reducing Bounce Rates on Organic Traffic

Many organic e-commerce visitors land directly on deep product detail pages rather than the homepage. When a shopper finds that a specific shoe is out of stock in their size, a prominent breadcrumb allows them to jump directly to the parent Trail Running Shoes category with a single click, rescuing a bounce that would otherwise exit back to Google.


2. Structural Taxonomy: Hierarchy-Based vs. History-Based Breadcrumbs

E-commerce developers often confuse hierarchy-based breadcrumbs with history-based breadcrumbs:

Breadcrumb AttributeHierarchy-Based (SEO Standard)History-Based / Session-Based
Link Generation RuleFixed canonical catalog taxonomyBrowser session history (window.history.back())
Server-Side RenderedYes (Identical across all users)No (Requires client-side session state)
Search Engine ValueHigh (Permanent crawlable links)Zero (Inaccessible to automated crawlers)
Schema.org CompatibleFully compatible with BreadcrumbListIncompatible (Dynamic, non-canonical)
Handling Facet FiltersAlways maps to root canonical categoryShows arbitrary user filtering path

⚠️ Critical Rule: Never implement history-based "Back to Results" breadcrumbs as your primary SEO breadcrumb strategy. Search engine crawlers do not maintain browser session cookies or stateful navigation history. Breadcrumbs must be hardcoded to your canonical catalog hierarchy.


3. Schema.org BreadcrumbList JSON-LD Implementation

To earn rich snippet presentation in Google Search, every breadcrumb trail must be accompanied by Schema.org BreadcrumbList markup rendered in JSON-LD format.

Production JSON-LD Blueprint:

html
<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": "Outdoor Gear",
      "item": "https://example.com/outdoor-gear"
    },
    {
      "@type": "ListItem",
      "position": 3,
      "name": "Footwear",
      "item": "https://example.com/outdoor-gear/footwear"
    },
    {
      "@type": "ListItem",
      "position": 4,
      "name": "Waterproof Trail Hiking Boots",
      "item": "https://example.com/outdoor-gear/footwear/waterproof-hiking-boots"
    }
  ]
}
</script>

Critical Implementation Rules:

  1. Absolute URLs: Always use absolute HTTPS URLs in the item field. Relative paths (/outdoor-gear) frequently cause schema parsing errors in Google Search Console.
  2. Consecutive Numeric Positions: The position property must start at integer 1 and increment by 1 without gaps.
  3. The Leaf Element: The final item represents the current page. While some schemas omit the item URL on the leaf node to prevent self-linking, Google Search Central Breadcrumb documentation and the Schema.org BreadcrumbList specification accept both approaches provided the name and position are declared.

For a deeper dive into schema validation and edge cases, see our complete guide to BreadcrumbList schema JSON-LD implementation.


4. Semantic HTML Architecture for E-Commerce Breadcrumbs

In addition to JSON-LD structured data, your visible HTML must use semantic markup and accessibility attributes adhering to the W3C WAI ARIA Breadcrumbs Pattern:

html
<nav aria-label="Breadcrumbs" class="ecommerce-breadcrumbs">
  <ol class="breadcrumb-list">
    <li class="breadcrumb-item">
      <a href="/" class="breadcrumb-link">Home</a>
      <span class="breadcrumb-separator" aria-hidden="true">/</span>
    </li>
    <li class="breadcrumb-item">
      <a href="/outdoor-gear" class="breadcrumb-link">Outdoor Gear</a>
      <span class="breadcrumb-separator" aria-hidden="true">/</span>
    </li>
    <li class="breadcrumb-item">
      <a href="/outdoor-gear/footwear" class="breadcrumb-link">Footwear</a>
      <span class="breadcrumb-separator" aria-hidden="true">/</span>
    </li>
    <li class="breadcrumb-item breadcrumb-current" aria-current="page">
      <span>Waterproof Trail Hiking Boots</span>
    </li>
  </ol>
</nav>

Accessibility Standards:

  • Wrap the trail in <nav aria-label="Breadcrumbs"> so screen readers announce the landmark accurately.
  • Use an ordered list (<ol>) to represent the sequence of hierarchy.
  • Mark separators (slashes, chevrons) with aria-hidden="true" so assistive technologies do not pronounce them repeatedly.
  • Mark the final active node with aria-current="page".

5. Platform Implementation: Shopify Liquid Engine

Shopify stores frequently suffer from internal link fragmentation when products belong to multiple collections.

By default, Shopify themes often generate collection-nested product URLs like /collections/winter-sale/products/boot alongside /products/boot. This splits equity and generates duplicate URLs.

Below is an optimized Shopify Liquid snippet (snippets/seo-breadcrumbs.liquid) that enforces canonical hierarchy paths and injects BreadcrumbList JSON-LD automatically:

liquid
{% comment %}
  snippets/seo-breadcrumbs.liquid
  Production-grade e-commerce breadcrumb generator with JSON-LD.
{% endcomment %}

{% unless template == 'index' or template == 'cart' or template == '404' %}
<nav aria-label="Breadcrumbs" class="breadcrumbs">
  <ol class="breadcrumb-list">
    <li class="breadcrumb-item">
      <a href="{{ routes.root_url }}">Home</a>
      <span aria-hidden="true">/</span>
    </li>

    {% if template contains 'product' %}
      {% if collection and collection.url %}
        <li class="breadcrumb-item">
          <a href="{{ collection.url }}">{{ collection.title }}</a>
          <span aria-hidden="true">/</span>
        </li>
      {% elsif product.collections.size > 0 %}
        {% assign primary_collection = product.collections.first %}
        <li class="breadcrumb-item">
          <a href="{{ primary_collection.url }}">{{ primary_collection.title }}</a>
          <span aria-hidden="true">/</span>
        </li>
      {% endif %}
      <li class="breadcrumb-item" aria-current="page">
        <span>{{ product.title }}</span>
      </li>

    {% elsif template contains 'collection' and collection.handle %}
      <li class="breadcrumb-item" aria-current="page">
        <span>{{ collection.title }}</span>
      </li>

    {% elsif template contains 'page' %}
      <li class="breadcrumb-item" aria-current="page">
        <span>{{ page.title }}</span>
      </li>

    {% elsif template contains 'article' %}
      <li class="breadcrumb-item">
        <a href="{{ blog.url }}">{{ blog.title }}</a>
        <span aria-hidden="true">/</span>
      </li>
      <li class="breadcrumb-item" aria-current="page">
        <span>{{ article.title }}</span>
      </li>
    {% endif %}
  </ol>
</nav>

{% comment %} Output Matching JSON-LD Schema {% endcomment %}
<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "BreadcrumbList",
  "itemListElement": [
    {
      "@type": "ListItem",
      "position": 1,
      "name": "Home",
      "item": "{{ shop.url }}"
    }
    {% if template contains 'product' %}
      {% assign target_coll = collection | default: product.collections.first %}
      {% if target_coll %}
      ,{
        "@type": "ListItem",
        "position": 2,
        "name": {{ target_coll.title | json }},
        "item": "{{ shop.url }}{{ target_coll.url }}"
      },
      {
        "@type": "ListItem",
        "position": 3,
        "name": {{ product.title | json }},
        "item": "{{ shop.url }}{{ product.url }}"
      }
      {% else %}
      ,{
        "@type": "ListItem",
        "position": 2,
        "name": {{ product.title | json }},
        "item": "{{ shop.url }}{{ product.url }}"
      }
      {% endif %}
    {% elsif template contains 'collection' %}
      ,{
        "@type": "ListItem",
        "position": 2,
        "name": {{ collection.title | json }},
        "item": "{{ shop.url }}{{ collection.url }}"
      }
    {% endif %}
  ]
}
</script>
{% endunless %}

6. Platform Implementation: WooCommerce & WordPress Hooks

In WooCommerce, products often exist under nested category taxonomies (e.g., Apparel > Men > Jackets). Below is a clean PHP implementation utilizing the woocommerce_before_main_content hook to render canonical hierarchy breadcrumbs:

php
<?php
/**
 * Plugin / Theme Functions: Custom SEO Breadcrumbs for WooCommerce
 */

function bugviso_custom_wc_breadcrumbs() {
    if (is_front_page() || is_cart() || is_checkout()) {
        return;
    }

    global $post;
    $crumbs = [];
    $crumbs[] = ['Home', home_url('/')];

    if (is_product()) {
        $terms = wc_get_product_terms($post->ID, 'product_cat', ['orderby' => 'parent', 'order' => 'DESC']);
        if (!empty($terms)) {
            $main_term = $terms[0];
            $ancestors = get_ancestors($main_term->term_id, 'product_cat');
            $ancestors = array_reverse($ancestors);

            foreach ($ancestors as $ancestor_id) {
                $ancestor = get_term($ancestor_id, 'product_cat');
                $crumbs[] = [$ancestor->name, get_term_link($ancestor)];
            }
            $crumbs[] = [$main_term->name, get_term_link($main_term)];
        }
        $crumbs[] = [get_the_title(), ''];
    } elseif (is_product_category()) {
        $current_term = get_queried_object();
        $ancestors = array_reverse(get_ancestors($current_term->term_id, 'product_cat'));

        foreach ($ancestors as $ancestor_id) {
            $ancestor = get_term($ancestor_id, 'product_cat');
            $crumbs[] = [$ancestor->name, get_term_link($ancestor)];
        }
        $crumbs[] = [$current_term->name, ''];
    }

    // Render Semantic HTML
    echo '<nav aria-label="Breadcrumbs" class="wc-seo-breadcrumbs"><ol class="breadcrumb-trail">';
    foreach ($crumbs as $index => $crumb) {
        $is_last = ($index === count($crumbs) - 1);
        if ($is_last) {
            echo '<li class="crumb-item active" aria-current="page">' . esc_html($crumb[0]) . '</li>';
        } else {
            echo '<li class="crumb-item"><a href="' . esc_url($crumb[1]) . '">' . esc_html($crumb[0]) . '</a> <span aria-hidden="true">/</span></li>';
        }
    }
    echo '</ol></nav>';

    // Render JSON-LD
    $schema_items = [];
    foreach ($crumbs as $index => $crumb) {
        $url = !empty($crumb[1]) ? $crumb[1] : get_permalink($post->ID);
        $schema_items[] = [
            '@type' => 'ListItem',
            'position' => $index + 1,
            'name' => $crumb[0],
            'item' => esc_url($url)
        ];
    }

    $json_ld = [
        '@context' => 'https://schema.org',
        '@type' => 'BreadcrumbList',
        'itemListElement' => $schema_items
    ];

    echo '<script type="application/ld+json">' . json_encode($json_ld, JSON_UNESCAPED_SLASHES | JSON_PRETTY_PRINT) . '</script>';
}

add_action('woocommerce_before_main_content', 'bugviso_custom_wc_breadcrumbs', 8);

7. Headless E-Commerce: Next.js App Router Server Component

For enterprise brands running headless storefronts (Shopify Storefront API, BigCommerce, or Medusa with Next.js 15), generate breadcrumbs server-side within the App Router. Search crawlers then receive complete HTML and structured data without relying on client-side JavaScript.

Below is an optimized React Server Component (components/breadcrumbs/BreadcrumbNav.tsx) that recursively generates canonical path links and injects JSON-LD into the document <head>:

typescript
// components/breadcrumbs/BreadcrumbNav.tsx
import Link from 'next/link';

export interface BreadcrumbSegment {
  name: string;
  url: string;
}

interface BreadcrumbNavProps {
  segments: BreadcrumbSegment[];
}

export function BreadcrumbNav({ segments }: BreadcrumbNavProps) {
  // Construct Schema.org BreadcrumbList object
  const schemaData = {
    '@context': 'https://schema.org',
    '@type': 'BreadcrumbList',
    itemListElement: segments.map((seg, idx) => ({
      '@type': 'ListItem',
      position: idx + 1,
      name: seg.name,
      item: seg.url
    }))
  };

  return (
    <>
      {/* 1. Server-Rendered JSON-LD for Search Engine Robots */}
      <script
        type="application/ld+json"
        dangerouslySetInnerHTML={{ __html: JSON.stringify(schemaData) }}
      />

      {/* 2. Accessible Semantic HTML Navigation Bar */}
      <nav aria-label="Breadcrumb Navigation" className="flex items-center text-xs text-slate-500 py-3">
        <ol className="flex items-center space-x-2">
          {segments.map((seg, idx) => {
            const isLast = idx === segments.length - 1;

            return (
              <li key={seg.url} className="flex items-center">
                {idx > 0 && (
                  <span className="mx-2 text-slate-400 select-none" aria-hidden="true">
                    /
                  </span>
                )}
                {isLast ? (
                  <span
                    aria-current="page"
                    className="font-semibold text-slate-900 truncate max-w-[200px] sm:max-w-none"
                  >
                    {seg.name}
                  </span>
                ) : (
                  <Link
                    href={seg.url}
                    className="hover:text-emerald-600 transition-colors font-medium hover:underline"
                  >
                    {seg.name}
                  </Link>
                )}
              </li>
            );
          })}
        </ol>
      </nav>
    </>
  );
}

Server Page Integration (app/products/[slug]/page.tsx):

typescript
// app/products/[slug]/page.tsx
import { BreadcrumbNav } from '@/components/breadcrumbs/BreadcrumbNav';
import { fetchProductBySlug } from '@/lib/api';

export default async function ProductPage({ params }: { params: { slug: string } }) {
  const product = await fetchProductBySlug(params.slug);
  const siteUrl = process.env.NEXT_PUBLIC_SITE_URL || 'https://example.com';

  const breadcrumbs = [
    { name: 'Home', url: siteUrl },
    { name: product.primaryCategory.name, url: `${siteUrl}/${product.primaryCategory.slug}` },
    { name: product.subCategory.name, url: `${siteUrl}/${product.primaryCategory.slug}/${product.subCategory.slug}` },
    { name: product.title, url: `${siteUrl}/products/${product.slug}` }
  ];

  return (
    <main className="max-w-7xl mx-auto px-4">
      <BreadcrumbNav segments={breadcrumbs} />
      <article className="mt-6">
        <h1 className="text-3xl font-extrabold">{product.title}</h1>
        {/* Product Details, Media Gallery, and Add-to-Cart Modules */}
      </article>
    </main>
  );
}

8. Multi-Category Taxonomy: The Single-Path Canonical Rule

One of the most complex architectural dilemmas in e-commerce SEO occurs when a single item belongs to multiple categories simultaneously. For example, a "Women's Waterproof Gore-Tex Trail Shoe" belongs to:

  1. /footwear/running/trail
  2. /womens/outdoor/shoes
  3. /brands/gore-tex/footwear
  4. /sale/clearance-shoes
Diagram
┌─────────────────────────────────────────────────────────────┐
│             Multi-Category Taxonomy Conflict                │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│              ┌─────────────────────────────┐                │
│              │   Product: Gore-Tex Boot    │                │
│              └──────────────┬──────────────┘                │
│                             │                               │
│      ┌──────────────────────┼──────────────────────┐        │
│      ▼                      ▼                      ▼        │
│ Category 1            Category 2             Category 3     │
│ /footwear/trail       /womens/outdoor        /brands/goretex│
│                             │                               │
│                             ▼ Decision Rule                 │
│              Enforce 1 Primary Canonical Path               │
│              (Declared in PIM or ERP Schema)                │
│                             │                               │
│                             ▼ Output Breadcrumb             │
│        Home > Footwear > Trail Running > Gore-Tex Boot      │
│                                                             │
└─────────────────────────────────────────────────────────────┘

The 4 Rules for Multi-Category Breadcrumbs:

  1. Never Generate Dynamic Path Traversal in Canonical Breadcrumbs: Do not adjust the breadcrumb trail based on the specific category page from which the visitor arrived. Dynamic trails create duplicate canonical schemas for the same product.
  2. Designate a "Primary Category" in your Product Information Manager (PIM): Every product must possess an immutable primary_category_id. The breadcrumb trail must always reflect this single primary hierarchy, regardless of user journey.
  3. Strip Facet & Query Parameters: Breadcrumbs should never point to filtered parameter URLs (e.g., /footwear/trail?size=11&color=black). The breadcrumb must always link to the clean, indexable category root (/footwear/trail).
  4. Coordinate Canonical Tags: Ensure the <link rel="canonical"> URL and the final leaf node of the breadcrumb match identically to avoid conflicting search signals.

9. Automated Testing: Validating Breadcrumbs in CI/CD Pipelines

To prevent theme updates or code refactors from breaking breadcrumb schemas, add automated testing using Vitest or Jest. Below is a unit test validating that the generated schema contains non-empty names, valid HTTPS URLs, and strictly incremental positions:

typescript
// __tests__/breadcrumbSchema.test.ts
import { describe, it, expect } from 'vitest';

function validateBreadcrumbList(jsonLd: any) {
  expect(jsonLd['@context']).toBe('https://schema.org');
  expect(jsonLd['@type']).toBe('BreadcrumbList');
  expect(Array.isArray(jsonLd.itemListElement)).toBe(true);

  const items = jsonLd.itemListElement;
  expect(items.length).toBeGreaterThanOrEqual(2);

  items.forEach((item: any, idx: number) => {
    expect(item['@type']).toBe('ListItem');
    // Position must be 1-indexed and contiguous
    expect(item.position).toBe(idx + 1);
    expect(typeof item.name).toBe('string');
    expect(item.name.trim().length).toBeGreaterThan(0);
    // URL must be absolute HTTPS
    expect(item.item).toMatch(/^https:\/\/[a-z0-9.-]+\.[a-z]{2,}.*$/i);
  });
}

describe('E-Commerce BreadcrumbList JSON-LD Validator', () => {
  it('validates a correct multi-tier product breadcrumb structure', () => {
    const mockSchema = {
      '@context': 'https://schema.org',
      '@type': 'BreadcrumbList',
      itemListElement: [
        { '@type': 'ListItem', position: 1, name: 'Home', item: 'https://example.com' },
        { '@type': 'ListItem', position: 2, name: 'Footwear', item: 'https://example.com/footwear' },
        { '@type': 'ListItem', position: 3, name: 'Trail Running', item: 'https://example.com/footwear/trail' },
        { '@type': 'ListItem', position: 4, name: 'Waterproof Gore-Tex Shoe', item: 'https://example.com/products/gore-tex-shoe' }
      ]
    };

    validateBreadcrumbList(mockSchema);
  });
});

10. How BugViso Audits Breadcrumbs & Schema Integrity

Maintaining structured data and internal link hygiene across thousands of dynamically updated products needs regular re-checking. A single theme patch or app update can inadvertently strip JSON-LD tags or break reciprocal collection links.

BugViso checks breadcrumb architectures during a scan:

  1. Schema.org Syntax & Completeness Validation: Validates BreadcrumbList tags across every crawled page, flagging missing required properties and malformed JSON-LD.
  2. Internal Equity Flow Mapping: Traces upward internal links from product leaves to category hubs, ensuring that PageRank passes cleanly without dead ends.
  3. Click Depth Auditing: Reports click depth for every crawled page, so you can see which products sit deep in the catalog.
  4. Mobile & Accessibility Compliance: Checks breadcrumb elements using self-hosted axe-core to verify touch target sizes, contrast ratios, and screen-reader landmark compliance.

To verify your complete site structure, review our 18-point internal linking audit checklist.

You can see every rule BugViso applies in its technical SEO audit tool.


11. Frequently Asked Questions

Are breadcrumbs good for ecommerce SEO?

Yes, breadcrumbs help ecommerce SEO in three ways. They give crawlers an upward link path from deep product pages, they pass internal link equity from every product back to its category pages, and valid BreadcrumbList markup can replace the raw URL in Google results with a readable category trail. They also give shoppers a one-click route back to the parent category.

Should ecommerce breadcrumbs be based on hierarchy or browsing history?

Use hierarchy-based breadcrumbs that follow your fixed catalog taxonomy. History-based "Back to Results" trails depend on the visitor's session, and search engine crawlers keep no session state, so those links have no SEO value and can't be marked up with BreadcrumbList. A hierarchy trail renders the same for every user and always links to canonical category URLs.

Which breadcrumb should a product in several categories show?

Show one primary category path for every product, whichever category the visitor came from. Store an unchanging primary category for each product in your catalog system and build the breadcrumb from it. Changing the trail by entry path creates conflicting structured data for the same product, so keep a single path and make its last item match the page's canonical URL.

Do breadcrumbs need BreadcrumbList schema markup?

Yes, a visible breadcrumb needs matching Schema.org BreadcrumbList markup, usually in JSON-LD, to be eligible for breadcrumb display in Google results. Use absolute HTTPS URLs in each item, start position at 1 and increase it by 1 without gaps, and give every entry a name. Validate the output in tests so a theme update can't silently break it.

No, breadcrumbs should link to the clean, indexable category URL, never to a filtered version with size, colour or other parameters. A link like /footwear/trail?size=11 points crawlers at a non-canonical page and splits signals. Strip facet and query parameters so every breadcrumb points to the category root, such as /footwear/trail.


12. Summary & Key Takeaway

Breadcrumb navigation is not merely a design convenience; it is part of how a catalog's internal links are structured. By pairing canonical hierarchy links with valid BreadcrumbList JSON-LD, online retailers give crawlers and shoppers a clear path up to their category pages.

Validate your breadcrumb markup and audit your entire e-commerce internal link graph by launching a technical scan with BugViso.

Written by

· BugViso Team

Kazi writes BugViso’s guides on website audits, Core Web Vitals, technical SEO, accessibility and AI search. The data in them comes from audits BugViso runs in a real Chromium browser, including our 219-site study of website health.

Found this useful? Share it.

Summarise with AI

Open this guide in your assistant.

Follow BugViso

New guides and audit data as we publish them.

AI visibility tracker

Is your brand in AI answers?

See how often AI assistants mention you, cite your site and rank you against your competitors.

  • ChatGPT
  • Gemini
  • Perplexity
  • Claude
  • AI Overviews
See how it works

See where your site stands

Run a free BugViso audit for SEO, speed, accessibility and AI search readiness — with fixes you can ship today.