Webflow CMS Limits:
What They Are and How to Work Around Them

Webflow's CMS is genuinely powerful. You can build complex, dynamic sites without writing backend code, and for most projects it handles everything you throw at it. But it has hard limits — ceilings you hit with zero warning, usually at the worst possible time.

I have hit every single one of these limits across client projects. The collection limit at 3 AM before a launch. The field limit halfway through a migration. The multi-reference cap when a client's product catalog outgrew the constraint nobody planned for. Each time, the fix required restructuring work that would have taken ten minutes to prevent and took hours to resolve.

This guide documents every Webflow CMS limit, explains why each one matters, gives you the standard workaround, and shows how Trellis handles each constraint automatically. Keep it bookmarked. You will come back to it.

Collection Limits

The limit: 40 CMS collections on the Business plan. 20 on the CMS plan. These are hard caps — Webflow will not let you create collection number 41.

Why it matters: Twenty collections sounds like plenty until you start building a real site. A typical agency portfolio site needs: Blog Posts, Categories, Authors, Case Studies, Services, Team Members, Testimonials, FAQs, Job Openings, Locations. That is ten collections for a site most people would call "simple." Add a client portal, an events section, or localized content structures and you are at fifteen before the design phase is over.

E-commerce sites compound the problem. Products, product categories, product tags, variants, size guides, material descriptions, related accessories — each one a collection. Multi-brand or multi-locale sites can exhaust the 20-collection CMS plan limit before the first page is designed.

The standard workaround: Consolidate collections that share a structure. Instead of separate "Blog Posts" and "News" collections with identical fields, use one "Articles" collection with a "Type" option field. Filter by type in your collection lists. This trades some editorial clarity for collection headroom.

You can also offload lookup-style data — things like tags, color options, or status labels — into option fields instead of separate collections. You lose the ability to create landing pages for those entities, but you save a collection slot.

How Trellis handles it: Trellis lets you manage your content in Airtable, where there is no practical collection limit. You structure your data the way it makes sense — as many tables as you need — and Trellis maps them into your Webflow collections intelligently, consolidating where needed and preserving relationships. You design for the content model, not for the constraint.

Field Limits

The limit: 60 fields per collection, including system fields. Every Webflow collection starts with six system fields: Name, Slug, Created On, Updated On, Published On, and Archived. That leaves you 54 custom fields.

Why it matters: Fifty-four fields seems generous until you count what a well-structured collection actually needs. A real-world blog post collection: Title, Slug, Body (Rich Text), Excerpt, Featured Image, Thumbnail, Author (Reference), Categories (Multi-Reference), Tags (Multi-Reference), Published Date, Featured (Switch), SEO Meta Title, SEO Meta Description, SEO OG Image, Card CTA Text, Read Time, Related Posts (Multi-Reference). That is 17 fields — manageable.

But landing pages, product pages, and case studies routinely need 30 to 45 fields. A landing page with a hero section, three feature blocks, a testimonial, a pricing table, and a CTA — each section requiring a heading, body, image, and link — burns through fields fast. At 45 fields you start making compromises. At 54, you are locked out.

The Webflow field limit is the constraint people hit most often, and it is the one that causes the most restructuring pain because fields cannot be retyped. If you chose Plain Text and needed Rich Text, you delete the field, lose its data, create a new one, and re-enter everything.

The standard workaround: Split the collection. Move sections of the page into a companion "Page Sections" collection connected via multi-reference. Each section gets its own item with a type, heading, body, and image. The parent page references the sections it needs. This pattern is sometimes called a "modular content" or "component-based" CMS architecture.

Another approach: use Rich Text fields to absorb what would otherwise be multiple plain text and image fields. A single Rich Text field can hold headings, paragraphs, images, and lists — reducing five fields to one. The tradeoff is less granular styling control and a harder time binding individual elements to CMS data.

How Trellis handles it: Trellis manages your full data model in Airtable, where fields are unlimited. When syncing to Webflow, Trellis maps only the fields your Webflow site actually uses, keeping each collection well within the 60-field limit. If your content model evolves and you need to restructure, Trellis handles the field mapping changes without manual data migration.

Multi-Reference Limits

The limit: 100 items per multi-reference field. If a blog post references categories, that post can link to at most 100 categories. Additionally, you can only have 5 multi-reference fields per collection.

Why it matters: The 100-item cap rarely matters for things like categories or tags — few posts need more than ten. But it becomes a real problem for product catalogs, resource libraries, or any collection where items have many relationships.

Consider an "Ingredients" collection for a recipe site. A complex recipe might reference 30 ingredients — fine. But now add a reverse relationship: an ingredient page showing every recipe that uses it. Popular ingredients like "butter" or "olive oil" could appear in hundreds of recipes, easily exceeding 100.

