Provides tools for managing Mailchimp audiences, campaigns, templates, subscribers, and reports, as well as universal tools to access the full Mailchimp Marketing API (282 endpoints).
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@mailchimp-mcp list my Mailchimp audiences"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
12 tools. 282 endpoints. Zero bloat.
A hybrid Mailchimp MCP server built on the architecture Cloudflare pioneered for their own API: instead of drowning the model in 50+ tool definitions, we give it 10 fast native tools for the email workflow you actually use, plus two universal tools that unlock the entire Mailchimp Marketing API on demand.
There are half a dozen Mailchimp MCP servers on GitHub. They all do the same thing: expose 40–50+ individual tools, one per API operation. list_campaigns, get_campaign, create_campaign, delete_campaign, list_audiences, get_audience, add_member, update_member... on and on.
Every single one of those tool definitions gets loaded into the LLM's context window on every turn of every conversation — even when you're talking about something completely unrelated to Mailchimp. That's thousands of tokens burned before the model even starts thinking about your question.
This is the context flooding problem. Cloudflare ran the math on their own API (2,500+ endpoints) and found that exposing everything as native MCP tools would consume 1.17 million tokens per turn. Even aggressively pruned, it was 244,000 tokens. Their solution was radical: collapse the entire API surface into just two tools — search and execute — and let the model discover what it needs on the fly. They called it Code Mode, and it reduced the footprint to ~1,000 tokens.
Related MCP server: Mailchimp MCP Server
Pure Code Mode is elegant, but it has a tradeoff. For the stuff you do every single day — list your audiences, create a campaign, check open rates — forcing the model to search the API catalog first adds an unnecessary round trip. You already know what you want. The model should too.
The deeper analysis of real-world API traffic reveals a consistent pattern: a Pareto distribution. The vast majority of what people actually do hits a tiny subset of endpoints. The long tail is everything else.
So we built a hybrid:
Layer 1: 10 native tools for the mass email workflow. These are purpose-built, zero-overhead, and handle the 80% case. Creating a campaign, sending it, checking the report — one tool call, done. No searching, no discovering, no extra turns.
Layer 2: search + execute for everything else. An embedded catalog of all 282 Mailchimp API endpoints, generated from the official OpenAPI spec. The model searches to discover endpoints, then executes to call them. Automations, e-commerce, landing pages, file management, batch operations — it's all there without adding a single extra tool definition.
The result: 12 tool schemas in your context window instead of 50+. Fast for the common case, omnipotent for the edge case.
Other Mailchimp MCPs | mailchimp-mcp | |
Tools in context | 40–50+ | 12 |
API coverage | Partial | Full (282 endpoints) |
Token cost per turn | High (all schemas always loaded) | Minimal |
Common tasks | Same overhead as rare ones | Optimized native tools |
New Mailchimp endpoints | Requires code changes | Already covered via execute |
Log in to Mailchimp
Go to Profile → Extras → API keys
Click Create A Key
Copy the key — it looks like: xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx-usXX
The suffix after the dash (us12, us6, etc.) is your data center. The server extracts it automatically.
Add to your ~/.claude.json (or project-level .claude.json) under mcpServers:
{
"mcpServers": {
"mailchimp": {
"type": "stdio",
"command": "npx",
"args": ["-y", "mailchimp-mcp"],
"env": {
"MAILCHIMP_API_KEY": "your-api-key-us12"
}
}
}
}Restart Claude Code for the server to connect. You'll see mailchimp in your MCP server list, and the tools will appear as mcp__mailchimp__list_audiences, mcp__mailchimp__search, etc.
Add to ~/Library/Application Support/Claude/claude_desktop_config.json (macOS) or %APPDATA%\Claude\claude_desktop_config.json (Windows):
{
"mcpServers": {
"mailchimp": {
"command": "npx",
"args": ["-y", "mailchimp-mcp"],
"env": {
"MAILCHIMP_API_KEY": "your-api-key-us12"
}
}
}
}Restart Claude Desktop. The Mailchimp tools will appear in the tools menu (hammer icon).
The config pattern is the same — npx -y mailchimp-mcp as the command, with your API key in the env block. Consult your client's MCP documentation for where to place the config.
If you cloned the repo instead of using npx:
{
"mcpServers": {
"mailchimp": {
"command": "node",
"args": ["/path/to/mailchimp-mcp/dist/index.js"],
"env": {
"MAILCHIMP_API_KEY": "your-api-key-us12"
}
}
}
}These 10 tools cover the complete mass email lifecycle — no searching required:
Tool | What it does |
| List all audiences with subscriber counts, open rates, click rates |
| Browse campaigns by status (draft, sent, scheduled, etc.) |
| Create a new email campaign with subject, from name, reply-to |
| Set HTML content or assign a template to a campaign |
| Schedule a campaign for a future send time |
| Send a campaign immediately |
| Get opens, clicks, bounces, unsubscribes for a sent campaign |
| Browse your email templates |
| Find subscribers by name or email across all audiences |
| Add/update a subscriber with auto MD5 hash + optional tags |
1. list_audiences() → find your audience ID
2. list_templates(type: "user") → find a template
3. create_campaign(list_id, subject, from_name, reply_to) → get a campaign_id back
4. update_campaign_content(campaign_id, template_id: 123) → set the email content
5. send_campaign(campaign_id) → fire it off
6. get_campaign_report(campaign_id) → check opens & clicksadd_or_update_member(
list_id: "abc123",
email: "jane@example.com",
merge_fields: { "FNAME": "Jane", "LNAME": "Doe" },
tags: ["VIP", "2026-spring"]
)The MD5 subscriber hash that Mailchimp requires is computed automatically from the email — you never have to think about it.
For anything beyond the 10 native tools — automations, e-commerce, segments, webhooks, landing pages, file uploads, batch operations, and hundreds more — use search and execute.
Call with no arguments to see the full API map:
> search()
Mailchimp Marketing API — 282 endpoints across 29 categories
lists (66) — Audiences, members, segments, merge fields, tags, webhooks, signups
ecommerce (60) — Stores, products, orders, carts, customers
campaigns (22) — Email campaigns — create, schedule, send, content, feedback
reports (22) — Campaign performance reports — opens, clicks, bounces
automations (18) — Marketing automation workflows and triggered emails
...Narrow it down:
> search(tag: "automations")
> search(query: "segment members")
> search(query: "merge fields", method: "POST")> execute(method: "GET", path: "/ping")
{ "health_status": "Everything's Chimpy!" }
> execute(method: "GET", path: "/automations", params: { "count": "5" })
> execute(method: "POST", path: "/lists/{list_id}/segments", body: {
"name": "Active subscribers",
"static_segment": ["email1@test.com", "email2@test.com"]
})Category | Endpoints | Description |
lists | 66 | Audiences, members, segments, merge fields, tags |
ecommerce | 60 | Stores, products, orders, carts, customers |
campaigns | 22 | Create, schedule, send, content, feedback |
reports | 22 | Opens, clicks, bounces, email activity |
automations | 18 | Workflows, triggered emails, queues |
reporting | 12 | Advanced analytics |
fileManager | 11 | File and image uploads |
landingPages | 8 | Landing page management |
templates | 6 | Email templates |
verifiedDomains | 5 | Domain verification for sending |
connectedSites | 5 | Connected e-commerce sites |
batchWebhooks | 5 | Batch webhook configurations |
campaignFolders | 5 | Organize campaigns into folders |
templateFolders | 5 | Organize templates into folders |
batches | 4 | Batch operations for bulk API calls |
conversations | 4 | Conversation tracking and messages |
contacts | 4 | Contact management |
audiences | 4 | Audience management |
Surveys | 3 | Survey management |
accountExports | 2 | Account data exports |
authorizedApps | 2 | OAuth authorized applications |
facebookAds | 2 | Facebook ad campaigns |
accountExport | 1 | Export account data |
activityFeed | 1 | Activity feed events |
customerJourneys | 1 | Customer journey automations |
ping | 1 | API health check |
root | 1 | API root and account info |
searchCampaigns | 1 | Search campaigns by query |
searchMembers | 1 | Search audience members by query |
git clone https://github.com/livemau5/mailchimp-mcp.git
cd mailchimp-mcp
npm install
npm run build
# Regenerate the API catalog from the latest Mailchimp spec
npm run generate-catalog
# Run in development mode
MAILCHIMP_API_KEY=your-key-us12 npm run devsrc/
index.ts Entry point — server setup, tool registration, stdio transport
types.ts CatalogEntry interface
utils.ts Data center extraction, URL building, auth, response formatting
api-catalog.ts Auto-generated catalog of all 282 endpoints
tools/
native.ts 10 native tools for the mass email workflow
search.ts Search tool — text/tag/method filtering over the catalog
execute.ts Execute tool — HTTP client with automatic Basic Auth
scripts/
generate-catalog.ts Parses official Mailchimp OpenAPI spec into api-catalog.tsMIT
Add a new subscriber or update an existing one (upsert). Automatically computes the required subscriber hash from the email. Returns compact confirmation by default — set verbose=true for full response.
| Name | Required | Description | Default |
|---|---|---|---|
| tags | No | Tags to add, e.g., ["VIP", "2026-campaign"] | |
| Yes | Subscriber email address | ||
| status | No | Subscription status (default: subscribed for new, unchanged for existing) | |
| list_id | Yes | Audience/list ID | |
| verbose | No | Return full API response instead of compact summary (default false) | |
| merge_fields | No | Merge fields like { "FNAME": "Jane", "LNAME": "Doe" } |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations exist, so the description carries the full transparency burden. It usefully discloses automatic hash computation and the compact vs verbose response behavior, but omits side effects, permissions, or error conditions. This is more than a tautology but still minimal for a mutation tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences front-load the purpose and then give essential behavioral details. Every sentence earns its place with zero fluff or repetition.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the 6-param schema with full descriptions and no output schema, the description covers the core upsert behavior and response format, making it sufficiently complete for typical use. It doesn't cover edge cases or prerequisites, but the schema mitigates that.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% coverage for all parameters, so the description adds little beyond re-stating the verbose option already documented in the schema. It provides no extra semantic detail about parameters themselves.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states 'Add a new subscriber or update an existing one (upsert)' with a specific verb and resource, and the 'upsert' term uniquely distinguishes it from sibling tools like search_members. It leaves no ambiguity about what the tool does.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description clearly implies when to use it: for adding or updating subscribers. However, it doesn't explicitly contrast it with alternatives like search_members, so it stops short of explicit when-not and alternative guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Create a new email campaign. Returns the campaign ID for use with update_campaign_content and send/schedule. Returns compact confirmation by default — set verbose=true for full response.
| Name | Required | Description | Default |
|---|---|---|---|
| title | No | Internal campaign title (defaults to subject) | |
| list_id | Yes | Audience/list ID to send to | |
| subject | Yes | Email subject line | |
| verbose | No | Return full API response instead of compact summary (default false) | |
| reply_to | Yes | Reply-to email address | |
| from_name | Yes | The 'from' name on the email | |
| segment_id | No | Segment ID to send to (subset of audience) | |
| preview_text | No | Preview text shown in inbox |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the burden. It discloses response behavior (compact confirmation by default, verbose=true for full response) and the return of a campaign ID. However, it does not mention permissions, side effects beyond creating a resource, or the fact that sending is separate, leaving some transparency gaps.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, front-loaded with the primary purpose, followed by the return value and a key option. Every sentence contributes value with no redundancy or filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description covers the workflow context (creates an initial campaign, returns ID for next steps) and the default response behavior, which is critical given no output schema. It does not explain every parameter, but the schema already does. A small gap is not explicitly stating that this only creates a draft and does not send, but the flow reference to send/schedule makes it implicit.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema fully documents all parameters. The description adds minor clarification about the verbose flag (already in schema) and mentions the campaign ID return, but does not provide additional parameter meaning beyond what schema properties already offer.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description starts with a specific verb and resource: 'Create a new email campaign.' It also distinguishes from siblings by stating it returns a campaign ID for use with update_campaign_content and send/schedule, clarifying the tool's role in the campaign creation flow.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies when to use this tool by referencing the campaign ID for subsequent update/send steps, but does not explicitly state exclusions like 'use update_campaign_content for existing campaigns.' Context is clear enough for selection, but no explicit alternatives are named.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Execute any Mailchimp Marketing API call. Use the search tool first to discover available endpoints and their parameters. Write operations return compact summaries by default — set verbose=true for full response.
| Name | Required | Description | Default |
|---|---|---|---|
| body | No | Request body for POST/PATCH/PUT requests (JSON object) | |
| path | Yes | API path (e.g., "/lists", "/campaigns/{campaign_id}", "/lists/{list_id}/members") | |
| method | Yes | HTTP method | |
| params | No | Query parameters (e.g., { "count": "10", "offset": "0", "status": "subscribed" }) | |
| verbose | No | Return full API response. By default, write operations (POST/PATCH/PUT/DELETE) return compact summaries to save context. Set verbose=true to get the full response. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must carry the safety disclosure burden. It only mentions compact summaries for write operations, but omits warnings about destructive operations (DELETE/PATCH), rate limits, error handling, or authorization requirements. This is insufficient for a tool that can execute arbitrary API calls.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences, front-loaded with the core purpose, and every clause provides actionable guidance. There is no filler or redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
This is a generic executor with high complexity, no annotations, and no output schema. The description only covers search-first usage and verbose summaries, leaving critical gaps around destructive operations, error handling, pagination, and how this tool relates to the specific sibling tools.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% with meaningful descriptions for all five parameters (path examples, method enum, body/params types, verbose behavior). The description adds no semantic value beyond the schema, so the baseline 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly identifies the tool as a generic Mailchimp Marketing API executor with 'Execute any Mailchimp Marketing API call.' It distinguishes itself from specific sibling tools by being the catch-all, and explicitly references the search tool for discovery, making its role unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
It explicitly instructs to use the search tool first for endpoint discovery, which implies this tool is for execution after discovery. It also notes the default compact summaries for write operations, but does not explicitly direct users to common sibling tools for standard operations.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get performance report for a sent campaign: opens, clicks, bounces, unsubscribes, and more.
| Name | Required | Description | Default |
|---|---|---|---|
| campaign_id | Yes | Campaign ID |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It discloses that the tool returns metrics (opens, clicks, bounces, unsubscribes) and implies read-only behavior via 'Get', but it does not explicitly confirm side-effect-free operation, authentication requirements, or error handling for unsent campaigns.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single concise sentence, front-loaded with the core action and resource, followed by a list of report contents. No wasted words or redundant information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple one-parameter tool with no output schema, the description adequately explains the purpose and gives a glimpse of return data. It lacks details on output structure and possible error states, but these are less critical given the tool's simplicity and the clarity of 'performance report'.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% for campaign_id, but the description adds meaningful constraint: the campaign must be 'sent'. This clarifies that only sent campaigns are valid inputs, which is not present in the schema description.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('Get') and resource ('performance report for a sent campaign') and enumerates the report contents (opens, clicks, bounces, unsubscribes). It clearly distinguishes this reporting tool from sibling tools like list_campaigns or send_campaign.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies when to use the tool (for performance reports on a sent campaign) but does not explicitly state alternatives, exclusions, or when not to use it. No comparison to sibling tools or prerequisite conditions beyond 'sent campaign' is provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List all audiences (lists) with subscriber counts and key stats.
| Name | Required | Description | Default |
|---|---|---|---|
| count | No | Number of audiences to return (default 10) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must carry full behavioral disclosure. It mentions output fields but omits critical behavior such as default/maximum count, pagination, ordering, or whether 'all' is truly all given the count parameter. The phrase 'List all audiences' is potentially misleading when paired with a limit parameter.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is one concise sentence that states the action, resource, and output highlights. No wasted words or redundant repetition of the schema.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple list tool, the description plus schema provide reasonable coverage, but the lack of an output schema and the ambiguity around 'all' vs. the count parameter leave gaps. The description doesn't clarify what 'key stats' includes or how results are limited, making it incomplete for an agent needing precise return expectations.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The single 'count' parameter is fully described in the schema (default 10, max 100), so schema coverage is 100%. The description does not add any additional meaning about the parameter, staying at the baseline for schema-backed clarity.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('List') and resource ('audiences'), clarifying the scope ('all audiences') and adding detail about output content ('subscriber counts and key stats'). This clearly distinguishes it from sibling tools like list_campaigns.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The context of when to use this tool is implied—when you need audience lists with statistics—but there are no explicit exclusions or comparisons to alternative tools. No mention of when to prefer search_members or search instead.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List email campaigns, optionally filtered by status (save, paused, schedule, sending, sent).
| Name | Required | Description | Default |
|---|---|---|---|
| count | No | Number of campaigns to return (default 10) | |
| offset | No | Pagination offset | |
| status | No | Filter by campaign status |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
There are no annotations, so the description bears the transparency burden. It indicates a read-only list operation via 'List' and enumerates status filter values, but it does not mention pagination, ordering, or return format. The description is not misleading but leaves behavioral details to the schema.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, compact sentence that efficiently conveys the tool's purpose and key optional filter. It avoids restating schema details or adding fluff, making it appropriately sized and front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple list tool without an output schema, the description provides a sufficient overview: it specifies the resource and optional status filtering. It does not cover pagination or default return size, but those are already defined in the schema, and the absence of complex side effects keeps the description complete enough.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with all three parameters (count, offset, status) already described in the input schema. The description adds the status filter values but does not enhance understanding of count or offset beyond what the schema provides.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action (List) and resource (email campaigns), and specifies optional status filtering with exact status values (save, paused, schedule, sending, sent). This distinguishes it from sibling list tools like list_audiences and list_templates, and from campaign-specific actions like send_campaign.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies the tool is used to retrieve campaign lists, optionally filtered by status, but it does not explicitly state when to use this tool versus alternatives. No exclusions or recommendations for sibling tools are provided, though the purpose is clear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List available email templates.
| Name | Required | Description | Default |
|---|---|---|---|
| type | No | Filter by template type: 'user' (yours) or 'gallery' (Mailchimp's) | |
| count | No | Number of templates to return (default 20) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full responsibility for behavioral disclosure. It only states the core action without mentioning read-only nature, filtering by type, pagination behavior, or any side effects. This is minimal and leaves important behaviors undocumented.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, focused sentence that immediately tells the reader what the tool does. There is no wasted wording, making it highly concise and front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
This is a simple list operation with no output schema and no annotations, so the description must provide context about return values and usage scenarios. It does neither, leaving the agent with only minimal functional info and no understanding of how templates relate to other tools.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the input schema fully documents both parameters (type and count). The description adds no parameter information, but the baseline of 3 applies because the schema handles all parameter semantics.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('List') and the resource ('available email templates'), making the purpose apparent. However, it does not explicitly differentiate itself from sibling list tools like list_audiences or list_campaigns, though the resource name makes the distinction obvious.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives. There is no mention of typical use cases (e.g., before creating a campaign) or any exclusions, leaving the agent without context for selecting this tool from its siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Schedule a campaign to send at a specific time. Returns compact confirmation by default — set verbose=true for full response.
| Name | Required | Description | Default |
|---|---|---|---|
| verbose | No | Return full API response instead of compact summary (default false) | |
| campaign_id | Yes | Campaign ID | |
| schedule_time | Yes | Send time in ISO 8601 format (e.g., '2026-03-15T10:00:00+00:00') |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are present, so the description carries the burden. It discloses the default return format (compact confirmation) and how to get the full response (verbose=true). However, it does not mention potential side effects like overwriting an existing schedule, prerequisites, or cancellation behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, front-loaded with the main purpose and immediately followed by response behavior. No filler or redundant information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple scheduling tool with three parameters and no output schema, the description covers the action, default output, and how to get more detail. It lacks some context about prerequisites or effects on existing schedules, but is adequate for straightforward use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, with detailed descriptions for all three parameters. The description adds no significant semantic meaning beyond the schema, though it does reiterate the verbose toggle behavior.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action: 'Schedule a campaign to send at a specific time.' This uses a specific verb and resource, and distinguishes from sibling tools like send_campaign (immediate send) and create_campaign (creation).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description clearly implies the use case: scheduling for a future time. It does not explicitly reference alternatives or for when not to use it, but the phrase 'at a specific time' contrasts with immediate sending.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Search the Mailchimp Marketing API catalog to discover endpoints. Returns method, path, summary, and parameter details. Call with no arguments to see all available categories.
| Name | Required | Description | Default |
|---|---|---|---|
| tag | No | Filter by API category (e.g., 'lists', 'campaigns', 'automations', 'templates', 'reports') | |
| limit | No | Max results to return (default 20) | |
| query | No | Text to search for in endpoint paths, summaries, and tags (e.g., 'members', 'campaign send') | |
| method | No | Filter by HTTP method |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Without annotations, the description carries the burden. It transparently discloses the output format and the no-arguments behavior, which covers the essential behavioral traits for a non-mutating catalog search. However, it does not explicitly state it is read-only or mention any rate limits.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences, immediately stating the action and resource, then providing output details and a usage tip. No filler or redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple catalog search with full schema coverage and no output schema, the description sufficiently covers the tool's purpose, return contents, and invocation options. The optional parameters are all explained in the schema, and the description provides the remaining context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
All parameters have schema descriptions, so baseline is 3. The description adds value by explaining that calling with no arguments returns all categories, clarifying the optionality of parameters beyond individual schema entries.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool searches the Mailchimp Marketing API catalog to discover endpoints, specifying the returned fields (method, path, summary, parameter details). This distinguishes it from sibling tools like search_members which search for member data.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
It provides a clear usage context: discover endpoints and view categories. It explicitly mentions calling with no arguments to see all categories, but does not contrast itself with alternatives like search_members or explain when to prefer endpoint discovery over actual data search.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Search for audience members by name or email address across all audiences.
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | Search query (name or email address) | |
| list_id | No | Limit search to a specific audience/list ID |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the burden. It discloses the search scope and criteria but omits behavioral details such as return format, pagination, permission requirements, or whether partial matches are returned.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, concise sentence with no wasted words. It front-loads the action ('Search for audience members') and lists criteria and scope efficiently.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has no output schema, so the description should explain what is returned. It only says 'search for' without stating the output format or any limitations. Given the tool's simplicity, it's adequate but incomplete for a fully opaque context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema covers both parameters with descriptions (query is name/email, list_id limits to a specific audience). The tool description adds that search is across all audiences, implying the list_id is a limiter, but this is minor extra value beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses the specific verb 'Search' with resource 'audience members' and scope 'across all audiences', clearly distinguishing from generic sibling 'search'. It states exactly what the tool does and its default search scope.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context for when to use the tool (finding members by name/email across all audiences) but does not explicitly mention alternatives or exclusions relative to siblings like 'search' or 'list_audiences'.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Send a campaign immediately. The campaign must have content set first via update_campaign_content. Returns compact confirmation by default — set verbose=true for full response.
| Name | Required | Description | Default |
|---|---|---|---|
| verbose | No | Return full API response instead of compact summary (default false) | |
| campaign_id | Yes | Campaign ID to send |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the burden and does well: it discloses the prerequisite (content must be set), the immediate side effect of sending, and the return behavior (compact by default, full with verbose). This gives the agent a clear picture of what to expect.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two concise sentences with no filler. The first sentence states the action, the second adds a prerequisite and return behavior. All information is front-loaded and purpose-driven.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple 2-parameter tool with no output schema and no annotations, the description covers the essential aspects: action, prerequisite, and response type. It does not fail to mention anything critical, though it could hint at error behavior if content is missing. Overall, it is complete enough for safe invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema covers both parameters. The description repeats the verbose behavior ('compact confirmation', 'verbose=true') rather than adding new meaning, so it does not exceed the baseline for well-documented schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's function: 'Send a campaign immediately.' The verb 'send' and resource 'campaign' are specific, and the word 'immediately' distinguishes it from sibling `schedule_campaign`. It also mentions the prerequisite of setting content, reinforcing its distinct role.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides a clear usage context: 'Send a campaign immediately' indicates immediate action, and 'must have content set first via update_campaign_content' gives a specific prerequisite and names an alternative tool. However, it does not explicitly contrast with `schedule_campaign`, leaving some room for interpretation.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Set the HTML content or template for a campaign. Provide either html OR template_id. Returns compact confirmation by default — set verbose=true for full response.
| Name | Required | Description | Default |
|---|---|---|---|
| html | No | Full HTML content for the email | |
| verbose | No | Return full API response instead of compact summary (default false) | |
| campaign_id | Yes | Campaign ID | |
| template_id | No | Template ID to use instead of raw HTML |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions the default compact response and the verbose option, which is useful. However, it does not explicitly state that this is an overwrite operation (destructive), any permission requirements, or what happens if both html and template_id are provided. Some behavioral traits are disclosed, but not the full safety profile.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences, front-loaded with the action, and includes both the core usage rule and the response format. Every sentence earns its place; there is no fluff or repetition. It is highly efficient.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has 4 parameters, no output schema, and no annotations. The description covers the main purpose, the either/or constraint, and the response behavior, which are the most critical aspects. It falls short of a perfect score because it omits edge-case behavior, such as validation rules or consequences of providing both parameters, and does not explicitly state that content is overwritten. Still, it is notably complete for a simple update tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% coverage, so all parameters already have descriptions. The description adds the mutual exclusivity constraint ('Provide either html OR template_id'), which is a semantic enhancement, but the schema's phrase 'instead of raw HTML' for template_id already hints at this. Overall, the description adds marginal value beyond the schema without fully compensating for any gaps.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Set the HTML content or template') and the target resource ('a campaign'), using a specific verb that distinguishes it from sibling tools like create_campaign, schedule_campaign, or send_campaign. It also indicates the key input choice (html vs template_id), making the purpose unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives clear usage guidance: 'Provide either html OR template_id' and explains the verbose parameter's effect on output. It implies the tool is for editing existing campaigns (as opposed to create_campaign, which is a sibling), though it does not explicitly name alternatives or when-not-to-use conditions. The context is clear enough for an agent to select it appropriately.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
v1.0.0add_or_update_membercreate_campaignexecuteget_campaign_reportlist_audienceslist_campaignslist_templatesschedule_campaignsearchsearch_memberssend_campaignupdate_campaign_contentScored across 12 tools
Each specific tool targets a distinct resource and action (campaigns, content, scheduling, sending, reports, templates, members). The meta-tools 'search' and 'execute' are clearly differentiated as discovery and fallback execution, so there is no practical confusion.
Most tools follow a consistent verb_noun pattern (list_audiences, create_campaign, get_campaign_report). The exceptions are the bare verbs 'search' and 'execute', which are minor deviations but still clear in intent.
Twelve tools is well within the ideal 3-15 range. Each tool covers a distinct part of the Mailchimp workflow without redundancy or bloat.
The core campaign lifecycle (create, content, schedule, send, report) and audience/member management are covered. The 'search' and 'execute' meta-tools ensure no Mailchimp API endpoint is unreachable, effectively filling any gaps.
Mailchimp MCP Pack — manage audiences, campaigns, and members via Mailchimp Marketing API.
335 MCP tools, 75 playbooks. AI-native CRM, email/SMS, events, OAuth.
Marketo MCP server for AI. 130 tools to operate Marketo from Claude, Cursor, or ChatGPT.
MCP server connecting AI agents to 100+ apps (Gmail, Slack, Notion, GitHub) via one-click OAuth.
