# Mailchimp MCP Server - AI Email Marketing Integration (`engaging_image/mailchimp-mcp-server`) Actor

Connect Claude, ChatGPT, Cursor and other AI agents to Mailchimp via Model Context Protocol (MCP). 56 tools for email
marketing: manage campaigns, automations, audiences, contacts, templates, tags, segments and reports. Full API
coverage, pay-per-use.

- **URL**: https://apify.com/engaging\_image/mailchimp-mcp-server.md
- **Developed by:** [zeel](https://apify.com/engaging_image) (community)
- **Categories:** MCP servers, AI, Agents
- **Stats:** 17 total users, 1 monthly users, 0.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-usage

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Mailchimp MCP Server — Control Your Entire Email Marketing With AI

The most comprehensive **Mailchimp MCP Server** built on the **Model Context Protocol (MCP)**, giving your AI assistant full control over your Mailchimp account. With **56 tools** covering audiences, contacts, campaigns, automations, tags, segments, templates, and analytics, you can manage every aspect of your **email marketing** without ever opening the Mailchimp dashboard.

Works with **Claude**, **ChatGPT**, **Cursor**, **VS Code**, **Windsurf**, **Claude Code CLI**, and any MCP-compatible client. Whether you are building drip campaigns, segmenting audiences, or pulling performance reports, just describe what you need in plain English and your AI assistant handles the rest.

---

### 🎯 What Can It Do?

Talk to your AI assistant and it will interact with Mailchimp for you. Here are real-world examples across every area of email marketing:

- **"Show me all my audiences and their subscriber counts"** — Instantly audit your lists without navigating the dashboard.
- **"Add jane@example.com to my Newsletter audience with the tag VIP and merge fields First Name: Jane, Last Name: Doe"** — Onboard new contacts with full profile data in one sentence.
- **"Create a campaign for the Spring Sale, subject line '50% Off Everything', using my Promo Template, and send a test to me first"** — Build, preview, and validate campaigns conversationally.
- **"What's the open rate and click-through rate on my last 5 campaigns? Compare them side by side"** — Pull detailed analytics and spot trends across campaigns.
- **"Find everyone tagged 'Webinar Attendee' who hasn't opened an email in 90 days and tag them as 'Re-engage'"** — Combine search, filtering, and tagging for targeted list hygiene.
- **"Pause the Welcome Series automation, then show me its email sequence and stats"** — Manage automation workflows and inspect their structure on the fly.
- **"Create a new audience called 'Product Launch 2026', set up merge fields for Company and Job Title, then import these 10 contacts..."** — Spin up fully configured audiences from scratch.
- **"Schedule my Black Friday newsletter for November 28 at 6am EST, and send a test email to the marketing team first"** — Schedule campaigns with confidence after previewing them.
- **"Which links in my last campaign got the most clicks? Break it down by email domain"** — Deep-dive into click performance and domain-level analytics.
- **"Delete all draft campaigns older than 6 months to clean up my account"** — Perform bulk housekeeping tasks that would take dozens of clicks in the UI.

---

### 💡 Why This Actor?

| Advantage | Details |
|-----------|---------|
| **56 Tools — Full CRUD Coverage** | Not a partial integration. Every major Mailchimp feature is covered: audiences, contacts, campaigns, automations, tags, segments, templates, and reports. |
| **Real-Time Data** | Every request hits the live Mailchimp API. No caching, no stale data — you always see the current state of your account. |
| **No Dashboard Required** | Stop context-switching between your AI workflow and the Mailchimp UI. Handle everything through conversation. |
| **Production-Ready MCP Compliance** | Built to the Model Context Protocol spec with Streamable HTTP transport. Works reliably across all major MCP clients. |
| **Secure by Design** | Your API key is encrypted on Apify's SOC 2 certified infrastructure. No data is stored or logged by this Actor. |
| **Pay-Per-Use Pricing** | No subscriptions. You only pay for the API calls you make, starting at $0.003 per operation. Apify's free tier covers light usage entirely. |
| **Instant Deployment** | Three steps, three minutes. No servers to provision, no code to write, no infrastructure to maintain. |

---

### 🛠️ 56 Tools — Full Mailchimp Coverage

#### Account & Templates (7)
| Tool | Description |
|------|-------------|
| `mailchimp_ping` | Health check — verify API key is valid |
| `mailchimp_get_account` | Get account name, plan, total subscribers |
| `mailchimp_list_templates` | List email templates (user, base, gallery) |
| `mailchimp_get_template` | Get details of a specific template |
| `mailchimp_create_template` | Create a new email template with custom HTML |
| `mailchimp_update_template` | Update a template's name or HTML |
| `mailchimp_delete_template` | Delete an email template |

#### Audiences (9)
| Tool | Description |
|------|-------------|
| `mailchimp_list_audiences` | List all audiences with member counts and stats |
| `mailchimp_get_audience` | Get detailed info for a specific audience |
| `mailchimp_create_audience` | Create a new audience with contact info and defaults |
| `mailchimp_update_audience` | Update audience name and settings |
| `mailchimp_delete_audience` | Permanently delete an audience |
| `mailchimp_list_merge_fields` | List merge fields (FNAME, LNAME, custom) on an audience |
| `mailchimp_create_merge_field` | Create a custom merge field on an audience |
| `mailchimp_list_interest_categories` | List interest categories (groups) on an audience |
| `mailchimp_list_interests` | List interests within a category |

#### Contacts / Members (9)
| Tool | Description |
|------|-------------|
| `mailchimp_list_members` | List contacts with filtering by status |
| `mailchimp_get_member` | Get full profile for a contact by email |
| `mailchimp_add_or_update_member` | Add or update a contact (upsert) with merge fields |
| `mailchimp_archive_member` | Archive (soft-delete) a contact |
| `mailchimp_search_members` | Search contacts by name or email across audiences |
| `mailchimp_get_member_activity` | Get recent activity — opens, clicks, bounces |
| `mailchimp_get_member_notes` | Get notes attached to a contact |
| `mailchimp_add_member_note` | Add a note to a contact |
| `mailchimp_delete_member_permanent` | Permanently delete a contact (irreversible) |

#### Campaigns (12)
| Tool | Description |
|------|-------------|
| `mailchimp_list_campaigns` | List campaigns, filter by status/audience/date |
| `mailchimp_get_campaign` | Get full campaign details |
| `mailchimp_get_campaign_report` | Get opens, clicks, bounces, unsubscribes |
| `mailchimp_create_campaign` | Create a new draft campaign with HTML content |
| `mailchimp_update_campaign` | Update subject, title, from name on draft campaigns |
| `mailchimp_send_campaign` | Send a campaign (irreversible) |
| `mailchimp_delete_campaign` | Delete an unsent campaign |
| `mailchimp_schedule_campaign` | Schedule a campaign for future delivery |
| `mailchimp_unschedule_campaign` | Cancel a scheduled campaign |
| `mailchimp_send_test_email` | Send a test/preview email before sending |
| `mailchimp_get_campaign_content` | Get HTML/plain-text content of a campaign |
| `mailchimp_update_campaign_content` | Update campaign HTML or plain-text content |

#### Tags & Segments (7)
| Tool | Description |
|------|-------------|
| `mailchimp_list_tags` | List all tags on an audience |
| `mailchimp_get_member_tags` | Get tags for a specific contact |
| `mailchimp_update_member_tags` | Add or remove tags on a contact |
| `mailchimp_list_segments` | List saved segments on an audience |
| `mailchimp_create_segment` | Create a new segment (static or saved) |
| `mailchimp_update_segment` | Update a segment's name or members |
| `mailchimp_delete_segment` | Delete a segment |

#### Automations (5)
| Tool | Description |
|------|-------------|
| `mailchimp_list_automations` | List all automation workflows |
| `mailchimp_get_automation` | Get details of a specific automation |
| `mailchimp_start_automation` | Start/activate an automation workflow |
| `mailchimp_pause_automation` | Pause all emails in an automation |
| `mailchimp_list_automation_emails` | List emails within an automation workflow |

#### Reports & Analytics (7)
| Tool | Description |
|------|-------------|
| `mailchimp_get_open_details` | Who opened a campaign, when, and how many times |
| `mailchimp_get_click_details` | Which links were clicked, by whom |
| `mailchimp_get_email_activity` | Per-recipient delivery, opens, clicks, bounces |
| `mailchimp_get_top_links` | Click performance by URL |
| `mailchimp_get_domain_performance` | Performance by email domain (gmail, yahoo, etc.) |
| `mailchimp_list_campaign_abuse_reports` | Spam complaints for a campaign |
| `mailchimp_get_campaign_sent_to` | Full recipient list with delivery status |

---

### 🔑 Setup (3 Minutes)

#### Step 1: Get Your Mailchimp API Key

1. Log in to [Mailchimp](https://mailchimp.com)
2. Go to **Account → Extras → API keys**
3. Click **Create A Key**
4. Copy the key — it looks like `abc123def456-us6`

> The part after the dash (e.g., `us6`) is your data center — it is extracted automatically.

#### Step 2: Deploy on Apify

1. Go to this Actor's page on the Apify Store and click **"Try for free"**
2. In the Actor input, paste your Mailchimp API key into the `mailchimpApiKey` field
3. Save and start the Actor — it runs in **Standby mode** and stays available for incoming MCP requests
4. Copy your MCP endpoint URL:
````

https://engaging\_image--mailchimp-mcp-server.apify.actor/mcp

````

#### Step 3: Connect Your MCP Client

Choose your client below and add the configuration. Replace `YOUR_APIFY_TOKEN` with your [Apify API token](https://console.apify.com/settings/integrations).

---

##### Claude Desktop

File: `~/Library/Application Support/Claude/claude_desktop_config.json` (macOS) or `%APPDATA%\Claude\claude_desktop_config.json` (Windows)

```json
{
"mcpServers": {
 "mailchimp": {
   "url": "https://engaging_image--mailchimp-mcp-server.apify.actor/mcp",
   "headers": {
     "Authorization": "Bearer YOUR_APIFY_TOKEN"
   }
 }
}
}
````

##### Cursor

File: `.cursor/mcp.json` in your project root

```json
{
  "mcpServers": {
    "mailchimp": {
      "url": "https://engaging_image--mailchimp-mcp-server.apify.actor/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_APIFY_TOKEN"
      }
    }
  }
}
```

##### VS Code

File: `.vscode/mcp.json` in your project root, or in your User Settings JSON under `mcp.servers`

```json
{
  "mcpServers": {
    "mailchimp": {
      "url": "https://engaging_image--mailchimp-mcp-server.apify.actor/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_APIFY_TOKEN"
      }
    }
  }
}
```

##### Windsurf

File: `~/.windsurf/mcp.json` or via **Settings → MCP Servers**

```json
{
  "mcpServers": {
    "mailchimp": {
      "url": "https://engaging_image--mailchimp-mcp-server.apify.actor/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_APIFY_TOKEN"
      }
    }
  }
}
```

##### Claude Code CLI

```bash
claude mcp add mailchimp \
  --transport http \
  --url "https://engaging_image--mailchimp-mcp-server.apify.actor/mcp" \
  --header "Authorization: Bearer YOUR_APIFY_TOKEN"
