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 introOption 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:
- Create your first Collection List, connect it to your collection, and set the limit to 100.
- Duplicate that entire Collection List wrapper and place it directly below the first list.
- Keep the styling and structure identical so they look like one continuous list on the page.
- On the second list, go to the Element Settings panel.
- Set the Start at setting (also known as the Skip setting) to 100.
- 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:
- Select your Collection List Wrapper, open the settings panel, and add a custom attribute. Set the name to
fs-cmsload-elementand the value tolist. - Select your Collection List pagination container (ensure native pagination is turned on in Webflow settings). Add an attribute with the name
fs-cmsload-elementand the value topagination. - If you want a load-more button, style a button on your page, and give it the attribute
fs-cmsload-elementwith the valuebutton.
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.