Export your Mailchimp data with the API and you get something the dashboard export doesn't give you: a repeatable, scriptable backup you can run whenever you like and feed straight into another system. With Bending Spoons agreeing on November 19, 2026 to buy Mailchimp from Intuit (closing is expected in early 2027), plenty of teams want a complete copy of their data on their own disk. Nothing has changed yet. This is just good practice.

This guide walks through a single Node.js script that:

  1. lists every audience in the account,
  2. exports every contact in each audience, by status (subscribed, unsubscribed, cleaned and the rest), with merge fields and tags,
  3. saves the HTML of every sent campaign, and
  4. optionally loads your subscribed contacts into Cresca, an AI email marketing and transactional email platform, through its contacts API.

Mailchimp API details below come from Mailchimp's developer documentation, checked on November 20, 2026. For the business side of the deal, see Bending Spoons acquires Mailchimp: what it means for you.

What the Mailchimp API export covers (and what it doesn't)

Data API Dashboard export
Contacts with status, merge fields and tags Yes: GET /lists/{list_id}/members Yes, one CSV per status
Merge field definitions Yes: GET /lists/{list_id}/merge-fields Column headers only
Sent campaign HTML Yes: GET /campaigns/{campaign_id}/content Yes, in the account data export
Template HTML No documented endpoint returns full template HTML Custom-coded templates only, or the account data export
Open and click history Reports endpoints Campaign report exports

For templates, use the dashboard: Account, Settings, Manage my data, Export Data puts the HTML of your templates in a Templates folder. You can run that export once every 24 hours.

Step 1: Get a Mailchimp API key and your server prefix

In Mailchimp, open your profile, then Extras and API keys, and create a key. A Mailchimp API key has full access to the account and doesn't expire, so treat it like a password, keep it in an environment variable and delete it when you're done.

The key ends in a dash and your data centre, for example -us6. That suffix is the server prefix in the API URL: https://us6.api.mailchimp.com/3.0.

Authentication is HTTP Basic, with any string as the username and the API key as the password. Bearer tokens work too.

export MAILCHIMP_API_KEY="your-key-us6" # Optional, for step 5: export CRESCA_API_KEY="cr_live_..." 

Step 2: A small Mailchimp API client with pagination

Mailchimp's list endpoints return at most 1,000 items per call. You page through them with count and offset, and each response includes total_items. The API allows 10 simultaneous connections per user and returns 429 TooManyRequests above that. This script makes one request at a time, so it stays well under the limit, and it retries on 429 just in case.

// export-mailchimp.mjs (Node.js 18 or later, no dependencies) import { mkdir, writeFile, appendFile } from 'node:fs/promises'; const KEY = process.env.MAILCHIMP_API_KEY; if (!KEY || !KEY.includes('-')) throw new Error('Set MAILCHIMP_API_KEY (it ends in -usN)'); const SERVER = KEY.split('-').pop(); // e.g. "us6" const BASE = `https://${SERVER}.api.mailchimp.com/3.0`; const AUTH = 'Basic ' + Buffer.from(`export:${KEY}`).toString('base64'); const OUT = './mailchimp-export'; const sleep = (ms) => new Promise((r) => setTimeout(r, ms)); async function mc(path, params = {}) { const url = new URL(BASE + path); for (const [k, v] of Object.entries(params)) url.searchParams.set(k, String(v)); for (let attempt = 1; ; attempt++) { const res = await fetch(url, { headers: { Authorization: AUTH } }); if (res.status === 429 && attempt <= 5) { await sleep(attempt * 2000); continue; } if (!res.ok) throw new Error(`Mailchimp ${res.status} on ${path}: ${await res.text()}`); return res.json(); } } // Yields every item of a paginated collection, 1,000 at a time. async function* all(path, key, params = {}) { const count = 1000; for (let offset = 0; ; offset += count) { const page = await mc(path, { ...params, count, offset }); yield* page[key]; if (offset + count >= page.total_items) return; } } 

Step 3: Export every contact, by status

A full backup needs more than your subscribers. The unsubscribed and cleaned contacts are your record of who must not get marketing email again, so the script exports every status Mailchimp documents for this endpoint. Each audience gets a JSON Lines file with the complete member objects, so nothing is lost, plus a simple CSV of subscribed contacts for importing elsewhere.

const STATUSES = ['subscribed', 'unsubscribed', 'cleaned', 'pending', 'transactional', 'archived']; const slug = (s) => s.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, ''); const csvCell = (v) => `"${String(v ?? '').replace(/"/g, '""')}"`; async function exportAudiences() { await mkdir(`${OUT}/audiences`, { recursive: true }); const subscribedByAudience = {}; for await (const list of all('/lists', 'lists')) { const name = slug(list.name) || list.id; const dir = `${OUT}/audiences/${name}`; await mkdir(dir, { recursive: true }); // Merge field definitions (FNAME, LNAME, and your custom fields) const fields = []; for await (const f of all(`/lists/${list.id}/merge-fields`, 'merge_fields')) fields.push(f); await writeFile(`${dir}/merge-fields.json`, JSON.stringify(fields, null, 2)); const subscribed = []; for (const status of STATUSES) { const file = `${dir}/${status}.jsonl`; await writeFile(file, ''); let n = 0; for await (const m of all(`/lists/${list.id}/members`, 'members', { status })) { await appendFile(file, JSON.stringify(m) + '\n'); n++; if (status === 'subscribed') { subscribed.push({ email: m.email_address, first_name: m.merge_fields?.FNAME || '', last_name: m.merge_fields?.LNAME || '', tags: (m.tags || []).map((t) => t.name).join('|'), }); } } console.log(`${list.name}: ${n} ${status}`); } const header = 'email,first_name,last_name,tags'; const rows = subscribed.map((r) => [r.email, r.first_name, r.last_name, r.tags].map(csvCell).join(',')); await writeFile(`${dir}/subscribed.csv`, [header, ...rows].join('\n')); subscribedByAudience[list.name] = subscribed; } return subscribedByAudience; } 

On a very large audience (hundreds of thousands of contacts), consider Mailchimp's batch operations endpoint (POST /batches) instead. A batched GET without a count pages through the whole collection on Mailchimp's side, and you download the results as a gzipped tar file.

Step 4: Save the HTML of every sent campaign

GET /campaigns lists campaigns, and GET /campaigns/{campaign_id}/content returns the campaign's html and plain_text. That gives you a permanent archive of every email you've sent, including the drag-and-drop designs you can't export as templates.

async function exportCampaigns() { await mkdir(`${OUT}/campaigns`, { recursive: true }); let n = 0; for await (const c of all('/campaigns', 'campaigns', { status: 'sent' })) { const content = await mc(`/campaigns/${c.id}/content`); const date = (c.send_time || '').slice(0, 10) || 'unsent'; const base = `${OUT}/campaigns/${date}-${slug(c.settings?.subject_line || c.id)}-${c.id}`; if (content.html) await writeFile(`${base}.html`, content.html); if (content.plain_text) await writeFile(`${base}.txt`, content.plain_text); n++; } console.log(`Saved ${n} sent campaigns`); } 

Step 5: Load your subscribers into Cresca (optional)

If you want to try a different tool while your Mailchimp account keeps running, the same script can load your subscribed contacts into Cresca. Cresca's POST /contacts endpoint takes up to 1,000 contacts per request, creates the list if it doesn't exist, and never duplicates a contact. Imports are limited to 120 requests per 15 minutes, which is up to 120,000 contacts.

Only subscribed contacts are sent. Unsubscribed and cleaned addresses stay in your backup, where they belong.

const CRESCA = 'https://api.cresca.xyz/api/v1'; async function importToCresca(listName, contacts) { for (let i = 0; i < contacts.length; i += 1000) { const chunk = contacts.slice(i, i + 1000).map((c) => ({ email: c.email, ...(c.first_name && { first_name: c.first_name }), ...(c.last_name && { last_name: c.last_name }), })); const res = await fetch(`${CRESCA}/contacts`, { method: 'POST', headers: { Authorization: `Bearer ${process.env.CRESCA_API_KEY}`, 'Content-Type': 'application/json', }, body: JSON.stringify({ list_name: listName, contacts: chunk }), }); if (!res.ok) throw new Error(`Cresca ${res.status}: ${await res.text()}`); const { summary } = await res.json(); console.log(`${listName}: +${summary.created} new, ${summary.updated} updated, ${summary.rejected} rejected`); } } // Run everything const audiences = await exportAudiences(); await exportCampaigns(); if (process.env.CRESCA_API_KEY) { for (const [name, contacts] of Object.entries(audiences)) { await importToCresca(`${name} (from Mailchimp)`, contacts); } } console.log(`Done. Files are in ${OUT}`); 

Run it:

node export-mailchimp.mjs 

You end up with a folder like this:

mailchimp-export/ audiences/ newsletter/ merge-fields.json subscribed.jsonl unsubscribed.jsonl cleaned.jsonl pending.jsonl transactional.jsonl archived.jsonl subscribed.csv campaigns/ 2026-11-14-black-friday-early-access-abc123.html 2026-11-14-black-friday-early-access-abc123.txt 

To get a Cresca API key, create a free account (30 days, 250 contacts, 1,000 emails, no credit card) and create a key with full access. The add contacts API reference has the full request and response format. Cresca's contacts API stores email, first name and last name. Your other Mailchimp merge fields stay in the JSON backup.

Step 6: Send your first campaign from Cresca

Once the import finishes, your Mailchimp audience is waiting in Cresca. Here's how to send to it, from sign-up to report:

1. Verify your sending domain

Open Sending Domains, add your domain and add the DNS records Cresca shows (ownership, DKIM and MAIL FROM/SPF), each with a copy button. When the domain shows as Verified, add your sender address.

2. Find your imported list

Open Contacts, then Contact Lists. The script named each list after its Mailchimp audience, with "(from Mailchimp)" at the end.

Contact Lists in Cresca, with a card for each list showing its contact count

Contact Lists in Cresca (sample data).

3. Describe the email to Cresca AI

Open Templates and type a brief in the Message Cresca AI box, for example "Welcome email for new subscribers with the code HELLO10 for 10% off". The AI agent designs the whole email in your brand, and you can refine it in the same conversation or in the editor.

Cresca's Email studio turning a one-line brief into a complete, on-brand email

Cresca AI designing a welcome email from one brief (sample brand).

4. Create the campaign

In Campaigns, choose New Campaign. Pick your sender, the template and the imported list, then send now or schedule it.

The Campaigns page in Cresca with a new campaign being scheduled

Scheduling a campaign in Cresca (sample data).

5. Check the results

on the dashboard or in Delivery logs: deliveries, bounces, complaints and unsubscribes. Hard bounces and complaints are suppressed automatically.

What to do with the backup

  • Store it somewhere safe and private. It contains personal data, so treat it under the same privacy rules as your live list.
  • Re-run it before any big change, such as a plan change, a migration or the deal closing.
  • Keep the unsubscribed and cleaned files for as long as you keep sending email. They're how you avoid emailing people who opted out.
  • Delete the API key when you're finished, because Mailchimp keys never expire on their own.

Why developers like Cresca

If your product sends both marketing and transactional email, Cresca puts them in one account, on your own domain:

  • a REST API for transactional email at https://api.cresca.xyz/api/v1, included on every plan, with templates, batches of up to 100 emails, scheduled sends and idempotency keys;
  • an AI agent that designs your marketing campaigns from a one-line brief, so nobody on the team has to hand-code newsletter HTML;
  • guided SPF and DKIM setup, one-click unsubscribe and automatic bounce and complaint suppression.

Email automation workflows are launching soon in Cresca. Campaigns, the AI agent and the transactional API are available today. Start with the quickstart, or try Cresca free for 30 days.

FAQ

Can I export Mailchimp contacts with the API?

Yes. GET /lists/{list_id}/members returns up to 1,000 contacts per call with count and offset for paging, and a status filter for subscribed, unsubscribed, cleaned, pending, transactional and archived contacts.

Does the Mailchimp API export templates?

No documented endpoint returns a template's full HTML. GET /templates/{template_id}/default-content returns only the editable sections. Use the account data export, which includes template HTML files, or export custom-coded templates from the dashboard.

What are the Mailchimp API rate limits?

Mailchimp allows 10 simultaneous connections per user and times out calls after 120 seconds. Going over the connection limit returns a 429 error.

Is my Mailchimp data changing because of the Bending Spoons acquisition?

No change has been announced. The deal is expected to close in early 2027, and neither company has said anything about plans, prices or data. A backup simply means you have a complete copy whatever happens.