Send iMessages from Claude Code — Complete MCP Setup Guide (2026)

Claude Code supports the Model Context Protocol (MCP), which lets you extend its capabilities with external tools. The Sendblue MCP server adds a send_imessage tool that Claude can call natively — no manual API calls, no copy-pasting curl commands.

Once configured, you can type natural language into your Claude Code chat and it will send a real iMessage (blue bubble) to any iPhone:

• "Send an iMessage to +15555555555 saying the deployment finished successfully"
• "Text the on-call team at +14155551234 — the API is throwing 500s, check the logs"
• "Message the client at +12125550000 their feature is live in production"

The message arrives as a genuine iMessage — blue bubble, read receipts, iMessage reactions — not SMS. This is distinct from regular text messaging because it uses Apple's iMessage protocol via the Sendblue API, which means full delivery guarantees to Apple devices.

This is particularly useful for:

• Build and deploy notifications — ping yourself when a long build or migration completes
• Incident alerts — have Claude notify your on-call engineer when it detects an anomaly
• Customer notifications from AI agents — Claude completes a task and messages the customer automatically
• Testing messaging workflows — send test messages from your terminal without switching apps

Before you start, you need:

• Claude Code installed and running (version 1.0 or later supports MCP)
• A Sendblue account — sign up at dashboard.sendblue.com (free sandbox, no credit card required)
• Sendblue API keys — generated from the Sendblue dashboard under API Settings
• Node.js 18+ installed (required to run the MCP server process)

The MCP server runs as a local subprocess that Claude Code spawns and communicates with over stdio. You don't need to host anything — it all runs on your machine.

Log in to your Sendblue dashboard at dashboard.sendblue.com. Navigate to Settings → API Keys. You'll see two values:

• API Key ID — used as the sb-api-key-id header
• API Secret Key — used as the sb-api-secret-key header

Copy both values. You'll paste them into your MCP config in the next step. Keep your secret key out of version control — treat it like a password.

Claude Code reads MCP server configuration from .claude/mcp_settings.json in your home directory (or project directory for project-scoped tools). Open or create that file and add the Sendblue entry:

Replace your_key_id_here and your_secret_key_here with the values from Step 1. The npx -y sendblue-mcp command automatically downloads and runs the latest version of the MCP server from npm — no separate install step required.

Security tip: Instead of pasting keys directly into the JSON, use environment variable references and set the actual values in your shell profile:

This way you can commit your mcp_settings.json safely without exposing credentials.

Claude Code loads MCP server configurations at startup. After saving your mcp_settings.json, quit Claude Code completely and relaunch it.

To verify the MCP server loaded correctly, run /mcp in the Claude Code chat. You should see sendblue listed as a connected server with the send_imessage tool available. If it doesn't appear, check that Node.js is on your PATH and that the JSON in mcp_settings.json is valid (no trailing commas, correct bracket matching).

In the Claude Code chat, type a natural language request to send a message:

Claude Code will call the send_imessage tool, which sends the request to the Sendblue API and returns a delivery status. You'll see output like:

The message should appear on the recipient's iPhone within a few seconds as a blue bubble iMessage. If the number is not iMessage-capable (Android device), Sendblue automatically falls back to SMS.

Use your own phone number for the first test so you can confirm delivery immediately.

Beyond sending a simple message, the send_imessage tool supports the full Sendblue API surface:

• Send text messages — plain text, up to ~2000 characters
• Send media — pass a media_url parameter with a public HTTPS URL to send images, GIFs, or video
• iMessage effects — use the send_style parameter for effects like celebration, shooting_star, or invisible
• Check delivery status — query the status of a sent message using its messageHandle
• Receive replies via webhooks — configure a webhook in your Sendblue dashboard to receive inbound messages and feed them back into Claude's context

See the full API reference for all available parameters and response shapes.

Build and deploy notifications
Ask Claude to run your build and then message you when it finishes: "Run npm run build and text me at +15555555555 when it's done — include whether it passed or failed." Claude executes the command, waits for the result, and sends you an iMessage with the outcome. No more babysitting terminal windows.

On-call incident alerts
Wire Claude into your monitoring workflow. If Claude Code is analyzing logs or running health checks, instruct it to send an iMessage alert to the on-call engineer when it detects a problem: "Check the last 100 error log lines. If you see more than 10 500-status errors, text +14155551234 with a summary."

Customer notifications from AI agent workflows
If you're building an AI agent that completes tasks on behalf of users, Claude can send the customer an iMessage when the job is done. This is especially useful for async workflows — document processing, data analysis runs, background jobs — where the user shouldn't have to poll a dashboard.

Team standup pings
Ask Claude to compose a standup summary from your git log and send it to your team channel number. Claude reads recent commits, drafts a natural-language summary, and sends it as an iMessage.

Both approaches work. Here's when to use each:

Use MCP when:

• You want Claude to decide when to send a message based on context (agent workflows)
• You're working interactively in Claude Code and want natural language to trigger sends
• You want the tool available across all your projects without writing integration code each time

Use the REST API directly when:

• You're building a production application that needs to send messages programmatically (not via Claude)
• You need precise control over timing, retries, and error handling in your own codebase
• You're integrating Sendblue into an existing backend service

The MCP and REST API are complementary — many developers use MCP for development-time tooling (notifying themselves) and the REST API for production customer-facing sends. The API reference covers the full REST interface.

Does the Sendblue MCP server work in Cursor?
Yes. Cursor supports the Model Context Protocol. Add the same sendblue entry to your Cursor MCP configuration file and restart the editor. The tool will be available in Cursor's AI chat exactly as it is in Claude Code. See the Cursor integration guide for the exact file path and setup steps.

Does it work in Windsurf?
Yes. Windsurf also supports MCP servers. The configuration format is the same. See the Windsurf integration guide for details.

What are the rate limits?
Sandbox accounts are limited to 100 messages per day for testing. Production plans support significantly higher throughput with burst capacity. Check your current limits and plan options in the dashboard at dashboard.sendblue.com.

How do I keep my API keys secure?
Store keys as environment variables in your shell profile rather than hardcoding them in mcp_settings.json. Never commit a settings file containing live API keys to a public repository — add .claude/mcp_settings.json to your .gitignore if you include actual key values in it. For team environments, use a secrets manager and inject values at runtime.

• MCP overview — Full Sendblue MCP server documentation and available tools
• API reference — REST API documentation for production integrations
• Cursor integration — Set up Sendblue MCP in Cursor
• Windsurf integration — Set up Sendblue MCP in Windsurf