How to Fix Infinite Scroll Crawlability with Paginated URLs

Infinite scroll loads more items with JavaScript when a visitor nears the bottom of the page. Crawlers do not scroll, so anything after the first batch is often never discovered. By the end of this guide, every batch will have its own server-rendered URL, linked with real anchor tags, with infinite scroll layered on top for human visitors.

By Updated ⏱ 2-4 hours🎯 Intermediate● Medium impactTechnical
Illustration: Infinite scroll crawlability fix guide
TECHNICAL · FIX GUIDE Infinite scroll crawlability IMPACTEFFORT TIME2-4 hours LEVELIntermediate

Why it matters

Googlebot renders pages at a fixed viewport and does not trigger scroll events or click 'Load more' buttons that lack an href. Bing and most AI crawlers, including GPTBot, ClaudeBot and PerplexityBot, often do not execute JavaScript at all. On a category or blog index with 400 items and a 24-item first batch, roughly 94% of item links can be invisible.

Those products or articles then rely on sitemaps alone, get little internal link equity, are indexed slowly, and are rarely cited in AI answers. Visitors also lose their position when they press Back and cannot share a link to a specific page of results.

✕Beforehttps://example.com/shoes returns 24products in its HTML, and products25-400 load only through a✓Afterhttps://example.com/shoes?page=2 to?page=17 each return their own 24products in server-rendered HTML,

What you need

Access to the theme or template code for list pages (category, blog index, search results)
A server-side way to return a specific page of results, such as ?page=2 or /page/2/
Google Search Console access for the URL Inspection tool
Chrome DevTools or curl for testing

Step-by-step fix

1

Measure what crawlers can see today

com/shoes | grep -c 'class="product-card"'` to count the items in the raw HTML. Then open DevTools > Network > Fetch/XHR and scroll. Note the request that loads the next batch and whether the address bar changes.

If the raw HTML count is only the first batch and the URL never changes, the remaining items cannot be crawled through this page.

text
curl -s -A "Googlebot" https://example.com/shoes | grep -o 'href="[^"]*page=[0-9]*' | sort -u
Pro tip: Repeat the check on your three to five largest list templates, such as category, tag, blog index and brand pages. They often use different scroll code.
2

Create a server-rendered URL for each batch

Make your server accept a page parameter and return a complete HTML document containing only that slice of items. page=2 or /page/2/. Do not use offsets that change when you add items, and never use fragments like #page2`, because crawlers ignore everything after #.

Return a 404 for page numbers past the last page so crawlers do not hit endless empty pages.

text
GET /shoes?page=1  -> items 1-24   (200)
GET /shoes?page=2  -> items 25-48  (200)
GET /shoes?page=17 -> items 385-400 (200)
GET /shoes?page=18 -> 404 Not Found
Pro tip: Keep the sort order deterministic. Add a tiebreaker such as product ID so an item never appears on two pages or on none.
3

Add real pagination links in the HTML

On every page, output plain anchor links to the previous and next pages, and ideally to numbered pages. Googlebot only follows <a> elements with an href. It does not follow buttons, onclick handlers or data- attributes.

These links are your fallback. JavaScript can hide or replace them later, but they must be in the server response.

html
<nav class="pagination" aria-label="Pagination">
  <a href="/shoes?page=1" rel="prev">Previous</a>
  <a href="/shoes?page=1">1</a>
  <a href="/shoes?page=2" aria-current="page">2</a>
  <a href="/shoes?page=3">3</a>
  <a href="/shoes?page=3" rel="next" class="js-next">Next</a>
</nav>
Pro tip: Google no longer uses rel="prev"/"next" as an indexing signal. They are harmless, but the href links themselves are what matter.
4

Layer infinite scroll on top of those URLs

