Warm-up API for AI SDRs and outbound agents

Your agent can write a thousand good emails and still land in spam if the mailbox it sends from has no history. This free API and MCP server let an AI SDR, a Clay table or an n8n workflow connect a mailbox, ask one question, "is it ready to send?", and start or stop warm-up, without a human opening a dashboard.

Free with every account. Base URL https://app-emailwarmup.bobwork.ai/api/v1, JSON in and JSON out, Bearer key bwk_… (create one under API after signing in, no card). 120 requests per minute per key.

The three jobs

1. Connect a mailbox

Any IMAP/SMTP mailbox (Gmail with an app password, Yahoo, iCloud, Lark, custom domains, SES, SendGrid, Mailgun). The login is tested before it is saved and warm-up starts the same day. GET /providers lists the presets.

curl -X POST https://app-emailwarmup.bobwork.ai/api/v1/mailboxes/imap \
  -H "Authorization: Bearer bwk_YOUR_KEY" -H "Content-Type: application/json" \
  -d '{"email": "sam@yourdomain.com", "password": "APP_PASSWORD", "preset": "gmail-imap", "name": "Sam"}' 

For Gmail and Google Workspace without handling passwords, request a sign-in link, hand it to the mailbox owner, and the mailbox appears in GET /mailboxes a few minutes after they allow it.

curl -X POST https://app-emailwarmup.bobwork.ai/api/v1/mailboxes/google/link -H "Authorization: Bearer bwk_YOUR_KEY"

Zoho Mail also connects through POST /mailboxes/zoho (free Zoho plan works). See the full API reference.

2. Check status and the ready gate

A mailbox is ready for outbound after 7 days of warm-up with a 7-day spam rate under 10%. The field is ready_for_outbound. Gate your agent on it: do not let a sequence send from a mailbox that returns false.

# one mailbox
curl https://app-emailwarmup.bobwork.ai/api/v1/mailboxes/sam@yourdomain.com -H "Authorization: Bearer bwk_YOUR_KEY"

# all mailboxes, filter ready_for_outbound == true
curl https://app-emailwarmup.bobwork.ai/api/v1/mailboxes -H "Authorization: Bearer bwk_YOUR_KEY"

{
  "email": "sam@yourdomain.com", "status": "active", "warmup_day": 9,
  "ready_for_outbound": true, "spam_rate_7d_pct": 0.8,
  "today": {...}, "last_7_days": {...}, "daily_target": 18, "last_error": null
}

last_error tells the agent when a login broke. POST /mailboxes/{email}/test signs in right now and reports whether the stored login still works.

3. Start and stop

Warm-up begins when the mailbox is connected. Use pause and resume as the on and off switch, for example to stop warming while an agent is mid-campaign and the mailbox needs to rest, or to restart after a login fix.

curl -X POST https://app-emailwarmup.bobwork.ai/api/v1/mailboxes/sam@yourdomain.com/pause  -H "Authorization: Bearer bwk_YOUR_KEY"
curl -X POST https://app-emailwarmup.bobwork.ai/api/v1/mailboxes/sam@yourdomain.com/resume -H "Authorization: Bearer bwk_YOUR_KEY"
curl -X POST https://app-emailwarmup.bobwork.ai/api/v1/mailboxes/sam@yourdomain.com/test   -H "Authorization: Bearer bwk_YOUR_KEY"

MCP: let the agent do it itself

The same three jobs are MCP tools. Remote server, nothing to install, Streamable HTTP, same API key. URL https://app-emailwarmup.bobwork.ai/mcp.

Claude Code

claude mcp add --transport http email-warmup https://app-emailwarmup.bobwork.ai/mcp \
  --header "Authorization: Bearer bwk_YOUR_KEY"

Cursor, Windsurf, VS Code and other MCP clients (mcp.json)

{
  "mcpServers": {
    "email-warmup": {
      "url": "https://app-emailwarmup.bobwork.ai/mcp",
      "headers": { "Authorization": "Bearer bwk_YOUR_KEY" }
    }
  }
}

