Bento MCP Server

Connect your favorite AI assistant to Bento and manage your email marketing with natural language.

The Model Context Protocol (MCP) is an open standard that lets AI assistants like Claude, Cursor, and others interact with external tools and services. The Bento MCP server gives your AI assistant direct access to your Bento account. It can look up subscribers, create broadcasts, track events, and more, all through natural conversation.

Bento hosts the MCP server at https://mcp.bentonow.com/mcp. You point your AI app at that URL and add your API keys. There's nothing to install, run, or update.

Whether you're drafting a campaign, importing subscribers, or checking your stats, you describe the task and your AI assistant runs the matching Bento tools.

Getting Your API Credentials

Hosted Endpoint

The hosted server is the recommended way to use Bento MCP. Bento runs and updates it, so you always get the latest tools.

Send these headers with every request:

X-Bento-Publishable-Key: BENTO_PUBLISHABLE_KEY
X-Bento-Secret-Key: BENTO_SECRET_KEY
X-Bento-Site-UUID: BENTO_SITE_UUID

Your MCP client sends your credentials with each request. The hosted server uses them to call the Bento API for that request and doesn't store them.

Setup Guides by Platform

Pick your AI application below. Every guide connects to the hosted server at https://mcp.bentonow.com/mcp, so there is nothing to install or keep updated. Replace the placeholder values with the credentials from Settings -> API Keys.

If your client can send custom headers to a remote MCP server, add the URL and the three headers. If it only launches local servers, use the mcp-remote bridge shown in the Claude Desktop and Continue guides. It runs through npx and forwards requests to the hosted server. Your app isn't listed? See Other MCP clients.

Other MCP clients

Most MCP clients accept one of two shapes. Use the first if your client supports remote servers with headers. Use the second if it only launches local commands.

Remote server with headers. The key names vary by client (url, serverUrl, or httpUrl, and sometimes a type such as http or streamable-http). Check your client's docs for the exact names.

{
"mcpServers": {
  "bento": {
    "type": "streamable-http",
    "url": "https://mcp.bentonow.com/mcp",
    "headers": {
      "X-Bento-Publishable-Key": "your_publishable_key",
      "X-Bento-Secret-Key": "your_secret_key",
      "X-Bento-Site-UUID": "your_site_uuid"
    }
  }
}
}

Local command through the mcp-remote bridge. This works in any client that can launch a stdio server and needs Node.js 18 or later. Use the same command, args, and env as the Claude Desktop JSON config.

Available Tools

The hosted MCP server provides these tools, plus related ones for subscriber status, tag removal, batch events, segment and report stats, and more. Your AI app loads the full list when it connects.

Common Workflows

Creating an Email Broadcast

This is the most common workflow: drafting and creating an email campaign using natural language.

Importing Subscribers

Perfect for moving subscribers from a spreadsheet or another platform.

Pro Tips for Bulk Imports:

• You can import up to 1000 subscribers at once
• Custom fields are supported. Just mention them naturally
• Tags can be added or removed during import
• Existing subscribers will be updated (not duplicated)

Tracking Purchase Events

Track revenue and trigger purchase-based automations.

Checking Your Stats

Get a quick overview of your Bento account performance.

Managing Your Subscriber Data

Look up and understand your subscribers.

Setting Up Custom Fields

Create the data structure for personalization.

Building a Welcome Sequence

Create and populate an email sequence step by step using natural language.

Reviewing Workflows

Check on your workflow performance and email templates.

Troubleshooting

curl -sS https://mcp.bentonow.com/health

curl -sS https://mcp.bentonow.com/mcp \
-H "Content-Type: application/json" \
-H "Accept: application/json, text/event-stream" \
-H "X-Bento-Publishable-Key: $BENTO_PUBLISHABLE_KEY" \
-H "X-Bento-Secret-Key: $BENTO_SECRET_KEY" \
-H "X-Bento-Site-UUID: $BENTO_SITE_UUID" \
--data '{"jsonrpc":"2.0","id":1,"method":"tools/list","params":{}}'

codex mcp get bento-remote

"Can you connect to Bento? Try listing my tags."

Best Practices

Security

• Never share your Secret Key in public repositories, screenshots, or support tickets
• Use environment variables in CI/CD rather than hardcoding credentials
• Rotate API keys periodically, especially if you suspect they may have been exposed

Performance

• Use batch operations when importing multiple subscribers. bento_batch_import_subscribers handles up to 1000 at once
• Be specific in your prompts to help the AI choose the right tool on the first try
• Review broadcasts in Bento before sending. The MCP creates drafts for safety

Workflow Tips

• Start with stats to understand your account state before making changes
• Test with a single subscriber before bulk importing
• Use descriptive broadcast names so they're easy to find in the Bento dashboard
• Leverage custom fields for personalization. Create them once, use them everywhere

Sequences & Workflows

• Always include an unsubscribe URL when updating sequence email HTML. Use {"{{ visitor.unsubscribe_url }}"} so recipients can always opt out
• Reference sequences by name for readability, or by ID for precision
• Set delivery timing explicitly when creating sequence emails using delayInterval and delayIntervalCount. If you leave them out, Bento uses its default delay, so check the timing in the dashboard
• Use bento_list_automations with a type filter to narrow results to just sequences or just workflows

Quick Reference Card

Subscriber Operations

"Look up [email] in Bento"
"Import these subscribers with tag [tag]: [list]"

Tag Operations

"What tags do I have?"
"Create a tag called [name]"

Broadcast Operations

"Show me my broadcasts"
"Create a broadcast called [name] about [topic]"

Sequence Operations

"Show me my sequences"
"Add an email to my [sequence name] sequence about [topic]"
"Update the subject on sequence email [id]"

Workflow Operations

"Show me my workflows"
"List only my workflows"
"Show me the Onboarding workflow"

Event Tracking

"Track [event] for [email]"
"Log a $[amount] purchase for [email]"

Statistics

"Show me my Bento stats"
"How many subscribers do I have?"

Alternative: Local npm Package

Most people should use the hosted server. If you need to run Bento MCP on your own machine, for example because your network blocks outside MCP connections, the @bentonow/bento-mcp npm package runs a local stdio server. It needs Node.js 18 or later.

Add it to any MCP client that launches local commands:

{
"mcpServers": {
  "bento": {
    "command": "npx",
    "args": ["-y", "@bentonow/bento-mcp"],
    "env": {
      "BENTO_PUBLISHABLE_KEY": "your_publishable_key",
      "BENTO_SECRET_KEY": "your_secret_key",
      "BENTO_SITE_UUID": "your_site_uuid"
    }
  }
}
}

You can leave out the env block if your shell profile (~/.zshrc or ~/.bashrc) exports the same three variables and your AI app inherits them:

export BENTO_PUBLISHABLE_KEY="pk_live_..."
export BENTO_SECRET_KEY="sk_live_..."
export BENTO_SITE_UUID="..."

To check the local server for errors, run it by hand:

BENTO_PUBLISHABLE_KEY=xxx \
BENTO_SECRET_KEY=xxx \
BENTO_SITE_UUID=xxx \
npx @bentonow/bento-mcp

Get Help

• Local npm package issues: github.com/bentonow/bento-mcp/issues
• Documentation: docs.bentonow.com
• Discord: Join the community
• Email Support: support@bentonow.com

Links

• Local npm package on GitHub
• Model Context Protocol
• Bento Node SDK
• API Reference