replaceState`. Crawlers and no-JS visitors get pagination. Visitors with JavaScript get seamless scrolling.

Bookmarks, shares and the Back button also land on a real, loadable page.

javascript
const list = document.querySelector('.product-grid');
const sentinel = document.createElement('div');
list.after(sentinel);
let nextLink = document.querySelector('a.js-next');
const io = new IntersectionObserver(async ([entry]) => {
  if (!entry.isIntersecting || !nextLink) return;
  const url = nextLink.href; nextLink = null;
  const html = await (await fetch(url)).text();
  const doc = new DOMParser().parseFromString(html, 'text/html');
  doc.querySelectorAll('.product-grid > .product-card').forEach(el => list.append(el));
  history.replaceState({}, '', url);
  nextLink = doc.querySelector('a.js-next');
  document.querySelector('.pagination').replaceWith(doc.querySelector('.pagination'));
  if (!nextLink) io.disconnect();
}, { rootMargin: '600px' });
io.observe(sentinel);
Pro tip: Use replaceState rather than pushState so the Back button leaves the list instead of stepping through 15 history entries.
5

Set canonicals, titles and robots rules per page

Each paginated URL needs a self-referencing canonical. Do not point page 2 and beyond to page 1, because that tells Google to ignore the items on those pages. Give each page a distinct title, such as 'Shoes – Page 2 | Example Co'.

txt does not block the page parameter.

html
<!-- on https://example.com/shoes?page=2 -->
<title>Shoes – Page 2 | Example Co</title>
<link rel="canonical" href="https://example.com/shoes?page=2">
<meta name="robots" content="index, follow">
Pro tip: Check robots.txt for lines like `Disallow: /*?page=` or `Disallow: /*?*`. These are common leftovers that silently block all pagination.
6

Verify with rendered and raw HTML

page=3, click Test live URL, then View tested page > HTML. Confirm that page 3's items and the Next link are present. Repeat the curl test from step 1 with JavaScript off: each page URL should return its own items.

Finally, scroll the live page in a browser and confirm the address bar changes and that reloading keeps your position.

text
for p in 1 2 3 18; do printf "page $p: "; curl -s -o /dev/null -w "%{http_code}\n" "https://example.com/shoes?page=$p"; done
Pro tip: After a few weeks, check Search Console > Pages and filter for item URLs. 'Discovered – currently not indexed' counts for deep products should start to fall.

Platform-specific notes

WordPress

Core already serves /page/2/ archive URLs. Problems usually come from theme or plugin 'Load more' features. Jetpack's Infinite Scroll (Jetpack > Settings > Writing > Theme enhancements) keeps /page/N/ URLs working, but check that your theme still outputs the_posts_pagination() links in the HTML. In Yoast or Rank Math, confirm that paginated archives are not set to noindex.

Shopify

Collection templates paginate with {% paginate collection.products by 24 %}...{{ paginate | default_pagination }}{% endpaginate %}, which produces ?page=2 links. Many infinite-scroll apps and themes remove that snippet. Keep it in the markup (hidden visually if needed) and have the app fetch the paginate.next.url value. Shopify sets the canonical automatically to include ?page=N.

Webflow

In the Designer, select the Collection List, open Settings and enable Pagination with a set number of items per page. Webflow generates URLs like ?a1b2c3d4_page=2 with real anchor links. If you add a Finsweet Attributes 'Load more' or infinite mode, it reads those native links, so leave pagination enabled rather than raising the item limit.

Next.js

In the App Router, read searchParams.page in the server component and fetch that slice, so /shoes?page=2 is server-rendered. Render <Link href={`/shoes?page=${n+1}`}> for Next. For the client-side scroll, fetch the same data in a client component and call window.history.replaceState. Do not use router.push with { scroll: false }, which triggers navigation. Avoid client-only useSWRInfinite lists with no URL-backed fallback.

React / Vue SPAs on static hosting

If every route serves the same empty index.html, crawlers that don't execute JavaScript see no items at all. Add server-side rendering or prerendering (for example Nuxt, Astro, or a prerender step at build time) for list routes before the pagination fix can work.

Check that it worked

✅ How to verify

  • Search Console URL Inspection > Test live URL on ?page=2 and ?page=3 shows those pages' items and a Next link in the rendered HTML.
  • curl with JavaScript disabled returns different items for each page number, and a 404 past the last page.
  • Each paginated URL has a self-referencing canonical and no noindex. Check with the browser's View Source or a crawler such as Screaming Frog with JavaScript rendering off.
  • Scrolling the live page updates the address bar, and reloading or sharing that URL opens the same batch.

⚠️ Common mistakes

  • Canonicalizing every paginated page to page 1, which tells Google to drop the deeper items.
  • Using a 'Load more' <button> or a #page=2 fragment instead of an <a href> to a real URL.
  • Letting the page parameter return an empty 200 page forever (?page=9999), which creates infinite crawl space.
  • Fetching JSON from an API for scrolling while the paginated HTML URLs show different or out-of-sync items.

Is this still an issue on your site? Run a free audit — ZORO checks this and 294 other SEO, AI-visibility, accessibility and security signals, with fixes for your platform.

Check my site free

FAQ

Does Google scroll pages when it renders JavaScript?

No. Googlebot renders with a tall viewport but does not fire scroll events or click buttons. Content that loads only on scroll or click is usually not seen. Google's guidance is to give each chunk its own URL and link to it.

Should paginated pages be noindex?

Generally no. Pages 2 and beyond are how crawlers reach deep items. Keep them indexable with self-referencing canonicals. They rarely rank on their own, but they pass discovery and link signals to the items.

Is a 'View all' page better than pagination?

It can work for lists of up to a few hundred lightweight items that load quickly. For large catalogs, a view-all page is slow and heavy, so paginated URLs with infinite scroll on top are the safer pattern.

Do I still need rel="next" and rel="prev"?

Google stopped using them as an indexing signal in 2019. Some other search engines and accessibility tools may still read them, so leaving them in place is fine. The required part is the crawlable <a href> links.