Sales execution layer for AI agents

Give your AI agent a sales system

Cold Leads gives AI agents persistent sales memory, verified contacts, outreach from your mailbox with human approval, reply tracking and follow-ups — over MCP, a REST API and a Node.js SDK.

Most AI agents can find prospects and write e-mails. Cold Leads lets them manage the sales relationship.

Get your API key Read the OpenAPI spec

OpenAPI 3.1
·x-api-key auth
·120 requests a minute per key
·Hosted MCP server
·MIT-licensed SDK on GitHub

POST /api/v1/verify

curl -X POST https://coldleads.app/api/v1/verify \
  -H "x-api-key: $COLDLEADS_API_KEY" \
  -d '{"email":"jane@example.com"}'

{
  "email": "jane@example.com",
  "status": "valid",
  "score": 75,
  "reasons": ["smtp_unreachable"],
  "mx": "mx.example.com",
  "catch_all": null,
  "disposable": false,
  "role": false
}

Illustrative response. The reason codes tell you whether the mailbox itself was checked.

120/min

requests per key, one auth header

MCP tools for Claude, ChatGPT and Cursor

5 days

free trial with API access on Business

The loop

From “I found a prospect” to “this relationship is managed”

1
Research
Your agent
Your agent finds and researches the prospect with its own tools. Cold Leads has no lead database.
2
Store
Cold Leads
Cold Leads remembers the prospect: deduplicated, do-not-contact addresses refused.
import_contactssearch_leads
3
Verify
Cold Leads
Syntax, disposable and role addresses, MX — and the mailbox itself when our server can reach it.
verify_email
4
Personalize
Your agent
One call returns the history, last reply and next step, so the agent writes a message that fits.
get_lead_contextsave_templatecreate_campaign_draft
5
Approve
You
Nothing is sent until you approve the exact message or campaign.
confirm_sendconfirm_launch
6
Send
Cold Leads
Cold Leads sends from your mailbox, with daily limits and pacing for campaigns.
send_contact_messagelaunch_campaign
7
Learn
Cold Leads
Replies are synced and classified: positive, neutral, negative, unsubscribe or auto. Unsubscribes are opted out.
get_conversationget_lead_context
8
Follow up
Cold Leads
A queue of who waits for an answer and whose follow-up is due — the agent picks up where it left off.
get_sales_next_actionsschedule_follow_upupdate_contact

Interfaces

Pick the surface that fits

REST API

Verify one address or a list (bulk jobs), look up contacts already in your own CRM, read your credit balance. OpenAPI 3.1 spec for code generation and for agents that import tools from a spec.

OpenAPI 3.1 spec

Lead and stage hooks

A website key (lk_…) turns any form into a lead source and can start an auto-campaign after a delay you choose. The stage hook marks a contact as customer when your billing or CRM system closes the deal.

Hosted MCP server

https://coldleads.app/api/mcp gives Claude, ChatGPT, Cursor and other MCP clients 18 tools: import and update contacts, verify addresses, write templates, draft campaigns and launch them after you approve, read replies. OAuth or a secret key.

Cold Leads for AI agents

Node.js SDK and stdio MCP

Typed client for Node 20 or newer and a local MCP server for Claude Desktop, Cursor and VS Code. Open source, MIT licence, installed straight from GitHub.

github.com/anttka4cz/coldleads-node-sdk

Quickstart

From sign-up to first call in minutes

Create an account with Google or an e-mail link. Start the 5-day free trial on the Business plan to try the API with 25 credits (card required, cancel any time before the trial ends).

Create a key

Settings → API. A secret key (sk_…) for your server, a website key (lk_…) for forms on your site. Secret keys are stored hashed, shown once, and can be paused, rotated or deleted.

Make a call

Send the key in the x-api-key header and call any endpoint below. Errors are JSON with a short code such as rate_limited, no_credits or bad_input.

Three calls that cover most integrations

# 1. Verify an address (1 credit)
curl -X POST https://coldleads.app/api/v1/verify \
  -H "x-api-key: $COLDLEADS_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"email":"jane@example.com"}'

# 2. Capture a lead from any form (website key lk_…, safe to ship in HTML)
curl -X POST "https://coldleads.app/api/hooks/lead?key=$COLDLEADS_SITE_KEY" \
  -d email=jane@example.com -d name="Jane Doe"

# 3. Move a contact along the funnel when the deal closes
curl -X POST https://coldleads.app/api/hooks/stage \
  -H "x-api-key: $COLDLEADS_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"email":"jane@example.com","stage":"customer"}'

# Node.js SDK and MCP server (installed from GitHub)
npm install --allow-git=root github:anttka4cz/coldleads-node-sdk
npx -y --allow-git=root github:anttka4cz/mcp-server-coldleads

Replace the environment variables with your keys. The addresses are illustrative.

A verification answer carries a status (valid, risky or invalid), a score, reason codes, the MX host and a catch_all flag. The reason codes tell you whether the mailbox itself was checked.

Tools

Every action is explicit

Each MCP tool declares whether it only reads, writes to the CRM or acts in the outside world, and whether it needs your approval. The same capability has the same name across interfaces.

