SEO Pagination Best Practices | How To Handle It Correctly

Pagination.

For many site owners, that word alone is enough to make their eye twitch. It’s that necessary, messy, and deeply confusing part of technical SEO. It feels impossible to get right.

I get it. I really do.

I’ve been in the trenches of SEO for over a decade. I can tell you firsthand that pagination is one of the top things clients get wrong. More than that, it’s one of the top things I got wrong when I was starting out. I still remember the cold sweat. That feeling when I realized I had accidentally told Google to ignore 80% of a client’s products. All because of the wrong canonical strategy.

It was a nightmare.

But it was a lesson I only needed to learn once.

Here’s the truth: handling paginated content is a fundamental part of a healthy site architecture. Get it wrong, and you risk wasting Google’s crawl budget, creating massive duplicate content issues, and hiding your most valuable pages.

Get it right, and you create a clean, efficient pathway. A highway for search engines to find, crawl, and index all your deep content.

This guide is my definitive playbook. It’s built from years of trial, error, and client successes. We’re going to demystify this topic for good. These are the SEO pagination best practices that work.

More in Technical SEO Category

How To Improve Page Speed With Caching

Step-By-Step Technical SEO Audit Guide

Key Takeaways

Before we dive deep, here are the absolute non-negotiables. If you do nothing else, do this:

• rel=prev/next is Dead: Google confirmed in 2019 they haven’t used this markup for years. Stop using it. It does nothing.
• Use Self-Referencing Canonical Tags: This is the modern standard. Page 2 canonicals to Page 2. Page 3 canonicals to Page 3. This tells Google each page is unique.
• Do NOT noindex Paginated Pages: Never, ever use a noindex tag on your paginated series (e.g., page 2, 3, 4…). This is a critical error. It prevents Google from following the links on those pages, effectively cutting off your deep content from link equity and discovery.
• Do NOT Canonicalize to Page 1: This is the most common and damaging mistake. Canonicalizing page 2 back to page 1 tells Google, “Page 2 is a duplicate of Page 1. Ignore it.” Google will then stop crawling the links on page 2. Your products or posts on that page will become invisible.
• Ensure Clean, Crawlable <a> Links: Your pagination controls (the “1, 2, 3… Next” links) must be standard <a href="..."> HTML links. If your pagination relies on JavaScript without a proper href attribute, Googlebot may not be able to find and crawl the subsequent pages.

So, What’s the Big Deal with Pagination Anyway?

Let’s start at square one. What are we even talking about?

Pagination is just splitting a large set of content into smaller, more manageable pages. You see it everywhere:

• E-commerce: Category pages showing 20 products per page.
• Blogs: The main blog archive, showing 10 posts per page.
• Forums: A thread with hundreds of replies split into multiple pages.

It’s a user experience (UX) pattern. That’s all. No one wants to load a single page with 5,000 products. It would crash their browser. So, we break it into pages.

The “big deal” for SEO is that this simple UX solution creates a complex problem for search engines. It generates a series of pages (page-1, page-2, page-3…) that are all very similar. They all share the same H1, the same introductory text, the same header, footer, and sidebar. The only thing that changes is the small block of content in the middle.

This similarity looks suspiciously like duplicate content to a search engine.

Plus, it forces Google to make a decision. “Which of these pages is the ‘real’ one? Should I index all of them? Which one should rank?”

This is where your job begins. You need to give Google crystal-clear signals about how to handle this series.

Is Google Smart Enough to Just… Figure It Out?

You’d think so, right?

And to be fair, Google is incredibly smart. But it’s not a mind reader. It doesn’t have unlimited resources.

The main issue is crawl budget. Every site gets an “allowance” of how many pages Googlebot will crawl on any given day. If your site has 50,000 products and 1,000 blog posts, you have a lot of pages. If Google wastes its time trying to understand a messy, confusing, and seemingly infinite series of paginated pages, it might give up. It might leave before it ever finds your brand-new product page or your brilliant new blog post.

Your goal isn’t just to get your pages indexed. It’s to get them crawled efficiently. You want the link equity (or “PageRank”) from your powerful homepage and category pages to flow correctly to your individual product and post pages.

Bad pagination dams up that flow. Good pagination builds a superhighway.

Did Google’s Past Advice Make Things More Confusing?

Oh, absolutely.

This is where I see so much old, outdated advice still floating around.

For the better part of a decade, the official “best practice” was using rel=prev/next link attributes. You’d put a tag in the <head> of page 2 that pointed to page 1 as the “prev” and page 3 as the “next.” The idea was to group these pages into a logical series for Google.

I spent years meticulously implementing rel=prev/next tags for clients. We all did. We built it into our site audits and our development checklists.

Then, in 2019, a Google spokesperson casually mentioned on Twitter that they hadn’t actually used that markup in years.