```

***

#### 🖥️ Local Development (stdio)

If you prefer to run the server locally for development or testing:

```bash
## Clone and install
git clone https://github.com/engaging_image/mailchimp-mcp-server.git
cd mailchimp-mcp-server
npm install
npm run build

## Run with your Mailchimp API key
export MAILCHIMP_API_KEY="your-key-us6"
node dist/main.js
```

Then configure your MCP client to use stdio transport:

```json
{
  "mcpServers": {
    "mailchimp": {
      "command": "node",
      "args": ["/absolute/path/to/mailchimp-mcp-server/dist/main.js"],
      "env": {
        "MAILCHIMP_API_KEY": "your-key-us6"
      }
    }
  }
}
```

***

### 💰 Pricing

This Actor uses **Pay Per Event** pricing — you only pay for what you use.

| Event Type | Examples | Price per Call |
|------------|----------|---------------|
| **Read** operation | `list_audiences`, `get_campaign`, `search_members`, `get_campaign_report` | **$0.003** |
| **Write** operation | `create_campaign`, `add_or_update_member`, `send_campaign`, `update_member_tags` | **$0.005** |

#### What does this cost in practice?

| Use Case | Monthly Operations | Estimated Cost |
|----------|--------------------|----------------|
| Light usage (check stats, look up contacts) | ~200 reads | **$0.60** |
| Regular marketing workflow | ~500 reads + 200 writes | **$2.50** |
| Heavy automation & management | ~1,000 reads + 500 writes | **$5.50** |

> Apify's **free tier** includes **$5/month** in platform credits — enough for approximately **1,600 read operations** or **1,000 write operations** per month at no cost.

***

### 🔒 Security

| Measure | Details |
|---------|---------|
| **Encrypted Storage** | Your Mailchimp API key is stored encrypted on Apify's SOC 2 Type II certified platform |
| **Pass-Through Architecture** | This server acts as a stateless proxy to Mailchimp's official REST API. No data is stored, cached, or logged by this Actor |
| **HTTPS Everywhere** | All communication between your MCP client, Apify, and Mailchimp uses TLS encryption |
| **Scoped Access** | The server only accesses Mailchimp endpoints you invoke. It does not perform background operations or access data beyond what you request |
| **Apify Token Authentication** | Your MCP endpoint is protected by your Apify API token. Unauthorized requests are rejected before reaching Mailchimp |

> **Best practice**: Use a dedicated Mailchimp API key for this integration so you can revoke it independently without affecting other services.

***

### 🏗️ Who Is This For?

#### Marketing Teams

Manage subscribers, launch campaigns, pull performance reports, and maintain list hygiene — all from your AI assistant. Stop spending time navigating the Mailchimp UI for routine tasks.

#### Sales Teams

Quickly search for contacts across audiences, add new leads with tags and custom fields, and check engagement history. Your CRM workflow stays in one place.

#### Developers & AI Engineers

Integrate Mailchimp into AI agent pipelines, build automated workflows, and prototype email marketing features without writing API integration code.

#### Content Creators & Freelancers

Draft campaigns, manage subscriber lists, and schedule sends conversationally. Focus on writing great content instead of learning dashboard navigation.

#### Agencies

Manage multiple client audiences and campaigns efficiently. Pull cross-campaign analytics and perform bulk operations that would take hours in the dashboard.

***

### ⚙️ Technical Details

| Property | Value |
|----------|-------|
| **MCP Transport** | Streamable HTTP (MCP specification compliant) |
| **Authentication** | Mailchimp API key via HTTP Basic auth internally |
| **API Version** | Mailchimp Marketing API v3 |
| **Runtime** | Node.js 22, TypeScript |
| **Apify SDK** | v3 |
| **Deployment Mode** | Apify Standby — always-on, low-latency responses |
| **Tool Count** | 56 tools across 7 categories |
| **Data Persistence** | None — stateless, no data stored between requests |

***

### ❓ FAQ & Troubleshooting

#### Common Issues

**"Invalid API key"**
Ensure your key follows the format `xxxxx-usXX`. The part after the dash is your Mailchimp data center (e.g., `us6`, `us21`). If you recently regenerated your key, update it in the Actor input on Apify.

**"Timeout" or slow responses**
Some Mailchimp operations take longer on large audiences (50,000+ contacts). Add filters, reduce the `count` parameter, or target specific segments instead of full audience queries.

**"Resource not found"**
Double-check that list, campaign, or automation IDs are correct. Use `mailchimp_list_audiences` or `mailchimp_list_campaigns` first to retrieve valid IDs.

**"Forbidden" or "Compliance" errors**
Some Mailchimp plans restrict certain API features. Ensure your Mailchimp plan supports the operation you are attempting (e.g., automations require a paid plan).

**Tools are not showing up in my MCP client**
Verify the MCP endpoint URL is correct and includes `/mcp` at the end. Check that your Apify token is valid and has not expired. Restart your MCP client after updating configuration.

#### General Questions

**Can I use this with a free Mailchimp account?**
Yes. All tools that correspond to features available on the Mailchimp free plan will work. Some advanced features (certain automation types, comparative reports) may require a paid Mailchimp plan.

**Does this work with Mailchimp Transactional (Mandrill)?**
No. This server uses the Mailchimp Marketing API v3 only. Transactional email via Mandrill requires a separate integration.

**Can multiple people use the same Actor deployment?**
Yes. The Actor runs in Standby mode and can handle concurrent requests. Each user needs their own Apify API token for authentication.

**Is my subscriber data sent to or stored by this Actor?**
No. The Actor is a stateless pass-through. Data flows directly between your MCP client and Mailchimp's API via Apify's infrastructure. Nothing is cached, logged, or persisted.

***

### 📬 Support

If you encounter issues or have feature requests, reach out through the Actor's page on the [Apify Store](https://apify.com/engaging_image/mailchimp-mcp-server). We actively monitor feedback and release updates regularly.

# Actor input Schema

## `mailchimpApiKey` (type: `string`):

Your Mailchimp API key in the format 'xxxxxxxxxxxxxxxx-usXX'. To get it: 1) Log in to Mailchimp, 2) Go to Profile > Extras > API keys, 3) Click 'Create A Key', 4) Copy the full key including the '-usXX' suffix. The data center is extracted automatically.

## Actor input object example

```json
{}
```

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "mailchimpApiKey": ""
};

// Run the Actor and wait for it to finish
const run = await client.actor("engaging_image/mailchimp-mcp-server").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "mailchimpApiKey": "" }

# Run the Actor and wait for it to finish
run = client.actor("engaging_image/mailchimp-mcp-server").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "mailchimpApiKey": ""
}' |
apify call engaging_image/mailchimp-mcp-server --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=engaging_image/mailchimp-mcp-server",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Mailchimp MCP Server - AI Email Marketing Integration",
        "description": "Connect Claude, ChatGPT, Cursor and other AI agents to Mailchimp via Model Context Protocol (MCP). 56 tools for email\n  marketing: manage campaigns, automations, audiences, contacts, templates, tags, segments and reports. Full API\n  coverage, pay-per-use.",
        "version": "2.0",
        "x-build-id": "ZBxiWcOUsPUyyeVL5"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/engaging_image~mailchimp-mcp-server/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-engaging_image-mailchimp-mcp-server",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/engaging_image~mailchimp-mcp-server/runs": {
            "post": {
                "operationId": "runs-sync-engaging_image-mailchimp-mcp-server",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/engaging_image~mailchimp-mcp-server/run-sync": {
            "post": {
                "operationId": "run-sync-engaging_image-mailchimp-mcp-server",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "mailchimpApiKey"
                ],
                "properties": {
                    "mailchimpApiKey": {
                        "title": "Mailchimp API Key",
                        "type": "string",
                        "description": "Your Mailchimp API key in the format 'xxxxxxxxxxxxxxxx-usXX'. To get it: 1) Log in to Mailchimp, 2) Go to Profile > Extras > API keys, 3) Click 'Create A Key', 4) Copy the full key including the '-usXX' suffix. The data center is extracted automatically."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