MCP tool	Side effect	Approval	REST API	Node.js SDK
`get_workspace_info`	read	—	—	`client.crm.workspace`
`search_leads`	read	—	`GET /api/v1/leads`	`client.leads.search`
`list_contacts`	read	—	—	`client.crm.contacts`
`import_contacts`	write	—	—	`client.crm.importContacts`
`update_contact`	write	—	—	`client.crm.updateContact`
`get_lead_context`	read	—	`GET /api/v1/leads/context`	`client.crm.leadContext`
`verify_email`	read · 1 credit	—	`POST /api/v1/verify`	`client.verify.email`
`list_templates`	read	—	—	`client.crm.templates`
`save_template`	write	—	—	`client.crm.saveTemplate`
`list_campaigns`	read	—	—	`client.crm.campaigns`
`create_campaign_draft`	write	—	—	`client.crm.createCampaignDraft`
`launch_campaign`	external	required	—	`client.crm.launchCampaign`
`send_contact_message`	external	required	—	`client.crm.sendMessage`
`get_conversation`	read	—	—	`client.crm.conversation`
`get_sales_next_actions`	read	—	`GET /api/v1/next-actions`	`client.crm.nextActions`
`schedule_follow_up`	write	—	`POST /api/v1/follow-ups`	`client.crm.scheduleFollowUp`
`get_agent_activity`	read	—	`GET /api/v1/activity`	`client.crm.activity`
`setup_website_lead_capture`	external	—	—	`client.crm.setupWebsiteLeadCapture`

Machine-readable for AI agents:/llms.txt/llms-full.txt/.well-known/agent-capabilities.json/.well-known/agents.txt/.well-known/mcp/server-card.json/api/v1/openapi.json

Why Cold Leads

Why developers stay

Plain JSON over HTTPS, one auth header, errors with short codes — no SDK required to start.

Every key has its own rate limit and usage counter, and can be paused or rotated without touching the others.

The same engine runs your own campaigns: addresses verified as invalid are never sent to, and campaigns go out from your own Gmail, Microsoft 365 or SMTP mailbox.

AI agents work with approval: they prepare a campaign draft and launch it only after a human confirms the template and audience.

An agent can even start without a key: POST /api/agent/provision returns a payment link for the human owner and a claim token.

Pricing

$99per month · Business · 10,000

Website keys work on every plan. The secret-key API (verification, finder, contact search, stage hook) and MCP come with Business: $99/month including 10,000 credits a month. Extra credits cost $5 per 1 000.

Try it first: the 5-day free trial on Business includes the API within trial limits (25 credits). New customers who subscribe within 24 hours of signing up get 30% off the first payment instead of the trial — the two can’t be combined.

Get your API key Pricing

Limits

120 requests a minute per key.
5 parallel bulk jobs, up to 5 000 addresses per job.
1 credit per verified address or finder call; results are cached for 30 days and a repeated check still costs a credit.
Website keys (lk_…) can only create contacts, with a daily cap per key.

Straight talk

What it is not

Not a lead database: Cold Leads does not sell people or company data and does not enrich contacts. Search runs over the contacts in your own account.

The mailbox and accept-all check over SMTP runs only when our server can reach the recipient’s mail server; otherwise the reason code says the mailbox was not checked.

No outgoing webhooks yet: read results by polling, or use MCP.

The SDK and the stdio MCP server install from GitHub; they are not on npm.

Recipes

Use Cold Leads from Cursor, Claude Desktop and Windsurf over MCP

Connect Cold Leads MCP or Node SDK to import and manage contacts, read chats, prepare campaigns, launch approved outreach and capture website leads.

Bulk e-mail verification in n8n with Google Sheets

An importable n8n workflow: read a Google Sheet, send up to 5,000 addresses to a Cold Leads bulk job, poll it, route rows by status and write results back.

Verify leads in Make.com before they reach an Instantly campaign

A Make.com scenario that checks each new lead with the Cold Leads API and adds only valid addresses to an Instantly campaign via the Instantly API v2.

Verify a 50,000-row CSV with Python, asyncio and httpx

A complete asyncio + httpx script for the Cold Leads bulk API: jobs of 5,000, five at a time, polling, 429 and 402 handling, resumable CSV output.

Moving e-mail verification from Hunter or Apollo to Cold Leads

Map Hunter's Email Verifier and Email Finder to the Cold Leads API field by field, see what Apollo data has no equivalent, and check Cold Leads costs.

Agent-initiated, human-approved subscriptions

An AI agent without a key asks for a Cold Leads Business subscription, the human owner approves and pays on Stripe, and the agent collects the API key once.

All recipes

FAQ

Developer FAQ

Do I need a card to try the API?

Yes. The 5-day free trial needs a card and you can cancel before it ends; nothing is charged during the trial. There is no free plan.

Which plan includes the API?

Business ($99/month, 10,000 credits). Website keys for forms work on every plan. During a Business trial the API works within the trial limits.

Can I generate a client from a spec?

Yes, /api/v1/openapi.json is an OpenAPI 3.1 document. The two hooks are plain HTTP calls described on this page.

Is there an SDK?

A typed Node.js SDK (Node 20 or newer) and an MCP server for local clients, both MIT-licensed on GitHub. Other languages can use the HTTP API directly.

Can an AI agent sign up by itself?

An agent can call POST /api/agent/provision with the owner’s e-mail. It gets a Stripe payment link for the human owner and a claim token; after the owner pays, the agent receives its key once.

What happens when I run out of credits?

Calls return a 402 no_credits error with your remaining balance. Credits renew monthly, and extra packs cost $5 per 1 000.

Ready to build?

Create an account, grab a key and make your first call in a few minutes.

Get your API key