Pagination vs Infinite Scroll for SEO: What Googlebot Actually Indexes in 2026
Infinite scroll looks modern until you check Search Console and realise half your listings are invisible. Here's how pagination, infinite scroll, and load-more actually behave for Googlebot in 2026.

Every few months a client ships a redesign, swaps paginated category pages for infinite scroll, and three weeks later asks why their long-tail traffic fell off a cliff. The honest answer is that infinite scroll is a UX decision that quietly becomes an indexing decision, and most teams never audit what Googlebot actually sees after the change.
This is a breakdown of how the three dominant patterns — classic pagination, infinite scroll, and load-more — behave for crawlers in 2026, where each one breaks, and the hybrid approach we keep landing on for programmatic sites with large inventories.
Why this still matters in 2026
Google has been rendering JavaScript at scale for years, and the common assumption is that infinite scroll "just works" now because Googlebot executes JS. That assumption is half right and completely dangerous.
Googlebot renders pages, but it does not scroll. It loads a URL, waits for the DOM to settle, and takes a snapshot. If your next batch of items only appears when a user (or an IntersectionObserver tied to viewport position) triggers a fetch, those items are not in the rendered HTML the indexer sees. They might be discovered later through other links, or they might not be discovered at all.
For a brochure site with 40 blog posts, this is a rounding error. For a programmatic site with 200,000 listings organised into category pages, it is the entire ballgame.
The three patterns, honestly compared
Classic pagination
Numbered pages linked via <a href> tags. Page 1 links to pages 2, 3, 4, and so on. Each page has a canonical URL and a stable set of items.
Crawler behaviour: Googlebot follows the anchor tags, requests each page as a distinct URL, and indexes items on each. Deterministic and boring, which is exactly what you want.
Downsides: UX is dated for product grids, and bounce behaviour on page 2+ is usually poor. You also carry pagination state in the URL, which some marketing teams dislike for sharing.
Infinite scroll
A single URL. As the user approaches the bottom, JavaScript fetches the next batch and appends it to the DOM. No new URL, no anchor tags to additional pages.
Crawler behaviour: Googlebot renders the initial payload and stops. Items beyond the first batch are invisible unless they are also linked from somewhere else on the site. In our audits of e-commerce sites that migrated to pure infinite scroll, we routinely see 60–80% of category inventory drop out of the rendered HTML Google receives.
Downsides: Crawl discovery collapses. You also lose the ability to deep-link to a specific position in the list, which hurts user return visits from SERPs.
Load-more buttons
A single URL with an explicit button. Clicking it fetches and appends the next batch, usually via JS, sometimes with a URL update.
Crawler behaviour: Same as infinite scroll by default. Googlebot does not click buttons. Unless the button is actually an <a href> to a paginated URL that gets intercepted by JS for the enhancement, the extra items are invisible.
What Googlebot actually sees: a quick test you can run today
Before you argue with your design lead, get evidence. The fastest way is to compare the rendered HTML Googlebot receives against what a user sees.
# Fetch as a generic bot (no JS execution)
curl -A "Mozilla/5.0 (compatible; Googlebot/2.1; +http://www.google.com/bot.html)" \
https://example.com/category/widgets > raw.html
# Count product cards in the raw response
grep -c 'class="product-card"' raw.html
Then use the URL Inspection tool in Search Console on the same URL and click "View crawled page" → "Rendered HTML". Count the product cards there too. If the second number is not meaningfully higher than what a user sees after scrolling, your infinite scroll is quietly amputating your index coverage.
For a programmatic site, do this across a stratified sample: top-traffic categories, mid-tail, and long-tail. The pattern usually holds across tiers, but the business impact lives in the mid-tail.
The hybrid pattern we keep landing on
After rebuilding this a few times, the pattern that reliably ships well is progressive enhancement over real pagination. The URL structure is paginated. The default navigation is anchor tags. JavaScript then intercepts and provides the infinite-scroll experience for users with it enabled.
The skeleton looks like this:
<!-- Server renders real pagination -->
<ul class="product-grid" data-page="1">
<!-- 24 products for page 1 -->
</ul>
<nav class="pagination">
<a href="/category/widgets?page=2" rel="next">Next</a>
<a href="/category/widgets?page=2">2</a>
<a href="/category/widgets?page=3">3</a>
<a href="/category/widgets?page=4">4</a>
</nav>
Client-side, you progressively enhance:
const grid = document.querySelector('.product-grid');
const nextLink = document.querySelector('a[rel="next"]');
const sentinel = new IntersectionObserver(async (entries) => {
if (!entries[0].isIntersecting || !nextLink) return;
const res = await fetch(nextLink.href, { headers: { 'X-Partial': '1' } });
const { items, nextUrl } = await res.json();
grid.insertAdjacentHTML('beforeend', items);
history.replaceState(null, '', nextLink.href);
nextLink.href = nextUrl || '';
});
sentinel.observe(document.querySelector('.pagination'));
A few details that matter:
- Server returns full HTML on direct requests. Only when
X-Partialis set does the server return a JSON fragment. This keeps the paginated URLs real pages, fully crawlable and fully linkable. history.replaceStateupdates the URL as the user scrolls. This fixes the "share this page" problem and makes browser back/forward sensible.- The
rel="next"link is the fallback. Googlebot and users with JS disabled get boring, working pagination.
Google deprecated rel="next"/"prev" as a ranking signal years ago, but the anchor tags still function as discovery links, which is the whole point.
Pitfalls we see repeatedly
Canonicalising page 2+ to page 1
This is the single most common self-inflicted wound. Someone decides page 2, 3, 4 are "duplicates" of page 1 and sets <link rel="canonical" href="/category/widgets"> on all of them. Google obliges and drops those pages from the index, along with the items they link to that live nowhere else.
Each paginated URL should be self-canonical. They are not duplicates; they contain different items.
Infinite scroll with no fallback URLs at all
If your category page is a single URL and the only way to reach product 25 is to scroll, Googlebot can still find that product through a sitemap or an internal link elsewhere. But the category page itself loses its ability to pass topical relevance and link equity to those items. On programmatic sites where the category page is a core hub, this quietly flattens the whole architecture.
Treating the sitemap as a safety net
A sitemap gets URLs discovered, not ranked. If your only path to a long-tail product is via sitemap, you have told Google it is an orphan. Orphans get crawled rarely and ranked poorly. The sitemap is a hint, not a substitute for internal links.
Not measuring the right thing
"Our rankings are fine" usually means the head terms are fine. Pull a GSC query report filtered to pages matching your category pattern, group by the URL's position in the pagination (page 1 vs 2+), and look at impressions and clicks over the last 90 days versus the 90 before migration. The damage shows up in the tail.
Where this fits in a broader growth system
Pagination is one of those decisions where frontend, SEO, and content ops all have a stake, and the person making the call is usually the frontend lead with no SEO context. Building the audit into your release process — a simple CI check that counts rendered items on a sampled set of category URLs — catches regressions before they ship. We cover more of this engineering-driven approach to growth on the 72Technologies blog.
Where we'd start
If you are mid-migration or considering one, do three things this week. First, run the curl-plus-GSC comparison on ten representative category URLs and quantify the gap. Second, check your canonicals on paginated pages — fix any that point to page 1. Third, if you are committed to an infinite-scroll UX, implement the progressive enhancement pattern above so the underlying URLs stay real and crawlable. The UX team gets what they want, and your long tail stays indexed.
Want a team like ours?
72Technologies builds production software for the kind of teams who actually read this blog.
Start a projectKeep reading
Query Clustering with Embeddings: Building the Topic Map That Killed Our Cannibalization
Keyword cannibalization on a 12k-page site isn't a content problem — it's a clustering problem. Here's the embeddings pipeline we built to merge, redirect, and consolidate pages that were fighting each other in Google.
Hreflang at Scale: The Sitemap-Driven Approach That Survived 40 Locales
Inline hreflang tags break once you hit a dozen locales. Here's the sitemap-driven setup we use on programmatic sites with 40+ locales, including the validation pipeline that catches drift before Google does.
Content Decay Detection with GSC + GA4: The Refresh Queue That Actually Moves Rankings
Most 'content refresh' programmes are vibes. Here's the data pipeline we use to detect decaying URLs, score them by recoverable traffic, and feed a refresh queue writers actually ship against.