The entire SEO community collectively spat out its coffee.

All that work, all that advice, was based on a signal Google was completely ignoring. It taught me a valuable lesson: build your SEO strategy on a solid foundation of logic (like crawlability and indexation). Don’t just rely on one specific piece of markup that a search engine can choose to ignore at any time.

This change is what cleared the way for the modern, simpler, and far more logical approach we use today.

Am I Accidentally Sabotaging My Site with Bad Pagination?

This is the question I get asked most. Before I show you the right way, let’s identify the wrong ways. I audit sites every single week, and I see these “Big 3” pagination sins constantly. They are the most common reasons a site’s category or blog pages fail to perform.

Check your site for these right now.

Are You Falling Into the “noindex” Trap?

This one sounds logical, which makes it so dangerous.

Someone sees a bunch of thin, similar-looking paginated pages and thinks, “I don’t want Google to index page 2, page 3, etc. That’s duplicate content! I’ll just add a noindex tag to all pages after page 1.”

Here’s the problem. The noindex tag tells Google two things:

1. Do not show this page in the search results.
2. After a while, stop crawling this page and don’t pass any link equity through its links.

Google used to treat noindex, follow as a clear directive (“don’t index this page, but do follow the links on it”). Now? They treat it as a temporary signal that eventually just becomes noindex, nofollow.

When you put a noindex tag on page 2, you are effectively vaporizing all the link equity. All the “SEO juice” that should be flowing to page 2 and from page 2 down to the products or posts listed on it… it’s gone.

You’ve created a dead end.

Mistake #2: The Canonical Catastrophe

This is, without a doubt, the single most destructive pagination mistake you can make. It’s the one I made early in my career. It’s the one I see most often.

The logic goes like this: “Page 1 is the main, most important page in this series. Therefore, I should tell Google that all other pages in the series (page 2, 3, 4…) are just copies of page 1.”

So, they place a canonical tag on page 2 that points back to page 1.

rel="canonical" href="https://www.mysite.com/category-page"

This is an unambiguous signal to Google. You are telling Google, “Page 2 is a 100% duplicate of Page 1. Please ignore Page 2 and transfer all its signals to Page 1.”

Google, being an obedient robot, says, “Got it.”

It stops indexing page 2. And more importantly, it stops crawling page 2. Why would it crawl a page it’s been told to ignore?

The catastrophic consequence? Google never sees the links to the products or posts on page 2. Or page 3. Or page 4. As far as Google is concerned, those products don’t exist.

You’ve hidden them.

Are You Blocking Google at the Front Door with robots.txt?

This is the nuclear option. It’s less common, but I still see it.

A developer, worried about crawl budget, will add a Disallow rule to their robots.txt file.

Disallow: /category/page/ or Disallow: *?page=*

This literally puts up a brick wall. It tells Googlebot, “You are not even allowed to look at these URLs.”

This is different from a noindex tag. A noindex tag lets Google look at the page and then tells it not to put it in the index. A robots.txt block prevents Google from ever even knowing the page exists. This means it can’t crawl the page, can’t see the links, can’t pass any link equity, and can’t discover your content.

Never, ever block your paginated URLs in robots.txt. You want Google to crawl them. Crawling is how it finds your stuff. You just need to manage what it does after it crawls.

Okay, I’m Scared. What’s the Right Way to Do This?

Breathe.

The correct way is actually far simpler than all the confusing, outdated methods. The modern, correct approach is about being honest and transparent with Google.

The core principle is this: Your paginated pages are not duplicates. They are unique pages.

Think about it. Page 2 of your “Running Shoes” category is not a duplicate of Page 1. Page 1 shows products 1-20. Page 2 shows products 21-40. They have different content. They should be treated as different pages.

Your entire strategy should be built around this one simple, logical truth.

What’s This “Golden Rule” About Self-Referencing Canonical Tags?

This is it. This is the heart of the entire strategy.

A self-referencing canonical tag is one that points to the page it’s already on. It’s the SEO equivalent of a page saying, “Hi, I’m me. This is the one and only version of this page. I am the original.”

Here’s how it works:

• Page 1:https://www.mysite.com/running-shoes
  • Canonical Tag: <link rel="canonical" href="https://www.mysite.com/running-shoes" />
• Page 2:https://www.mysite.com/running-shoes?page=2
  • Canonical Tag: <link rel="canonical" href="https://www.mysite.com/running-shoes?page=2" />
• Page 3:https://www.mysite.com/running-shoes?page=3
  • Canonical Tag: <link rel="canonical" href="https://www.mysite.com/running-shoes?page=3" />

…and so on.

This simple setup solves everything.

You are telling Google, “Yes, this is a series. And yes, each page in this series is a unique, real page that you should crawl. Please follow all the links on all these pages and discover my content.”