Claude Desktop connects through the mcp-remote bridge; the config is on the API page. Then prompt it: "Connect sales@mydomain.com with this app password, then tell me when it is ready for outbound." All 39 tools are listed on the API page. Tools that send email or delete data are marked and ask the agent to confirm with the user first.

n8n

Use an HTTP Request node in front of every send. Store the key once as a Header Auth credential.

Method: GET
URL: https://app-emailwarmup.bobwork.ai/api/v1/mailboxes/{{ $json.sender_email }}
Authentication: Generic Credential Type > Header Auth
  Name: Authorization   Value: Bearer bwk_YOUR_KEY
Then an IF node:  {{ $json.ready_for_outbound }}  is true

Route the false branch to a Wait node or a Slack alert. Poll GET /mailboxes on a schedule to alert when last_error is not null.

Clay

Add an HTTP API column on your sender or mailbox table.

Method: GET
Endpoint: https://app-emailwarmup.bobwork.ai/api/v1/mailboxes/{{Sender email}}
Header: Authorization = Bearer bwk_YOUR_KEY
Use the ready_for_outbound and spam_rate_7d_pct fields from the response.

Filter the table on ready_for_outbound before the rows reach your sequencer or a Smartlead/Instantly push.

Let an agent sign up and pay for the person

An agent acting for a person needs no browser. The person's email is the proof of control: we email a 6-digit code to it, and the agent (or the person) reads it.

# 1. email the person a 6-digit code
curl -X POST https://app-emailwarmup.bobwork.ai/api/v1/signup/code -H "Content-Type: application/json" -d '{"email": "person@company.com"}'
# 2. exchange nonce + code for a key (shown once)
curl -X POST https://app-emailwarmup.bobwork.ai/api/v1/signup/verify -H "Content-Type: application/json" -d '{"nonce": "NONCE_FROM_STEP_1", "code": "123456"}' 

Then connect mailboxes as above. When the free mailbox limit is reached or credits run out, the API answers 402 and says how to pay. The agent asks for a Stripe Checkout link, hands it to the person, and polls until Stripe confirms. The person clicks pay once; the agent never sees card details.

# extra mailboxes (monthly; {"yearly": true} for yearly)
curl -X POST https://app-emailwarmup.bobwork.ai/api/v1/billing/checkout -H "Authorization: Bearer bwk_YOUR_KEY" -H "Content-Type: application/json" -d '{}'
# Outbound credits: 5, 10, 25 or 100
curl -X POST https://app-emailwarmup.bobwork.ai/api/v1/credits/checkout -H "Authorization: Bearer bwk_YOUR_KEY" -H "Content-Type: application/json" -d '{"usd": 10}'
# did it work?
curl https://app-emailwarmup.bobwork.ai/api/v1/billing -H "Authorization: Bearer bwk_YOUR_KEY"

GET /billing shows subscription.active, credits_usd, mailboxes against the free limit and the prices. The MCP tools are create_billing_checkout, create_credits_checkout and get_billing_status. Starting a campaign from a mailbox that is still warming answers 400 with warming: true; the agent shows the person the warning and sends accept_warming_risk: true only if they agree. The whole journey in plain text for agents: llms-full.txt, and the OpenAPI spec.

What this does not do

The API and MCP cover warm-up, DNS checks (GET /tools/spf, /tools/dkim, /tools/dmarc) and our own Outbound sending. It does not read your real inbox, and Outlook / Microsoft 365 is not supported yet.

Pricing

The first 10 mailboxes are free (20 for accounts created before 27 October 2026), then $5 per mailbox per month ($3 each from 10 extra, $2 each from 50 extra). The API and MCP server are free. If you also send with our Outbound, emails cost $2 per 1,000 from prepaid credits.

FAQ

Do I need a paid plan to use the API? No. Create a key on a free account.

Can my agent keep sending from its own sequencer? Yes. Warm-up runs on the mailbox; you keep sending from Smartlead, Instantly, Apollo or your own SMTP. Just check the gate first.

Who can see my key's data? A key acts as its owner only and can be revoked any time. Up to 5 keys per account.