Webflow CMS

How to Get Past the 100-Item Limit on a Webflow Collection List

TS Talha Shahzad··7 min read
The short version
  • Webflow limits any single Collection List to rendering a maximum of 100 items on the live site.
  • This render limit is separate from the total CMS item limit of your hosting plan.
  • Native pagination is the easiest, no-code fix but requires a page reload for every new batch.
  • You can stack two lists and use the Skip offset setting to display up to 200 items inline.
  • True infinite scroll or dynamic load-more requires custom Javascript or tools like Finsweet Attributes.

If you are building a large blog or a product catalog in Webflow, you will eventually hit a wall. You drag a Collection List onto the canvas, style it, connect your CMS, and realize that only 100 items are displaying. Webflow limits every single Collection List element to rendering a maximum of 100 items on the published site.

To show more than 100 CMS items in Webflow, you have to choose between three paths: native pagination, the skip-field duplicate trick, or an external loading solution like Finsweet Attributes or custom Javascript. This is not a limit on how many items your CMS database can hold, but rather a hard limit on how many items Webflow will render in a single container on a page load.

After 450+ builds, I have seen this limit frustrate designers and clients alike. The good news is that you can get around it without migrating your database or compromising your layout. Let's look at the three most reliable ways to bypass this cap and build a list that scales.

Understanding the Webflow rendering ceiling

It is important to understand why this limit exists. Webflow enforces a 100-item limit per list to protect page performance. If a page tries to render 500 items with heavy images and nested dynamic fields all at once, the browser will lag, and your page speed scores will tank.

This is a render-level constraint. Depending on your site plan, your CMS can hold many thousands of items in the database (up to 20,000 on the top self-serve plan). But if you try to show them all on a single page in a single continuous grid, the designer will stop you at 100. Knowing this distinction helps you plan the right fix. If you only have 120 items, a simple visual trick works. If you have 800 items, you need a dynamic solution.

Option 1: The native pagination fix

The simplest way to bypass the limit without writing code is to use Webflow's native pagination. When you select your Collection List and open the Element Settings panel, you will see a checkbox for pagination.

When you check this box, you can set the number of items to show per page. For example, you can set it to 100. Webflow will automatically generate next and previous buttons below your list. When a visitor clicks next, the page reloads with the next set of items.

The pros of native pagination:

  • It requires zero setup outside the native designer interface.
  • It is highly secure and does not rely on third-party scripts.
  • It is easy to style using standard Webflow classes.

The cons of native pagination:

  • Every page change requires a full browser reload.
  • The reload interrupts the user experience, especially on mobile.
  • It feels slow compared to modern web applications.

If you are building a basic directory or a simple archive page, native pagination is fine. But if you want a seamless, modern experience, you will want to look at other options.

Want a website that turns visitors into customers, not just compliments?

Book a 15-min intro

Option 2: The duplicate and skip trick (Up to 200 items)

If you have slightly more than 100 items, say 130 or 170, and you absolutely want them to display on the page at the same time without pagination, you can use the duplicate and skip method.

This trick takes advantage of Webflow's ability to offset where a list starts rendering. Here is how to set it up:

  1. Create your first Collection List, connect it to your collection, and set the limit to 100.
  2. Duplicate that entire Collection List wrapper and place it directly below the first list.
  3. Keep the styling and structure identical so they look like one continuous list on the page.
  4. On the second list, go to the Element Settings panel.
  5. Set the Start at setting (also known as the Skip setting) to 100.
  6. Set the Limit to 100.

Your first list will display items 1 through 100. Your second list will display items 101 through 200. Because they sit right next to each other and share the same styling, your visitors will see one unified grid of up to 200 items.

While this trick is quick, it does have limits. You can only use a maximum of 40 Collection lists per page in Webflow. Stacking many lists to show hundreds of items will severely hurt your page loading times. For anything beyond 200 items, you should avoid this approach.

Option 3: Dynamic load-more with Finsweet Attributes

The most popular developer solution for showing more than 100 items is using Finsweet Attributes. It is a free, script-based library that lets you load CMS items dynamically as the user scrolls or clicks a button, without reloading the page.

To set this up, you use a combination of simple Javascript and custom attributes. Here is the process:

First, add the Finsweet CMS Load script to the custom code section of your page (in the before-body tag):

<script defer src="https://cdn.jsdelivr.net/npm/@finsweet/attributes-cmsload@1/cmsload.js"></script>