The 5-multi-reference-per-collection limit is equally constraining. A Case Studies collection might need multi-references for: Industries, Services, Technologies, Team Members, and Related Case Studies. That is exactly five — no room for an additional Tags or Clients relationship.

The standard workaround: For the item cap, use a junction collection. Instead of a direct multi-reference between Recipes and Ingredients, create a "Recipe Ingredients" collection with single references to both. This removes the 100-item ceiling but adds complexity to your Designer bindings and collection lists.

For the 5-field limit, consolidate relationships. Combine "Industries" and "Services" into a single "Tags" collection with a type field, and use one multi-reference instead of two. You lose some type safety but gain a reference slot.

How Trellis handles it: Trellis manages relationships in Airtable using linked records, which have no practical item limit. When syncing to Webflow, Trellis maps these relationships to multi-references and handles overflow automatically — splitting into junction collections where needed, invisible to your Webflow Designer workflow.

Image Limits

The limit: No native multi-image field type. Each image field holds exactly one image. If a product needs a gallery of six images, you need six separate image fields — or a workaround.

Why it matters: Image galleries are one of the most common content patterns on the web. Product pages, portfolio projects, property listings, team member photos — nearly every content type eventually needs more than one image. Webflow's single-image field forces you into awkward structural decisions.

Six individual image fields (Gallery Image 1 through Gallery Image 6) burns six of your 54 custom field slots. If you need alt text for each, that is twelve fields for a six-image gallery. And you have hard-coded the maximum — if a product needs seven images, you are adding another field and rebinding in the Designer.

The standard workaround: Create a companion "Gallery Images" collection with an Image field, Alt Text field, Sort Order field, and a Reference back to the parent item. Each image is its own CMS item. Display them using a nested collection list filtered by the parent reference.

This works but is tedious to manage. Adding images to a product means creating new items in the Gallery Images collection, setting the reference, and ordering them manually. For content editors used to dragging images into a gallery widget, this is a significant UX downgrade.

Another option: use a Rich Text field as a gallery container. Embed images directly into the rich text editor. You lose structured data (no alt text field, no sort order, no conditional display logic) but gain a simpler editing experience.

How Trellis handles it: Airtable has a native attachment field that holds multiple images per record. Trellis syncs these to Webflow by automatically creating and managing the companion gallery collection — each attachment becomes a gallery item, properly referenced and ordered. You add images in Airtable the natural way. Trellis does the structural translation.

Rich Text Limitations

The limit: Rich Text fields in Webflow cannot have their sub-elements individually bound to other CMS fields. You can style headings, lists, and paragraphs globally for all Rich Text fields, but you cannot bind, say, an H2 inside a Rich Text block to a separate CMS text field.

Why it matters: Rich Text is Webflow's most flexible field type — it supports headings, paragraphs, lists, images, videos, and embedded code. But that flexibility comes with a loss of structural control. If your design requires a specific heading to always render with a particular class, or an image within the body to link to a CMS-defined URL, Rich Text cannot do it.

This creates a tension between editorial flexibility and design precision. Designers want pixel-perfect control over every element. Editors want a familiar text editor where they can format content naturally. Rich Text gives editors what they want at the cost of what designers need.

The standard workaround: For content that needs both editorial flexibility and design control, split the page into structured CMS fields for predictable sections (hero, stats, CTA) and a Rich Text field for the free-form body content. This "hybrid" approach gives designers control where it matters while still allowing editors to write naturally.

You can also use Webflow's custom code embed within Rich Text to inject styled HTML, though this requires editors to be comfortable with code — which most are not.

How Trellis handles it: When syncing from Airtable, Trellis converts Airtable's rich text (Markdown-based) to Webflow's Rich Text HTML format automatically. Structured data stays structured — mapped to individual Webflow fields. Only content that genuinely belongs in a free-form body goes into Rich Text. Trellis helps you maintain the boundary between structured and unstructured content.

CMS Item Limits

The limit: 10,000 CMS items on the Business plan. 2,000 on the CMS plan. This is a site-wide total across all collections combined, not per collection.

Why it matters: Two thousand items sounds like a lot until you count companion collections. A product catalog with 200 products, each needing 5 gallery images (in a Gallery Images collection), 3 specifications (in a Specs collection), and 2 reviews (in a Reviews collection) is already at 200 + 1,000 + 600 + 400 = 2,200 items. You have exceeded the CMS plan limit with just 200 products.

The item limit is especially punishing when you use the workarounds for other limits. Companion collections for image galleries, junction collections for multi-references — each workaround multiplies your item count. The limits interact with each other in ways that are not obvious until you do the math.

The standard workaround: Upgrade to the Business plan for the 10,000 item ceiling. Beyond that, there is no workaround within Webflow — you either reduce your content or move to a headless CMS.