Google’s crawlers can now happily move from page 1, to page 2, to page 3, following the links and passing link equity to all the products along the way.

But Doesn’t That Create Duplicate Content?

No. This is the fear you have to let go of.

Will Google index all 50 of your paginated pages? Probably not. It will likely index page 1 (the most relevant) and maybe a few others.

But it will crawl all of them.

And that’s the distinction.

You don’t care if www.mysite.com/running-shoes?page=47 ranks for “running shoes.” You do care that Google crawls page 47, finds the link to the “Nike Pegasus Trail 5,” and gives that product page the link equity it deserves.

The “duplicate content” you’re worried about—the header, footer, and sidebar—is called “boilerplate.” Google is extremely sophisticated at identifying boilerplate. It knows how to ignore it and focus on the main content block, which is unique on every single page.

Trust Google. It’s smart enough to see the difference between product 1 and product 21.

How Do I Signal the Relationship Between Pages Now?

If rel=prev/next is dead, how does Google know page 2 comes after page 1?

Simple.

By using the single oldest and most reliable signal on the internet: an HTML link.

Your on-page pagination controls (e.g., < 1 | 2 | 3 | 4 | 5 >) are all the signal Google needs. When Googlebot crawls page 1, it sees a clean, crawlable link:

<a href="https://www.mysite.com/running-shoes?page=2">2</a>

It follows that link. It lands on page 2. It finds the self-referencing canonical. Then it sees the links for page 3 and page 4. It can follow this breadcrumb trail for as long as it needs to, discovering all your content.

This is why it is critical that your pagination links are real <a href="..."> links. If you use JavaScript onClick events without a fallback href, Googlebot may not be able to follow them. Always check your source code.

What About the “View All” Page? Is It a Silver Bullet?

Ah, the “View All” page. This is a special case.

A “View All” page is a single page that loads all the content from the paginated series. All 5,000 products on one URL.

From a purely theoretical SEO standpoint, this is fantastic. All link equity is consolidated onto one super-page. All products are one click from the main category page.

But in practice, it can be a UX and performance disaster.

I had an e-commerce client with massive categories who insisted on a “View All” page. They thought it would solve their SEO problems. What happened? Their server would time out trying to render 8,000 product variants on one page. Mobile users, 70% of their traffic, would hit the page, wait 15 seconds for it to load, and bounce immediately.

Their conversion rate tanked.

A “View All” page is only a good idea if it’s fast. If you have 100 products, go for it. If you have 5,000, it’s probably a bad idea. Performance and user experience come first.

If I Use “View All,” How Do I Canonicalize?

This is the one, and only, exception to the self-referencing canonical rule.

If you have a “View All” page, and you want it to be the one that ranks in Google, then you must canonicalize all the component pages (page 1, 2, 3…) to that “View All” page.

• Page 1:https://www.mysite.com/running-shoes?page=1
  • Canonical: <link rel="canonical" href="https://www.mysite.com/running-shoes?view-all" />
• Page 2:https://www.mysite.com/running-shoes?page=2
  • Canonical: <link rel="canonical" href="https://www.mysite.com/running-shoes?view-all" />
• View All Page:https://www.mysite.com/running-shoes?view-all
  • Canonical: <link rel="canonical" href="https://www.mysite.com/running-shoes?view-all" /> (It self-references)

This correctly tells Google, “All these little pages are just slices of this one big, definitive page. Please consolidate all signals to the ‘View All’ URL.”

My Site Doesn’t Use “Page Numbers.” What About Infinite Scroll?

Infinite scroll. It’s that modern UX pattern where new content loads automatically as the user scrolls down the page. No “Next” buttons.

From an SEO perspective, infinite scroll is a potential black hole.

Googlebot does not “scroll.” It doesn’t trigger the JavaScript events that load the next batch of content. It loads the initial page (what you’d see as page=1), sees no links to page=2 or page=3, and assumes that’s all the content there is. It leaves.

It never finds your deeper content.

This is a conversion-killer for e-commerce and a traffic-killer for blogs.

How Do I Make Infinite Scroll SEO-Friendly?

You have to create a hybrid system.

The goal is to give human users the smooth infinite scroll experience while giving Googlebot the simple, crawlable links it needs.

The solution is called “paginate-on-scroll.”

Here’s how it works:

1. Initial Load: The user (and Googlebot) loads https://www.mysite.com/blog. This is page=1.
2. User Scrolls: When the user scrolls to the bottom, JavaScript loads the content for page=2 and appends it to the bottom of the page.
3. URL Update: Crucially, as the page=2 content loads, you use the JavaScript History API to update the URL in the browser bar to https://www.mysite.com/blog?page=2.
4. Google’s Path: Here’s the magic. You must also include standard, crawlable <a href="..."> links for page=2, page=3, etc., in your footer or somewhere on the page.

