How to Export Data from Wix: API Limits, CSV Methods, and What's Locked In

How to Export Data from Wix: API Limits, CSV Methods, and What's Locked In

Wix does not let you export your entire site. There is no "Download Site" button, no portable code bundle, and no database dump. What you can export is structured data — products, contacts, orders, blog posts, CMS collections, and media files — each through a different method with different constraints.

Because Wix operates as a closed-ecosystem site builder with modular applications (Stores, Bookings, Blog, CRM), your data is siloed across different underlying databases. Extracting it requires a hybrid approach: native CSV exports for flat datasets, API integrations for relational data or large volumes, and Velo scripts for custom payloads.

This guide covers every extraction path available, the technical constraints and API limits that will trip you up at scale, and the data transformation steps required to make Wix's proprietary formats usable in other systems.

Version note: Limits and endpoints documented here reflect Wix API v2 and dashboard behavior as of mid-2025. Wix updates its platform frequently — verify current limits against the Wix API Reference before running large-scale extractions.

What Can You Actually Export from Wix?

Wix's export capabilities are limited to specific data types, not entire sites. The platform uses a proprietary, non-exportable architecture for site design, layouts, and styling. Your code, page structure, and visual design stay locked to Wix's infrastructure.

Here is what you can get out:

Anything not in this table — pages, forms, navigation structure, Velo scripts, third-party app data — has no native export path.

Method Selection: When to Use CSV, API, or Velo

Before working through individual export types, use this decision matrix to choose the right extraction path:

How to Export Products, Contacts, and Orders via the Wix Dashboard

Products

From the left-hand menu, navigate to Catalog → Store Products. Click More Actions at the top of the page, then choose Export. Wix generates a CSV containing product names, descriptions, prices, SKUs, inventory levels, and product variants. Images are exported as external URLs pointing to Wix's CDN, not as downloaded files.

Product export constraints:

• Row limits: Maximum 5,000 products per batch. For larger catalogs, filter by category or status and export in multiple batches.
• Variant handling: Product variants (size, color, etc.) are exported as separate rows beneath the parent product. The parent row contains base information; variant rows contain overrides like unique SKUs or price differences. Your target system must parse this parent-child hierarchy.
• Digital files: Actual digital product files are not included in the export. Download these manually from the Media Manager.

Contacts

You can export up to 50,000 site contacts at once. Wix supports three formats: Regular CSV, Google CSV, and Outlook CSV. Choose based on your target CRM.

When exporting in Google CSV format, the following fields are not natively supported by Google and get imported as custom fields: email subscription status, SMS subscription status, language, and created date. Labels are also excluded in this format, and Google caps contacts at 5 email, phone, and address entries per contact.

Member accounts vs. contacts: The Contacts export covers CRM contact records. For site member accounts (users who have logged into your site), export from Members → Site Members. This exports member emails and profile data but not passwords — member passwords are hashed by Wix and are not exposed via any export or API method. When migrating members to a new platform, plan for a bulk password reset campaign on the target system.

Orders

Navigate to the Orders section, select the orders you want, and click Export. Choose the row organization format:

• Item purchased — each line item appears on a separate row (best for inventory or fulfillment analysis)
• Orders — each order on a single row regardless of how many items it contains (best for financial reconciliation)

Payments and Transaction History

For accounting, tax, or financial reconciliation purposes, Wix Payments transaction history is accessible separately from orders. Navigate to Finance → Payments and export the transaction log as CSV. This includes payment amounts, fees, refunds, and payout dates — data not included in the standard Orders export.

How to Export Blog Posts from Wix

Wix blog posts can be exported via the site's RSS feed, available at yoursite.com/blog-feed.xml or yoursite.com/feed.xml. This is the only built-in method for pulling blog content out of Wix without code.

The RSS feed provides post titles, text content, and publication dates. It does not include images, categories, tags, or custom formatting.

To use the RSS method on older blogs:

1. Navigate to https://yoursite.com/blog-feed.xml in your browser
2. Right-click the page and select Save As to download the XML file
3. Import the file into your target platform (WordPress has a built-in RSS importer under Tools → Import)

How to Export Wix CMS Collections

A Wix CMS collection is a structured database table that stores dynamic content — blog posts, testimonials, FAQs, custom records, or any repeater-driven data on your site.