Next, apply the required custom attributes to your Webflow elements:

  1. Select your Collection List Wrapper, open the settings panel, and add a custom attribute. Set the name to fs-cmsload-element and the value to list.
  2. Select your Collection List pagination container (ensure native pagination is turned on in Webflow settings). Add an attribute with the name fs-cmsload-element and the value to pagination.
  3. If you want a load-more button, style a button on your page, and give it the attribute fs-cmsload-element with the value button.

Once published, the script intercepts Webflow's native pagination. Instead of reloading the page when a user clicks the button or scrolls to the bottom, the script fetches the next page in the background and appends the new items directly to the list. This gives you a fast, modern infinite scroll or load-more experience.

Building a custom Javascript fetch solution

If you prefer to avoid third-party libraries entirely, you can write a short Javascript function to fetch and append the paginated items yourself. This keeps your site lightweight and free of external dependencies.

To do this, turn on native pagination in Webflow and set the limit to 100. Wrap your collection list in a div with the ID cms-list-wrapper. Then, add a button below the list with the ID load-more-btn.

Add this script to your page settings before the body tag:

document.addEventListener("DOMContentLoaded", function() {
  const loadMoreBtn = document.getElementById("load-more-btn");
  const listWrapper = document.getElementById("cms-list-wrapper");
  
  if (!loadMoreBtn || !listWrapper) return;
  
  // Find the native Webflow next button link
  let nextButton = listWrapper.querySelector(".w-pagination-next");
  
  if (!nextButton) {
    loadMoreBtn.style.display = "none";
    return;
  }
  
  loadMoreBtn.addEventListener("click", async function() {
    loadMoreBtn.textContent = "Loading...";
    const targetUrl = nextButton.getAttribute("href");
    
    try {
      const response = await fetch(targetUrl);
      const htmlText = await response.text();
      
      // Parse the fetched HTML
      const parser = new DOMParser();
      const doc = parser.parseFromString(htmlText, "text/html");
      
      // Get the new items and the new next button
      const newItems = doc.querySelectorAll("#cms-list-wrapper .w-dyn-item");
      const newNextButton = doc.querySelector("#cms-list-wrapper .w-pagination-next");
      
      // Append new items to current list
      const currentList = listWrapper.querySelector(".w-dyn-items");
      newItems.forEach(item => {
        currentList.appendChild(item);
      });
      
      // Update the next link reference
      if (newNextButton) {
        nextButton.setAttribute("href", newNextButton.getAttribute("href"));
      } else {
        // No more pages left
        nextButton = null;
        loadMoreBtn.style.display = "none";
      }
      
      loadMoreBtn.textContent = "Load More";
    } catch (error) {
      console.error("Error loading more items:", error);
      loadMoreBtn.textContent = "Error, try again";
    }
  });
});

This script fetches the next page's HTML in the background, extracts the new dynamic items, appends them to your current page, and updates the pagination link. It is clean, fast, and does not require any paid subscriptions.

Choosing the right approach comes down to your catalog size and your team's comfort with code. If you have under 200 items, the duplicate-and-skip trick is a fast visual fix. For larger sites, a dynamic loader like Finsweet or custom Javascript provides the best balance of speed, user experience, and performance.

Prefer to hire through Upwork?
Top Rated Plus, 100% Job Success, 450+ projects shipped. See the reviews and start a contract.
Hire me on Upwork

FAQ

Is the 100-item limit a total CMS database limit?

No. The 100-item limit only applies to what a single Collection List element can render on a page. Your database can hold thousands of items, depending on your hosting plan, but a single visual list in the designer will stop at 100.

Can I use multiple collection lists to show 300 or 400 items?

Technically you can stack lists and use the Skip offset, but Webflow limits you to 40 Collection lists per page. Stacking too many lists will bloat the page and slow down load times.

Do I need to pay for a tool to get infinite scroll?

No, you do not have to pay. Finsweet Attributes is a completely free developer library that provides load-more and infinite scroll. You can also write a custom fetch script if you want to keep the code entirely in-house.

Does native pagination hurt SEO?

Not necessarily. Search engine crawlers can still find paginated links if the URLs are structured cleanly, but showing all items or using search-engine friendly infinite scroll is generally better for crawlability.

All posts
the next step is small

Want a site that does this for you?

15 minutes, no deck, no pressure. Worst case, you leave with a free plan.

keep reading

More notes