For sites approaching the limit, audit your companion collections. Are all gallery images necessary? Can specs be consolidated into a Rich Text field instead of individual items? Can archived or outdated content be unpublished and deleted? These are compromises, but they buy time.

How Trellis handles it: Trellis syncs only the items that need to be in Webflow. Your complete dataset lives in Airtable with no item limit. Trellis selectively syncs the subset your Webflow site requires — active products, published posts, current team members — keeping your item count lean while your source data stays comprehensive.

API Rate Limits

The limit: 120 API requests per minute for the Webflow CMS API. This applies to all API consumers combined — if you have a sync tool and a custom integration both hitting the API, they share that 120-request budget.

Why it matters: A single CMS item update is one API request. Updating 200 products means 200 requests — almost two minutes of API time at the rate limit. Adding images requires separate upload requests. Creating items with references requires the referenced items to exist first, forcing sequential operations.

Bulk operations help — Webflow's bulk endpoints handle up to 100 items per request — but they are only available for certain operations and still count against the rate limit. Large migrations or full catalog syncs can take 30 minutes or more, and a single rate limit error can break the entire batch if not handled properly.

The standard workaround: Implement request queuing with exponential backoff. Space requests to stay under 2 per second. Use bulk endpoints wherever possible. Cache responses to avoid redundant reads. For large operations, run them during off-peak hours and implement retry logic for 429 (rate limit) responses.

How Trellis handles it: Trellis manages rate limiting automatically. It queues requests, uses bulk operations where available, implements intelligent retry logic, and batches updates to maximize throughput without hitting the ceiling. Delta syncs — syncing only what changed since the last run — dramatically reduce the number of API calls needed. A 200-product catalog where 5 products changed requires 5 updates, not 200.

Summary: Every Webflow CMS Limit in One Table

How These Limits Interact

The most dangerous thing about Webflow CMS limits is not any individual constraint — it is how they compound. The workaround for one limit often accelerates your collision with another.

• Image galleries eat item limits. A companion gallery collection adds 5 to 20 items per parent record. Two hundred products with five images each is 1,000 gallery items — half the CMS plan limit consumed by image workarounds alone.
• Collection splits eat collection limits. Splitting a 55-field collection into two 30-field collections solves the field limit but uses an extra collection slot. Do this four times and you have consumed 20% of your collection budget on structural overhead.
• Junction collections eat both. A junction collection for multi-references uses a collection slot and creates items proportional to the number of relationships — potentially thousands.

This compounding effect is why CMS architecture planning matters. You cannot solve each limit independently. You need to model the total cost of your content structure — collections, fields, items, and references — before you start building.

Frequently Asked Questions

Can I increase the Webflow CMS collection limit?

Not beyond the plan maximum. The CMS plan allows 20 collections and the Business plan allows 40. There is no add-on, override, or enterprise exception that raises this ceiling. If you need more than 40 collections, you need a headless CMS or a content management layer like Trellis that manages your data externally and syncs a subset to Webflow.

Do system fields count toward the 60-field limit?

Yes. Every collection starts with six system fields (Name, Slug, Created On, Updated On, Published On, Archived). These count toward the 60-field cap, leaving you 54 custom fields. This is a common source of confusion — the "60 fields" number includes fields you did not create and cannot remove.

What happens when I hit the 10,000 item limit?

Webflow will not let you create or import additional items. Existing items remain live and functional. You need to either delete items to free up space, upgrade your plan (if a higher tier is available), or move content management to an external system that syncs selectively to Webflow.

Are API rate limits per site or per account?

API rate limits are per site. Each site gets 120 requests per minute, shared across all API tokens and integrations accessing that site. If you have a sync tool and a custom webhook both calling the API, they compete for the same 120-request budget.

Can I use multi-reference fields for image galleries?

Yes, but it is not ideal. You can create a "Media" collection and multi-reference it from your content collection. This works for shared media (the same image used across multiple items) but is awkward for item-specific galleries because the gallery images live in a shared pool rather than being scoped to their parent. A companion collection with a single reference back to the parent is usually a better pattern.

Will Webflow raise these limits?

Webflow occasionally adjusts plan limits — the Business plan item limit was previously 5,000 and was raised to 10,000. But structural limits like the 60-field cap and 100-item multi-reference ceiling have remained unchanged for years. Building your architecture around current limits is safer than hoping for future changes.

How does Trellis help with Webflow CMS limits?

Trellis manages your content in Airtable — where collections, fields, and items are effectively unlimited — and syncs to Webflow intelligently. It maps your full data model into Webflow's constraints automatically: consolidating fields, managing companion collections for galleries, handling multi-reference overflow, and syncing only active content to stay within item limits. You design for your content, not for the platform's ceiling. Read more about how Trellis works.