// agent setup
Set up your agent
Copy these instructions into your agent. It will guide the connection, check the available tools and pricing, and tell you when setup is ready.
Set up Fastsend in this agent or harness. First read https://fastsend.dev/skill.md for the service instructions; if you cannot fetch it, continue using the hosted Streamable HTTP MCP endpoint https://fastsend.dev/mcp. Check my existing MCP setup first and preserve other servers. Configure Fastsend using this harness's supported method, or give me exact manual steps if you cannot make the change. After any required reload, list the Fastsend tools, call get_service_status, and call get_pricing for email and SMS (ask for my destination country if needed for SMS). Tell me what succeeded, the quoted prices, and any payment setup needed for a future send. Do not send messages, verify recipients, create wallets, or pay during setup. Do not say Fastsend is ready if connection or checks fail.If copying fails, select the text in the box and copy it manually.
// 3 steps
How it works
Copy the setup prompt
Copy the instructions below — they tell your agent how to connect and check Fastsend.
Paste it into your AI agent
Works with Claude, Cursor, Windsurf, Codex CLI, or any MCP-capable client.
Agent connects itself
It connects to Fastsend, checks service health and pricing, then reports what is ready.
// what setup does
Your agent checks service health and per-send pricing, then reports back. Setup does not send a message, pay, or create a wallet. Ask your agent to confirm the price with you before a future paid send.
View full agent guide
Your agent can read this at /skill.md.
---
name: fastsend
description: >
Send SMS, email, WhatsApp, Telegram, and Signal (beta) messages from AI agents
using Fastsend — a hosted pay-per-send messaging service built for autonomous
agents. Use this skill when the user or agent needs to send a message, check
delivery status, look up pricing, or verify a recipient.
version: "0.1.0"
homepage: https://fastsend.dev
mcp_endpoint: https://fastsend.dev/mcp
transport: streamable_http
---
# Fastsend Messaging Skill
You have access to Fastsend, a hosted messaging service for sending SMS, email, WhatsApp, Telegram, and Signal (beta) messages from AI agents.
MCP endpoint: https://fastsend.dev/mcp (Streamable HTTP)
## Onboarding
Set yourself up in four steps using read-only checks:
1. Check the client's existing MCP configuration, preserve other servers, and connect to https://fastsend.dev/mcp using the client's supported Streamable HTTP setup. If you cannot change the configuration, give the user exact manual steps.
2. After any required reload, list the available Fastsend tools. The hosted server currently exposes the five tools below.
3. Call `get_service_status` and `get_pricing` for email and SMS. SMS quotes need a destination country; ask for one if needed.
4. Report which checks succeeded, the quoted prices, and any payment setup needed before a future send. If the connection or checks fail, report what remains and do not claim readiness.
During setup you MUST NOT call `send_message`, `verify_recipient`, or `create_wallet`, and MUST NOT perform any paid or payment-related action. Only send messages, verify recipients, or create wallets when the user explicitly asks you to after setup is complete.
## Tools
### send_message
Submit a message on any supported channel to Fastsend for asynchronous delivery.
Parameters:
- `channel`: `"sms"`, `"email"`, `"whatsapp"`, `"telegram"`, or `"signal"`
- `recipient`: For sms/whatsapp/signal: `{ phoneNumber: "+1234567890" }` (E.164). For email: `{ email: "[email protected]", name?: "User Name" }`. For telegram: `{ chatId: "123456789" }` (numeric chat ID only)
- `content`: `{ text: "message body" }` for all channels (SMS max 149 chars). For email you may add `subject: "Subject Line"`
- `metadata` (optional): key-value pairs for your own tracking
- `paymentMethod` (optional): `"x402"` or `"mpp"` payment-method preference for paid sends
- `idempotencyKey` (optional): 24-hour key for safe retries of the same paid request
Channel prerequisites:
- `whatsapp`: delivered via Bird to a phone number; may be sent as an approved template. `sent` means handoff to WhatsApp, `delivered` means recipient delivery.
- `telegram`: recipient must have already started the Fastsend bot; status reflects relay acceptance only, not recipient delivery.
- `signal`: restricted beta — the recipient must be on the operator allowlist; status reflects relay acceptance only, not recipient delivery.
Returns a `messageId` you can use with `get_delivery_status`.
If payment is required (`status: "payment_required"`), the tool will return pricing information. Ask the user to confirm before proceeding with a paid send.
If first-time recipient verification is required, use `verify_recipient` with the returned `challengeId`.
### verify_recipient
Complete recipient verification after `send_message` returns `verification_required`. On success, the original pending message is automatically released for delivery.
Parameters:
- `challengeId`: the challenge ID from the `send_message` response
- `code`: the verification code the recipient received
### get_pricing
Look up per-send pricing for a channel and optional destination country.
Parameters:
- `channel` (optional): `"sms"`, `"email"`, `"whatsapp"`, `"telegram"`, or `"signal"`
- `country` (optional): ISO 3166-1 alpha-2 country code, e.g. `"US"`, `"GB"`, `"DE"` — applies to SMS only
### get_delivery_status
Fetch the latest delivery status and history for a previously submitted message.
Parameters:
- `messageId`: the message ID returned by `send_message`
Returns current status: `queued`, `sent`, `delivered`, `failed`, or `retrying`.
### get_service_status
Check whether the Fastsend gateway is healthy before sending.
No parameters required.
## Connecting a client
Point your MCP client at the hosted endpoint:
```json
{
"mcpServers": {
"fastsend": {
"url": "https://fastsend.dev/mcp"
}
}
}
```
The exact field name varies by client (`url`, `serverUrl`, or a remote-server list) — check your client's docs for remote MCP servers. Works with Claude, Cursor, Windsurf, Codex CLI, and any MCP-compatible client.
For clients that only support local stdio servers, a `fastsend-mcp` binary exists in the Fastsend repository (`mcp/` workspace, run with `--stdio`); it is not published to npm, so prefer the hosted endpoint. The local build additionally exposes `create_wallet` and `get_wallet` for managing a local EVM wallet on Base — these are not available on the hosted endpoint.
## Payment model
Fastsend charges per message sent. Pricing is available via `get_pricing`. Sends may return a `402 Payment Required` response with machine-readable payment details that x402-aware clients resolve automatically.
Manual setup — point your client at the endpoint directly
Claude Code (CLI)
Run this from the project where you use Claude Code.
claude mcp add --transport http fastsend https://fastsend.dev/mcpCursor
Merge this entry into .cursor/mcp.json or your global Cursor MCP configuration.
{
"mcpServers": {
"fastsend": {
"url": "https://fastsend.dev/mcp"
}
}
}Windsurf
Merge this entry into ~/.codeium/windsurf/mcp_config.json.
{
"mcpServers": {
"fastsend": {
"serverUrl": "https://fastsend.dev/mcp"
}
}
}Any MCP client
Choose a remote Streamable HTTP server in your client. The hosted endpoint needs no local install or API key.
https://fastsend.dev/mcp