How to Export Data from Webflow: Methods, API Limits & Portability

What Data Can You Actually Export from Webflow?

Webflow gives you three distinct ways to get data out: CSV export from the Designer (one CMS Collection at a time), code export as a ZIP of static HTML/CSS/JS (paid Workspace plans only), and the Data API v2 for programmatic extraction of CMS items, ecommerce data, and form submissions. There is no single "export everything" button. Each method has blind spots, and understanding those gaps before you start is the difference between a clean migration and weeks of manual reconstruction.

Webflow stores data across several distinct systems: the CMS (Collections and Items), Ecommerce (Products, Orders, Inventory), Forms (submissions), Assets (images, files), Users (Memberships), and the site design itself (HTML, CSS, JS). Each has a different export path and different limitations.

Method 1: CMS CSV Export from the Designer

This is the fastest way to get structured content out of Webflow for small-to-medium sites.

How to export a CMS Collection as CSV

1. Open your project in the Webflow Designer.
2. Navigate to the CMS Collections panel (the database icon).
3. Select the Collection you want to export.
4. Click the Export button at the top of the collection.
5. Choose whether to export all items (including archived) or selected items.
6. Webflow generates and downloads a CSV file.

You must export each Collection individually. There is no "export all collections" option in the Webflow UI. For sites with 10+ collections, this becomes tedious fast.

What the CSV contains

