Already Have an Account? Sign In ›

Developer Platform

API and MCP. One surface.

Build with REST. Operate with agents. Ship iMessage workflows that can be driven by code or by chat.

Use signed webhooks, reusable workflow tools, CRM sync, inbox actions, reactivation, and the published `tuco-mcp` package for Claude, Cursor, Windsurf, and other MCP clients.

Read the docsView `tuco-mcp`

Last updated:

90 MCP tools.

Campaigns, inbox, Knowledge Base, CRM sync, line health, AI credits, and reactivation are already exposed.

One npm package.

Install `tuco-mcp` once and use the same server across Claude, Cursor, Windsurf, and future MCP clients.

Real workflow coverage.

This is not a toy wrapper around send-message. It reaches campaigns, KB approvals, inbox work, and CRM-aware logic.

API + agent surface.

Use REST when code should drive. Use MCP when a person or AI should operate the workspace by chat.

Quick Start

Install it. Then talk.

The MCP layer is real, published, and already broad enough to operate your workspace like a product operator.

npm

Install the MCP package.

npx tuco-mcp

Claude Desktop

Add the config.

{
  "mcpServers": {
    "tuco": {
      "command": "npx",
      "args": ["tuco-mcp"],
      "env": {
        "TUCO_API_KEY": "your_api_key_here"
      }
    }
  }
}

Platform

Build less glue.

The point is not just sending one message. It is operating campaigns, inbox, CRM, and AI workflows from one developer surface.

REST API

Send messages, manage leads, retrieve replies, and work the platform with predictable HTTP calls.

Signed Webhooks

Receive sent, failed, fallback, reply, and opened events without polling or brittle status checks.

tuco-mcp

Let Claude, Cursor, or Windsurf run the workspace with natural language across 90 live tools.

Custom Tools

Build reusable API tools once, test them on a real lead, then reuse them inside campaigns and AI bots.

CRM Write-Back

Sync HubSpot and GoHighLevel, map owners and properties, and push the right updates back after the reply.

Reactivation

Scan dormant conversations, tune reactivation rules, and trigger the next AI motion from code or MCP.

Send an iMessage in 5 lines

Code samples: cURL, Python, Node.js.

One REST endpoint. Authenticate with a Bearer token. Get a message ID back. That's it.

cURL

curl -X POST https://api.tuco.ai/v1/messages \
  -H "Authorization: Bearer $TUCO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "to": "+15551234567",
    "body": "Hi Sarah — saw you booked a demo. Quick q before we meet?",
    "lineId": "line_abc123"
  }'

Python

import os, requests

resp = requests.post(
    "https://api.tuco.ai/v1/messages",
    headers={"Authorization": f"Bearer {os.environ['TUCO_API_KEY']}"},
    json={
        "to": "+15551234567",
        "body": "Hi Sarah — saw you booked a demo. Quick q before we meet?",
        "lineId": "line_abc123",
    },
    timeout=10,
)
resp.raise_for_status()
print(resp.json()["id"])

Node.js

import fetch from "node-fetch";