From the left-hand menu, go to CMS → Collections, select the collection, click the More Actions menu at the top right, and choose Export to CSV.

Each collection must be exported individually. There is no dashboard option to batch-export all collections simultaneously.

CMS export constraints:

• Reference fields: If your collection includes reference fields linking to another collection (e.g., an "Author" field in a "Books" collection), the CSV exports the proprietary Wix Item ID for the referenced item, not the human-readable value. To reconstruct the relationship, export both collections and perform a JOIN on the ID field in your database or spreadsheet tool.
• Rich text fields: Rich text content exports as raw HTML or, in many cases, as Draft.js JSON AST (Abstract Syntax Tree). See the conversion section below for how to handle this.

Converting Draft.js AST to Usable HTML

When Wix exports a rich text field as Draft.js JSON, it produces a structure like this:

{
  "blocks": [
    {
      "key": "abc123",
      "text": "This is a paragraph.",
      "type": "unstyled",
      "depth": 0,
      "inlineStyleRanges": [],
      "entityRanges": []
    },
    {
      "key": "def456",
      "text": "This is bold text.",
      "type": "unstyled",
      "inlineStyleRanges": [{"offset": 8, "length": 4, "style": "BOLD"}],
      "entityRanges": []
    }
  ],
  "entityMap": {}
}

To convert this to HTML, use the draft-js-export-html npm package:

import { stateToHTML } from 'draft-js-export-html';
import { convertFromRaw } from 'draft-js';
 
function draftJsToHtml(rawContent) {
  const contentState = convertFromRaw(JSON.parse(rawContent));
  return stateToHTML(contentState);
}

To convert to Markdown instead, substitute draft-js-export-markdown. Inline images and embedded content require additional entity mapping — the basic conversion handles text formatting only.

Extracting Data via the Wix REST API

For datasets exceeding native limits, relational data requiring automated extraction, or recurring sync workflows, the Wix REST API is the right path.

The Wix Data APIs provide access to, organization of, and management of data stored in a Wix site's database. Core API groups include: Data Items (access and query items in collections), Collection Management (create and configure collections), and Operations (background processes and maintenance).

Authentication and Token Lifecycle

Wix uses OAuth 2.0 for API authentication. The flow:

1. Create an app in the Wix Developers Center
2. Request the necessary permission scopes (e.g., WixStores.Read, WixCRM.Read, WixData.Read)
3. Install the app on your Wix site to initiate the OAuth flow
4. Exchange the authorization code for an access token and refresh token

Token lifecycle: Wix access tokens expire after 5 minutes. Refresh tokens are long-lived (typically valid for 30 days but should be treated as expiring). Your extraction script must implement token refresh logic before running long batch operations. A token expiring mid-extraction will return 401 errors that look identical to permission failures, which causes significant debugging confusion.

async function refreshAccessToken(refreshToken, clientId, clientSecret) {
  const response = await fetch('https://www.wix.com/oauth/access', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      grant_type: 'refresh_token',
      client_id: clientId,
      client_secret: clientSecret,
      refresh_token: refreshToken
    })
  });
  const data = await response.json();
  return data.access_token;
}

Key API Endpoints for Data Extraction

• POST /wix-data/v2/items/query — filter, sort, and paginate through collection records
• GET /wix-data/v2/items/{dataCollectionId}/{dataItemId} — retrieve a single item by ID
• POST /wix-data/v2/items/aggregate — perform calculations and grouping on collection data
• GET /wix-data/v2/collections — enumerate all collections on a site
• POST /stores/v2/orders/query — query store orders with cursor pagination
• GET /contacts/v4/contacts — retrieve CRM contacts

Pagination

By default, the query limit is set to 50 items per page. The maximum value that limit() can accept is 1,000. For some Wix app collections, the maximum is lower — the Wix Stores/Product collection caps at 100 items per page.

Cursor-based pagination means the server returns a pointer (cursor) to the last item in the current response. Pass this cursor in the next request to fetch the subsequent page. This prevents data duplication if items are added or removed during extraction. Cursors are time-limited — complete your pagination within a single session or implement a checkpoint mechanism to resume from a saved cursor.