• All standard field values for each item
• Rich text fields exported as raw HTML strings
• Image fields as Webflow-hosted URLs
• Reference fields as display names (the human-readable name, not the item ID)
• Multi-reference fields as comma-separated display names
• Item ID included (useful for re-importing with Webflow's "Link and update matching items" feature)

What the CSV does NOT contain

• Relational integrity: Reference fields flatten to display names. If a Blog Posts collection references an Authors collection, you get the author's name as a string — not a foreign key you can programmatically re-link. Rebuilding relationships from CSV requires a manually constructed mapping table from display names to destination item IDs. For collections with name collisions (two authors named "Alex Smith"), this mapping becomes ambiguous and must be resolved by hand.
• Collection schema: A CSV gives you rows, not field definitions. Field types, option values, validation rules, and reference topology live in the Collection schema, accessible only through the API via GET /v2/collections/:collection_id. Without schema capture, you are guessing field types when you rebuild the data model in the target system. (developers.webflow.com)
• Page metadata: No meta descriptions, OG images, or URL slugs in a portable format.
• Cross-collection context: Each CSV is a standalone file. There is no join key between exported CSVs unless you manually correlate Item IDs.

CSV edge cases

• Localization: The exported CSV only contains items from the current locale view. Multilingual sites require a separate export pass per locale. (help.webflow.com)
• Ecommerce product CSVs omit custom fields. Only standard product fields (name, slug, price, SKUs, variants, images) are included. Fields added to the product collection schema beyond Webflow's defaults are silently dropped.
• CSV import cap is 4 MB. If you are round-tripping data (export → transform → re-import), large collections with rich text and many image URLs can exceed this limit.
• File fields cannot be mapped during CSV import. If your collection uses file upload fields, those will not survive a CSV round-trip cleanly.

Method 2: Code Export (HTML, CSS, JS)

Webflow's code export produces a ZIP file containing your site's static frontend markup. This is a completely separate system from CMS data export. (help.webflow.com)

Requirements

Code export requires a paid Workspace plan. Site plans alone do not unlock this feature. The free Starter plan does not support code export at all.

What you get

• One HTML file per static page
• CSS stylesheets
• JavaScript files (including webflow.js for interactions and animations)
• Image and font assets

What you don't get

This is where teams get burned. The code export strips out everything dynamic:

• CMS content: Collection lists render as empty containers. Template pages do not generate individual item pages.
• Form submissions: Forms display visually but submit to nowhere — they depend on Webflow's backend. To keep forms working on an exported site, you need to rewire the form action to a third-party endpoint (Formspree, Basin, Netlify Forms, or similar). (help.webflow.com)
• Site search: Completely broken without Webflow's content index.
• Ecommerce: Product listings, carts, and checkout are non-functional.
• Memberships / User Accounts: Login forms stop working. Gated pages become publicly accessible.
• Localized content: Code export only includes the primary locale's pages, elements, and content. (help.webflow.com)

Scraping as an alternative

Some teams use tools like wget, HTTrack, or SiteSucker to crawl the published Webflow site and save every rendered page as static HTML. This captures CMS-generated pages that the official code export misses. The trade-off: you get a frozen snapshot with no structured data, no editable content model, and no clean migration path to another CMS.

Method 3: The Webflow Data API v2

For anything beyond a simple backup, the API is the only reliable extraction path. It gives you structured JSON for CMS items, ecommerce data, form submissions, and page metadata — all the things CSV and code export miss.

Authentication and setup

The current API version is v2 (v1 was deprecated in January 2025). You need a Site API Token or an OAuth app with the appropriate scopes:

• cms:read — read Collection schemas and items
• ecommerce:read — read products, orders, inventory
• forms:read — read form submissions
• pages:read — read page metadata
• assets:read — read asset metadata

Generate a token from your site's Integrations settings panel. Site tokens are per-site, limited to five per site, and expire after 365 consecutive days of inactivity. (developers.webflow.com)

Key endpoints for data extraction

# List all collections
GET https://api.webflow.com/v2/sites/{site_id}/collections
 
# Get collection schema (field types, reference topology)
GET https://api.webflow.com/v2/collections/{collection_id}
 
# List items in a collection (paginated)
GET https://api.webflow.com/v2/collections/{collection_id}/items?limit=100&offset=0
 
# List products
GET https://api.webflow.com/v2/sites/{site_id}/products
 
# List orders
GET https://api.webflow.com/v2/sites/{site_id}/orders
 
# List form submissions
GET https://api.webflow.com/v2/sites/{site_id}/form-submissions
 
# Get page metadata
GET https://api.webflow.com/v2/sites/{site_id}/pages
 
# Get static page content
GET https://api.webflow.com/v2/pages/{page_id}/dom
 
# List assets
GET https://api.webflow.com/v2/sites/{site_id}/assets

Note: the page content endpoint (/dom) is scoped to static pages. Dynamic CMS template pages return an empty response. (developers.webflow.com)

How to enumerate locales via the API

If your site uses Webflow Localization, you must enumerate locales explicitly before exporting. The site object returned by GET /v2/sites/{site_id} includes a locales array. Each locale object contains an id (the cmsLocaleId value), a displayName, and a tag (IETF language tag such as "fr" or "de-AT").

GET https://api.webflow.com/v2/sites/{site_id}

Response excerpt:

{
  "locales": [
    { "id": "64b1c2d3e4f5a6b7c8d9e0f1", "displayName": "English", "tag": "en", "primary": true },
    { "id": "64b1c2d3e4f5a6b7c8d9e0f2", "displayName": "French", "tag": "fr", "primary": false }
  ]
}

To export CMS items for a specific locale, pass cmsLocaleId as a query parameter:

GET https://api.webflow.com/v2/collections/{collection_id}/items?cmsLocaleId=64b1c2d3e4f5a6b7c8d9e0f2&limit=100&offset=0

A complete multi-locale export pipeline must iterate over every non-primary locale ID and run a full paginated extraction per locale per collection. Webflow's API does not support exporting localized image field variants — image fields always return the primary locale's asset URL regardless of which cmsLocaleId you pass. (developers.webflow.com)

Pagination

The List Items endpoint returns a maximum of 100 items per request. You control pagination with limit and offset query parameters. The response includes a pagination object with total, limit, and offset fields — loop through pages until offset + limit >= total.

import requests
 
API_TOKEN = "your_token"
COLLECTION_ID = "your_collection_id"
BASE_URL = f"https://api.webflow.com/v2/collections/{COLLECTION_ID}/items"
 
headers = {"Authorization": f"Bearer {API_TOKEN}", "accept": "application/json"}
 
all_items = []
offset = 0
limit = 100
 
while True:
    resp = requests.get(BASE_URL, headers=headers, params={"limit": limit, "offset": offset})
    data = resp.json()
    all_items.extend(data["items"])
    
    if offset + limit >= data["pagination"]["total"]:
        break
    offset += limit
 
print(f"Exported {len(all_items)} items")

Filtering drafts and archived items

By default, the /items endpoint returns published items, drafts, and archived items. Filter the response using the isDraft and isArchived boolean flags to prevent migrating unpublished content to your new system — or to explicitly capture archived content if your requirements demand it.

CLI alternative

Webflow also offers a CLI that wraps the same API. It is convenient for quick audits and one-off exports:

webflow sites list --json
webflow cms collections list --site <site_id> --json
webflow cms items list --collection <collection_id> --limit 100 --offset 0 --json
webflow forms submissions --site <site_id> --form <form_id> --output submissions.csv
webflow assets list --site <site_id> --limit 100 --json

Under the hood, you are still subject to the same scopes, pagination rules, and rate limits as the REST API. (developers.webflow.com)

Webflow API Rate Limits by Plan

Rate limits are the single biggest constraint for programmatic exports. Here are the official limits from Webflow's developer documentation:

Key details:

• Rate limits are per API key, not per site or per account. Each token has its own independent counter.
• Exceeding the limit returns HTTP 429 with a Retry-After header (typically 60 seconds).
• Site Publish operations have a separate limit: one successful publish per minute.
• The Webflow SDK includes built-in exponential backoff. If you are writing raw HTTP calls, implement retry logic that respects the Retry-After header.

(developers.webflow.com)

Realistic export time estimates

For a site on a CMS plan (120 req/min):

• 2,000 CMS items across 5 collections: ~5 schema requests + 20 paginated List Items requests = ~25 total requests. Under 15 seconds.
• 10,000 CMS items on a Business plan: ~100 paginated requests + collection metadata. At 120 req/min, under 1 minute for CMS data alone.
• 10,000 items + 500 products + 2,000 orders + form submissions: ~130+ API calls. At 120 req/min, roughly 1–2 minutes. At 60 req/min on a Starter plan, double that.

The API is rarely the bottleneck. The bottleneck is what you do with the data after extraction — re-hosting images, reconstructing relationships, and transforming field formats for the target platform.

CMS Scale Limits That Affect Your Export

Webflow's CMS has hard caps that determine how much data you will need to extract:

Two things stand out for export planning:

1. The 5-reference-field cap means Webflow sites often use creative workarounds — plain text fields with slugs, JSON blobs in rich text — to model complex relationships. Your export script needs to account for these unofficial relational patterns, not just the formal reference fields.
2. Archived items still count toward the total limit and are included in API responses unless filtered. Make sure your export captures or explicitly excludes them based on your migration requirements.

Handling Complex Field Types

Extracting the JSON payload or downloading a CSV is only the first step. The real engineering challenge is transforming Webflow's specific field types into portable formats.

Re-hosting image assets

Webflow image fields return a URL pointing to Webflow's CDN. Your extraction pipeline must:

1. Parse the exported data for all image URLs.
2. Execute a GET request to download each binary file.
3. Upload the file to your new storage bucket (AWS S3, Cloudflare R2, Cloudinary, or your target CMS's media library).
4. Replace the old Webflow URL in your data with the new destination URL.

Parsing Rich Text HTML

Webflow's Rich Text field exports as standard HTML mixed with Webflow-specific structures, particularly for embedded images and custom code blocks.

If you are migrating to a Markdown-based system, you cannot pass the raw HTML. You must:

1. Run the string through an HTML parser (Cheerio in Node.js, BeautifulSoup in Python) to strip Webflow-specific CSS classes.
2. Use a converter (Turndown.js for JavaScript, markdownify for Python) to generate clean Markdown.

The embedded image edge case: Images placed inside a Rich Text field do not appear as standard Image fields in the API response. They are embedded as <figure> and <img> tags within the HTML string. Your parser must isolate these src attributes, download the images, upload them to your new host, and rewrite the src attribute within the HTML before migrating.

Write-side limitation: Webflow's API does not support code blocks in Rich Text fields on write. If your content uses code blocks and you need to round-trip data back into Webflow (such as during a Notion to Webflow migration), this is a hard constraint that cannot be worked around via the API. (developers.webflow.com)

Resolving reference fields

In the API, reference fields return 24-character hex item IDs. Multi-reference fields return arrays of these IDs:

"tags": ["64b1c2d3e4f5a6b7c8d9e0f1", "64b1c2d3e4f5a6b7c8d9e0f2"]

To make this data portable:

1. Extract the referenced Collection (e.g., "Tags").
2. Create a key-value dictionary mapping item IDs to human-readable values.
3. Run a script over your primary Collection to either replace the IDs with text values or map them to the destination system's identifiers.

In CSV exports, references are already flattened to display names — human-readable but not programmatically linkable. For a proper migration, always work from the API response where IDs are preserved, then build a deterministic remapping to the destination system.

Failure Mode Taxonomy

The table below maps the most common export failures to their root cause and resolution. This is a diagnostic reference, not a general warning list.

Ecommerce Data Export

Webflow Ecommerce data lives in a parallel system to the standard CMS.

Products: Exportable via CSV from the Designer's Ecommerce panel and via the API (GET /v2/sites/:id/products). The CSV covers standard product fields (name, slug, price, SKUs, variants, images). Custom fields added to the product collection schema are silently omitted from the CSV. (help.webflow.com)

Orders: Not exportable via CSV from the native UI. The API is the only path for extracting order data, including customer details, line items, and fulfillment status. Historical order data is read-only.

Inventory: Available via GET /v2/sites/:id/inventory through the API.

SKUs: Webflow separates Products and SKUs into distinct structures. A Product contains the core marketing data (name, description), while SKUs contain the transactional data (price, inventory, variants). Your export must capture both objects to preserve a complete product record.

If you are migrating a Webflow store to Shopify, WooCommerce, or another platform, use the API for orders and inventory from the start. The CSV path alone will not capture complete ecommerce data.

Form Submission Data

Form submissions live on a separate track from CMS data. In the Webflow UI, go to Site settings > Forms, open the form, and export. Webflow includes uploaded files as URLs in the CSV. If you later delete those submissions, the uploaded file URLs become inaccessible — back them up first. (help.webflow.com)

For repeatable or bulk exports, use the API or CLI:

# API
GET https://api.webflow.com/v2/sites/{site_id}/form-submissions
 
# CLI
webflow forms submissions --site <site_id> --form <form_id> --output submissions.csv

The API returns paginated JSON with all submitted form data. For compliance or backup purposes, this is the most reliable extraction path. (developers.webflow.com)

If you export site code and host it somewhere else, Webflow's built-in form handling does not transfer. Forms must be rewired to a third-party endpoint (Formspree, Basin, Netlify Forms, or a custom backend) to remain functional.

User (Memberships) Data

User data can be exported via the API (GET /v2/sites/{site_id}/users). You can extract names, emails, custom user fields, and access group assignments.

You cannot export user passwords. Webflow hashes and salts passwords and does not expose the hashes. When migrating users to a new authentication provider (Auth0, Supabase, Memberstack, or similar), all users must complete a password reset on first login at the destination.

Data Portability: Honest Assessment

Webflow is more accessible than many SaaS platforms for data extraction (especially compared to the complexities of exporting data from Notion or Coda), but it is not fully portable by design.

What ports well:

• CMS item content (text, numbers, dates, booleans) via CSV or API
• Product catalog (standard fields only) via CSV
• Rich text as HTML — parseable but requires sanitization
• Page metadata via API
• Form submissions via API

What does not port well:

• Relational data: Reference fields in CSV become disconnected display names. Via the API, you get item IDs — but you need to rebuild the relationships in your target system. Name collisions in referenced collections make CSV-based relationship reconstruction unreliable.
• Site design: The visual design, interactions, and component structure are not extractable in any reusable format. Code export gives you static HTML, not a design system.
• Webflow-specific logic: Conditional visibility rules, CMS filters, custom interactions, and Ecommerce checkout flows have no export representation.
• Image hosting: All asset URLs point to Webflow's CDN. You must download every image and re-host it — including images embedded inside Rich Text HTML strings.
• SEO configuration: 301 redirects, robots.txt customizations, and sitemap settings have limited export paths.
• Localized content: Each export path handles locales differently. Code export only captures the primary locale. CSV only exports the current locale view. The API requires explicit cmsLocaleId parameters per request, and image fields always return the primary locale's asset URL regardless of locale parameter.

Choosing the Right Export Strategy

For any migration involving more than 2–3 collections, the API path is almost always the right call. CSVs work for flat, simple content. The moment you have relational data, multiple collections, or ecommerce history, you need the API.

Migration-Grade Export Checklist

A serious Webflow export is a bundle, not a single artifact.

1. Audit the surface area. List every Collection, static page, form, asset, Ecommerce object, and locale before exporting anything. Use GET /v2/sites/{site_id} to enumerate locales; GET /v2/sites/{site_id}/collections for the full collection inventory.
2. Export site code as a ZIP if you need the static layout and designer-generated markup. (help.webflow.com)
3. Export each CMS Collection as CSV in every locale view you care about (for human-readable backup). (help.webflow.com)
4. Pull Collection schemas and raw item JSON through the API so you keep field types, option values, item states, and stable IDs. (developers.webflow.com)
5. Pull static pages, page metadata, form submissions, and asset inventories through the API or CLI. (developers.webflow.com)
6. Run a locale extraction loop. For each non-primary locale ID, re-run steps 3–4 with cmsLocaleId appended to all item queries.
7. Download every Webflow-hosted file referenced by Collection CSVs, Rich Text HTML, form uploads, or asset listings. Parse Rich Text fields with an HTML parser to catch embedded image URLs that do not appear as standalone image fields.
8. Verify counts for items, pages, forms, assets, and locales before you touch the source site.
9. Package the export in a way another engineer can replay without access to the original Webflow site.

A simple folder structure works:

webflow-export/
  code/
  collections/
    csv/
    schema/
    json/
      primary-locale/
      fr/
      de/
  pages/
  forms/
  assets/
  manifest.json

Common Pitfalls When Exporting Webflow Data

1. Assuming CSV preserves relationships. It does not. Reference fields become display name strings with no reliable join key — especially when referenced items share identical display names.
2. Forgetting to re-host images. Webflow CDN URLs work while your site is active. They may not survive site deletion or plan changes. Images inside Rich Text fields are not surfaced as image fields — they must be found by parsing HTML.
3. Ignoring form data. Form submissions are not in CMS exports. Extract via API before canceling your plan. Uploaded file attachments in form submissions become inaccessible if submissions are deleted.
4. Exporting products without verifying custom fields. The ecommerce CSV export silently drops custom fields. Cross-reference your export against GET /v2/collections/{product_collection_id} to verify field coverage.
5. Not accounting for localized content. If you use Webflow Localization, each locale generates separate CMS data. The API's cmsLocaleId parameter lets you query specific locales — but you must first enumerate locale IDs from the site object, then run extraction per locale per collection.
6. Hitting rate limits without backoff logic. At 60 req/min on a Starter plan, a moderately automated script will get throttled within seconds on large sites. Always implement exponential backoff that respects the Retry-After header, or use the Webflow SDK which handles this natively.
7. Skipping schema capture. CSV gives you data rows. The API gives you the Collection schema with field types, option values, and reference topology. Without the schema, you are guessing when you rebuild fields in the target system. Store GET /v2/collections/:id output alongside your item exports.

When Native Export Is Enough — and When It Is Not

Native Webflow export handles small jobs well: handing off static code, backing up a few Collections, or pulling a one-time form CSV. It stops being enough when you need repeatability, multilingual coverage, relational accuracy, or an auditable backup that another team can actually restore.

Decision boundary: If your data includes only flat collections with no references, fewer than 2,000 items total, and no ecommerce, CSV export is sufficient. Once you add any of the following — reference fields, Rich Text with embedded images, multiple locales, ecommerce orders, or form attachments — the API is required.

If your data includes Rich Text with embedded images, you need a pipeline that parses the HTML, extracts image URLs, downloads assets, re-uploads them to your target platform, and rewrites the URLs in the content. That is where migrations move from "a quick script" to a proper engineering project.

If your requirement is ongoing sync rather than one-time export, tools like Zapier, Make, and Whalesync can automate CMS and Ecommerce actions between Webflow and other systems. Those tools are appropriate for recurring workflows but are not substitutes for migration planning. For jobs that include schema capture, HTML normalization, asset re-hosting, ID remapping, or zero-downtime cutover, a deterministic migration pipeline is the correct approach.