const r = await fetch("https://api.tuco.ai/v1/messages", {
  method: "POST",
  headers: {
    Authorization: `Bearer ${process.env.TUCO_API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    to: "+15551234567",
    body: "Hi Sarah — saw you booked a demo. Quick q before we meet?",
    lineId: "line_abc123",
  }),
});

if (!r.ok) throw new Error(await r.text());
const { id } = await r.json();
console.log(id);

Webhook (verify)

import crypto from "crypto";

export function verifyTucoWebhook(rawBody, signatureHeader, secret) {
  const expected = crypto
    .createHmac("sha256", secret)
    .update(rawBody)
    .digest("hex");
  return crypto.timingSafeEqual(
    Buffer.from(expected),
    Buffer.from(signatureHeader),
  );
}

No A2P 10DLC. No carrier surcharges. Webhook payloads are HMAC-signed — verify them like Stripe. Full reference in the docs →

MCP Prompt Lab

Pick a workflow. See the prompt.

Campaigns, KB approvals, inbox work, CRM sync, reactivation, and ops checks are already agent-friendly.

16 campaign tools

Build and tune campaigns by chat.

Create campaigns, preview paths, test steps, and pause live motions without leaving Claude or Cursor.

Drafts a multi-step campaign with delays and stop rules.
Returns campaign structure for review before launch.
Can simulate the path on a real lead next.
MCP prompt

You say

Create a 3-step campaign for dormant HubSpot leads. Wait 2 days after step 1. Stop if lifecycle stage changes to customer.

Tuco MCP handles

Drafts a multi-step campaign with delays and stop rules.
Returns campaign structure for review before launch.
Can simulate the path on a real lead next.

FAQ

Questions. Answered.

Does iMessage have an API?

Apple does not publish a public iMessage send API. The only Apple-sanctioned program is Messages for Business, which routes gray-bubble customer-support conversations and is not available for marketing or transactional sends. The practical "iMessage API" developers integrate against today is provided by third parties running real Apple hardware behind a clean HTTPS surface. Tuco AI exposes a REST endpoint at api.tuco.ai that accepts {to, body, lineId} and returns delivery status via signed webhooks — no Apple developer account, no A2P 10DLC, no carrier registration required.

What can developers build with Tuco AI?

Developers can send iMessages programmatically, create and tune campaigns, approve or auto-send KB replies, manage inbox workflows, sync CRMs, scan dormant leads, and control the whole workspace through API or MCP.

Is there an iMessage API for Python?

Yes. Tuco AI exposes a REST API any language can hit — Python, Node.js, Go, Ruby, PHP. There is no language-specific SDK requirement; the API is just signed HTTPS calls. See the code samples above for a Python `requests` example sending an iMessage in a few lines.

Is there an iMessage API for Node.js?

Yes. Node.js apps hit the same REST endpoints with `fetch` or `axios`. Webhooks are signed with HMAC so you can verify them in any Node middleware. The tuco-mcp package itself is published on npm and ships TypeScript definitions.

How do I send an iMessage programmatically with cURL?

POST to https://api.tuco.ai/v1/messages with a JSON body of {to, body, lineId} and your API key in the Authorization header. Full curl snippet is in the code samples on this page and in the docs.

How does the iMessage API authenticate requests?

API keys are scoped per workspace and sent as Bearer tokens. Webhook payloads are signed with HMAC-SHA256; verify the signature against your endpoint secret before trusting the body. Standard pattern, no surprises.

Is the Tuco AI iMessage API secure for backend integration?

Yes. TLS in transit, encrypted at rest, scoped API keys, signed webhooks, and audit logs on every workspace mutation. Tuco AI does not require A2P 10DLC because iMessage uses Apple’s network rather than US carriers, so you avoid the brand-vetting paperwork while keeping a clean compliance posture.

What is tuco-mcp?

tuco-mcp is the published npm package for Tuco’s official MCP server. It lets Claude, Cursor, Windsurf, and other MCP clients control your Tuco workspace through natural language instead of custom glue code.

How much MCP coverage is live right now?

The current published package exposes 90 tools across campaigns, Knowledge Base, inbox, leads, messaging, CRM sync, line health, workspace config, and reactivation workflows.

When should I use the REST API vs MCP?

Use the REST API when your app or backend needs deterministic integration. Use MCP when a human or AI agent should operate the workspace conversationally from Claude, Cursor, or another MCP client.

How affordable is the iMessage API for small developer projects?

Pricing starts at $59/mo on the Mini plan with full API access, no setup fee, and no A2P 10DLC carrier surcharges. There is no per-API-call fee — you pay for the line and credits, not for each request. See /pricing for the full breakdown.

Is there an iMessage API webhook for sent, replied, and opened events?

Yes. Subscribe to message.sent, message.failed, message.fallback, message.reply, and message.opened webhook events. Payloads are signed; retries follow exponential backoff. Configure endpoints in the workspace settings or via the API.

Build it. Or talk to it.

The best developer surface is the one that fits both your backend and your operator workflow. Tuco gives you both.

Open npm packageExplore MCP page
Get StartedMini self-serve, Growth demos