async function fetchAllWixOrders(accessToken) {
  let allOrders = [];
  let cursor = null;
  let hasNext = true;
  let retryDelay = 1000;
 
  while (hasNext) {
    const body = {
      query: {
        limit: 100,
        ...(cursor && { cursorPaging: { cursor } })
      }
    };
 
    const response = await fetch('https://www.wixapis.com/stores/v2/orders/query', {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${accessToken}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify(body)
    });
 
    if (response.status === 401) {
      // Token expired — refresh and retry
      accessToken = await refreshAccessToken(/* credentials */);
      continue;
    }
 
    if (response.status === 429) {
      await new Promise(resolve => setTimeout(resolve, retryDelay));
      retryDelay = Math.min(retryDelay * 2, 60000); // cap at 60 seconds
      continue;
    }
 
    retryDelay = 1000; // reset on success
    const data = await response.json();
    allOrders = allOrders.concat(data.orders);
    cursor = data.metadata?.cursors?.next ?? null;
    hasNext = Boolean(cursor);
  }
 
  return allOrders;
}

What Are the Wix API Rate Limits?

Wix enforces per-minute rate limits on both read and write requests but does not publicly document the exact numeric thresholds. This is one of the most operationally significant gaps in Wix's developer documentation.

What is officially documented:

• Wix limits the number of data requests a site can make per minute. Once a site reaches this quota, subsequent requests during the same minute are not processed and return an error.
• There are separate quotas for read requests and write requests.
• Wix returns HTTP 429 when limits are exceeded.
• No Retry-After header is returned on 429 responses.
• Specific numeric thresholds are not published in official documentation.

Community-reported figures (not officially verified): approximately 3,500 requests per minute total, with a 90-second query processing time budget per minute and a 500 KB per document size limit.

Request Timeouts by Plan

Payload Limits

API Error Codes You Will Encounter

Beyond rate limiting, these are the most common errors during Wix data extraction and what they indicate:

How to Convert Wix Image URIs into Standard URLs

One of the most complex aspects of extracting data from Wix is handling media. Whether you use CSV export or the API, Wix uses a proprietary URI format for image references rather than standard HTTP URLs.

Wix Image URI format: wix:image://v1/{filename}/{original_name}#w={width}&h={height}

Example: wix:image://v1/c837a6_a1b2c3d4e5f6.jpg/my_photo.jpg#w=500&h=500

The base URL for Wix static media is https://static.wixstatic.com/media/.

Transformation logic: Extract the string between wix:image://v1/ and the next forward slash /, then append it to the base URL.

The example above becomes: https://static.wixstatic.com/media/c837a6_a1b2c3d4e5f6.jpg

Here is a JavaScript function that handles this transformation, including edge cases for different file types:

function wixUriToUrl(wixUri) {
  if (!wixUri || typeof wixUri !== 'string') return null;
 
  // Standard image URI
  const imageMatch = wixUri.match(/^wix:image:\/\/v1\/([^\/]+)/);
  if (imageMatch) {
    return `https://static.wixstatic.com/media/${imageMatch[1]}`;
  }
 
  // Video URI
  const videoMatch = wixUri.match(/^wix:video:\/\/v1\/([^\/]+)/);
  if (videoMatch) {
    return `https://video.wixstatic.com/video/${videoMatch[1]}`;
  }
 
  // Document/file URI
  const docMatch = wixUri.match(/^wix:document:\/\/v1\/([^\/]+)/);
  if (docMatch) {
    return `https://static.wixstatic.com/ugd/${docMatch[1]}`;
  }
 
  // Already a standard URL — return as-is
  if (wixUri.startsWith('http')) return wixUri;
 
  return null;
}

Edge cases:

• GIFs use the same wix:image://v1/ scheme and convert identically
• SVGs are stored with .svg extensions and convert the same way, but may require ?format=svg appended to the URL to prevent Wix's CDN from serving a rasterized version
• Videos use wix:video://v1/ and are hosted at video.wixstatic.com rather than static.wixstatic.com
• Documents and PDFs use wix:document://v1/ and resolve to the /ugd/ path

Failing to convert these URIs before migration is the most common cause of broken images on the destination platform.

How to Export Media Files from Wix

Wix does not offer a bulk "download all media" function. You can download files from the Media Manager, but with constraints:

• You can download a single file or select multiple files for batch download
• Only images and videos you have uploaded can be downloaded — free Wix library media and Shutterstock content cannot be downloaded
• Board folder contents cannot be downloaded in bulk; files must be downloaded individually

To download multiple files: hold Command (Mac) or Control (Windows), click the files you want, then click Download.

For product migrations, the product CSV includes image URLs hosted on Wix's CDN rather than actual image files. Write a download script to batch-fetch images from those URLs:

import fs from 'fs';
import fetch from 'node-fetch';
import path from 'path';
 
async function downloadImages(imageUrls, outputDir) {
  fs.mkdirSync(outputDir, { recursive: true });
 
  for (const url of imageUrls) {
    const filename = path.basename(url.split('?')[0]);
    const response = await fetch(url);
    if (!response.ok) {
      console.warn(`Failed to download: ${url}`);
      continue;
    }
    const buffer = await response.buffer();
    fs.writeFileSync(path.join(outputDir, filename), buffer);
    // Respect rate limits — add delay between requests
    await new Promise(resolve => setTimeout(resolve, 100));
  }
}

Using Velo to Build Custom Export Scripts

Velo (formerly Corvid) is Wix's built-in server-side JavaScript environment that lets you write backend code interacting directly with your site's data via the wix-data API. It is the most flexible extraction method for complex or high-volume scenarios.

You can expose a custom HTTP endpoint by creating an http-functions.js file in your Wix backend. This allows external systems to request data in exactly the schema your target platform expects:

import { ok, serverError, response } from 'wix-http-functions';
import wixData from 'wix-data';
 
export async function get_exportCustomData(request) {
  // Validate authorization header
  const authHeader = request.headers['authorization'];
  if (authHeader !== 'Bearer YOUR_SECRET_KEY') {
    return response({ status: 401, body: { error: 'Unauthorized' } });
  }
 
  // Accept pagination parameters from caller
  const page = parseInt(request.query.page) || 0;
  const pageSize = 1000;
 
  try {
    const results = await wixData.query("MyCustomCollection")
      .skip(page * pageSize)
      .limit(pageSize)
      .find();
 
    return ok({
      body: {
        items: results.items,
        totalCount: results.totalCount,
        hasNext: results.hasNext(),
        page: page
      }
    });
  } catch (error) {
    return serverError({ body: { error: error.message } });
  }
}

Velo constraints:

• Query limit: Maximum 1,000 items per wix-data query. Use .hasNext() and .next() to paginate.
• Execution timeout: Backend functions have a hard timeout of 14 seconds. Attempting to pull tens of thousands of records in a single execution will time out. Design endpoints to accept page parameters and manage batching from the client side.
• WD_PERMISSION_DENIED on form collections: Form submission collections frequently throw this error even when using suppressAuth: true. This is a known platform limitation — these collections have additional permission restrictions that are not overridable in Velo. Workaround: use the REST API with admin-level OAuth credentials instead.
• No persistent storage between executions: Velo backend functions are stateless. You cannot checkpoint a long-running extraction within a single Velo function — manage state externally.

Benchmarking Extraction Time at Scale

As a planning reference for extraction projects:

These figures assume single-threaded requests at the 1,000-item page limit. Parallelizing collection exports can reduce time proportionally, but increases 429 risk. For Business Elite plans with the 10-second timeout tier, larger page sizes on complex queries are feasible.

Wix CMS Storage Limits by Plan

The total number of CMS items you can store (and therefore need to export) varies by plan. These limits are site-wide across all collections combined, not per collection:

The per-item 512 KB limit covers all field types combined — text, numbers, URLs, tags — but excludes media (images and videos are stored separately and referenced by URI).

A single Wix site can hold up to 1,000 data collections.

For sites on Light or Core plans, a manual CSV export per collection is viable. On Business or Enterprise plans with tens of thousands of items across dozens of collections, the REST API is the only practical extraction path.

What Wix Will Not Let You Export

Wix sites are built using proprietary technology that cannot be exported to HTML, CSS, or any standard web format. The editor translates content and layout choices into Wix's closed JSON schema, rendered server-side through a proprietary templating engine. There is no mechanism to access the compiled output.

You cannot export:

• Page layouts and design — no HTML/CSS export exists; rebuild your frontend entirely on the target platform
• Site navigation and menu structure — must be manually recreated
• Forms and form submissions — limited API access; no dashboard export path; WD_PERMISSION_DENIED is common
• Wix App Market third-party data — data stored in App Market integrations may have no export path; contact each app vendor individually
• Velo/Corvid custom code — code is non-portable due to tight dependency on Wix-specific APIs and the wix-* module ecosystem
• SEO settings and redirects — must be manually documented and recreated in the target platform's redirect rules
• Member passwords — hashed server-side; not accessible via any export or API
• Wix Automations — automated workflows (e.g., "Send email when user signs up") cannot be exported; logic must be manually mapped to equivalent tools on the target platform

Webhook Payload Schema and Continuous Data Sync

For active businesses, running a Wix migration while the site stays live requires capturing new data generated during the migration window. Implement a continuous sync using Wix webhooks alongside historical API extraction.

Wix Webhook Payload Structure

Wix webhooks send a POST request to your endpoint when a subscribed event occurs. The payload follows this structure:

{
  "data": "{\"createdEvent\":{\"entityAsJson\":\"{...}\"}}",
  "entityId": "order-id-here",
  "entityEventSequence": "1",
  "entityFqdn": "wix.ecommerce.v1.order",
  "eventTime": "2025-01-15T10:30:00.000Z",
  "id": "webhook-event-uuid",
  "instanceId": "site-instance-id",
  "slug": "created"
}

Note that data is a double-encoded JSON string — you must parse it twice. The inner entityAsJson is also a JSON string that must be parsed a third time to access the actual entity fields. This triple-encoding is a consistent pattern across all Wix webhook types.

Webhook Signature Validation

Wix signs webhook payloads using a public key for verification. Validate signatures before processing:

import crypto from 'crypto';
 
function validateWixWebhook(payload, signature, wixPublicKey) {
  const verifier = crypto.createVerify('RSA-SHA256');
  verifier.update(payload);
  return verifier.verify(wixPublicKey, signature, 'base64');
}

Zero-Downtime Migration Pattern

1. Timestamp your baseline: Record the exact timestamp when you begin historical extraction
2. Run historical extraction: Pull all data via REST API up to that timestamp
3. Enable webhooks: Configure webhooks for Order Created, Contact Created, Inventory Updated, and any other relevant events
4. Route to intermediary: Point webhooks to a serverless function that transforms Wix JSON to your target system's schema and pushes via API
5. Reconcile overlap: After historical import completes, process any webhook events that fired during the extraction window
6. Verify and cutover: Confirm record counts match before switching DNS

A Practical Extraction Checklist

When planning a migration off Wix, work through data extraction in this order:

1. Export CMS collections — CSV from dashboard for each collection; note which collections contain reference fields requiring post-processing
2. Export products — CSV from Store Products (max 5,000 per batch; filter by category for larger catalogs)
3. Export contacts — CSV from Contacts dashboard, choosing format for target CRM (max 50,000 per export)
4. Export orders — CSV from Orders, using per-item format for best compatibility with accounting and fulfillment systems
5. Export members — CSV from Members dashboard; plan for bulk password reset on target platform
6. Export transactions — CSV from Finance → Payments for accounting/tax records
7. Export blog content — RSS feed if available (older blogs only), or CMS collection export for newer blogs
8. Export bookings and events — CSV from respective dashboards
9. Download media — Multi-select from Media Manager; batch-download product images from CSV URLs using a script
10. Transform proprietary formats — Convert wix:image://v1/ URIs to standard HTTP URLs; convert Draft.js JSON AST to HTML or Markdown
11. Set up continuous sync — Configure webhooks for new data generated during the migration window; implement payload signature validation
12. Document non-exportable items — Screenshot navigation, record form field configurations, note all SEO meta settings, catalog 301 redirect mappings

What Wix Locks In Permanently

A complete migration audit should include an explicit inventory of data and functionality that has no export path and must be rebuilt from scratch on the target platform:

This table represents the minimum rebuild scope for any Wix migration. Budget rebuild time proportional to the complexity of your current Wix Automations, form count, and Velo code volume — these are typically the most time-consuming items to reconstruct.