Googlebot ignores the scroll-triggered JavaScript. It just crawls the page, finds the link to https://www.mysite.com/blog?page=2, and follows it.

When it lands on that URL, it gets a page that starts with the content from page 2. This is a real, distinct, crawlable, and indexable page. You’ve created a fully accessible, paginated series behind your fancy infinite-scroll interface.

This is the best of both worlds. For a great reference on web accessibility patterns for pagination, which search engines also appreciate, check out this pagination design pattern from MIT.

Let’s Talk URL Parameters. ?page=2 vs. /page/2/?

Does it matter if your URLs look like: .../category?page=2 or .../category/page/2/

From a purely technical SEO standpoint? No. It doesn’t matter. Google can handle both.

What does matter is consistency.

Don’t mix and match. Don’t have some links going to one version and other links going to another. Pick one structure and stick with it.

Your self-referencing canonical tag is what solves this. As long as the canonical tag on .../category?page=2 points to .../category?page=2 (including the parameter), you are clearly telling Google which URL is the definitive one. This prevents any duplicate content issues that could arise from other parameters like ?page=2&sessionid=123. The canonical strips away the junk parameters and focuses on the real URL.

What About Faceted Navigation (Filters, Sorting)?

This is where things get really complex.

Faceted navigation (or “faceted search”) is when you have filters and sorting options on a category page.

• .../shoes?color=red
• .../shoes?size=10
• .../shoes?color=red&size=10&sort=price_low

This system can algorithmically create billions of unique URL combinations. This is a genuine crawl budget nightmare. And yes, this is duplicate content. The page for “red shoes” and “red shoes size 10” are way too similar.

Handling faceted navigation is a whole different article, but the quick-and-dirty rule is this:

1. Your main paginated series (?page=2, ?page=3) should be crawlable, indexable (with self-referencing canonicals), and have follow links. This is your “map” for Google.
2. Your faceted URLs (?color=red, etc.) should generally be handled in one of two ways:
   • Option A (Aggressive): Block all faceted parameters in robots.txt (Disallow: *?color=*). This saves crawl budget but is a blunt instrument.
   • Option B (Better): Allow them to be crawled, but add a noindex, follow tag. This lets Google follow the links if it lands on one, but tells it not to junk up the index. Even better, use the canonical tag to point a faceted URL back to its non-faceted parent (e.g., .../shoes?color=red canonicals to .../shoes).

The key is to differentiate between your pagination (which you want crawled) and your filtering (which you mostly want ignored).

How Can I Audit My Own Site Right Now?

You don’t need a fancy, expensive tool to check your basics. You can do a 5-minute audit right now using just your browser.

Go to one of your category or blog archive pages. Go to page 2.

Now, do these four things:

• 1. Check the robots.txt file: Go to www.yoursite.com/robots.txt. Is there any Disallow rule that would block the URL you’re on (e.g., Disallow: *?page=*)? If so, you have a problem.
• 2. View the Source Code: Right-click and “View Page Source.” (Do not use “Inspect Element,” which can be misleading).
• 3. Find the Canonical Tag: Hit CTRL+F or CMD+F and search for "canonical". Look at the href URL.
  • Does it point to Page 1? This is a critical error. Fix it.
  • Does it point to itself (e.g., the URL in the href is the same as the URL in your browser bar)? Congratulations, this is correct!
• 4. Find the robots Tag: While in the source code, search for "robots".
  • Do you see content="noindex" or content="noindex, follow"? This is a critical error. Remove it.
  • If you don’t find a robots tag at all, that’s perfect. The default is index, follow.
• 5. Click the Page Numbers: Look at your “3, 4, 5… Next” links. Right-click and “Copy Link Address.”
  • Is it a clean, real URL? Great.
  • Is it something like javascript:void(0)? You may have a problem with Googlebot’s ability to crawl.

This simple test will tell you 90% of what you need to know about your site’s pagination health.

What’s the One Thing I Should Remember?

If you remember nothing else, remember this:

Don’t hide your pages from Google.

SEO has become far too complex with “hacks” and “tricks.” The best strategy is almost always the most logical and honest one. Your paginated pages are the map that guides Google to your valuable, deep-level content.

Why would you ever noindex your map? Why would you Disallow crawlers from reading it?

Treat your paginated series as a helpful, crawlable archive. Make each page unique with a self-referencing canonical. Provide clean HTML links for Google to follow. Then, get out of the way and let Google do its job.

Fixing pagination isn’t some dark art. It’s one of the cleanest and most important technical SEO wins you can get. It’s the digital equivalent of unlocking all the back doors to your store and letting the customers (and Google) flood in.

You’ve got this.

FAQ