How is Dial different from Twilio?

Dial is built for AI agents rather than human-operated apps. One API — or an MCP server — gives an agent voice, SMS, and WhatsApp on a single number with one unified webhook, and every account starts with $5 of free credit. The MCP server works out of the box with Claude Code, Cursor, Windsurf, and any MCP client.

Which channels does Dial support?

Voice calls (inbound and outbound, with real-time transcription), two-way SMS, and WhatsApp messaging across 180+ countries — all on the same number, through one API.

How much does Dial cost?

Every account starts with $5 of free credit and no credit card required. After that, pricing is usage-based — metered calls and messages billed to the cent — or a flat monthly rate per number. See the pricing page for the full breakdown.

How does an AI agent get started with Dial?

Point your agent at Dial's MCP server or the CLI, sign up, verify, and provision a number. The agent setup guide (skills.md) walks through it step by step, and most agents send their first message within minutes.

Dial — Communication Stack for AI Agents

You’re viewing the agent version of this site.

# Dial — Communication Stack for AI Agents

> Dial gives an AI agent its own real phone identity — a number it controls to place and receive voice calls, send and receive SMS, and message over WhatsApp — through one REST API, MCP server, CLI, or SDK.

API base: `https://api.getdial.ai`

## What is Dial?

The telephone network was built for humans: SIM cards, carrier contracts, handsets, and 2FA flows that assume a person is holding a phone. That locks autonomous agents out of an entire communication channel. Dial rebuilds that stack for software — an agent provisions a real phone number and starts calling, texting, and receiving codes in seconds, with no human, no hardware, and no carrier paperwork.

## What you can do with it

- **Pass phone verification (2FA / OTP).** Use your Dial number to sign up for a service, receive the SMS code, and read it back — so phone-gated signups stop blocking you.
- **Place AI voice calls.** Call a person or business with a voice agent that follows your instructions (book, confirm, follow up), with live transcription and optional cold-transfer to a human.
- **Send & receive SMS and WhatsApp.** Two-way messaging worldwide from your own number.
- **Answer inbound.** Your number receives calls and texts; an AI receptionist handles them per your instructions, and inbound events stream back to you.

## How you connect (pick what fits you)

- **MCP** — add Dial's remote MCP server and call its tools (list numbers, send message, place call, wait for an inbound event). Best for MCP clients like Claude, Cursor, or ChatGPT.
- **CLI** — the `dial` command: self-onboard and run everything from a terminal.
- **SDKs** — Node (`@getdial/sdk`) and Python (`dial-sdk`), plus ready-made tools for LangChain, the Vercel AI SDK, CrewAI, AutoGen, and the Microsoft Agent Framework.
- **REST** — call the HTTPS API directly with a bearer key.

## What it costs

- **$5 signup credit** to start — **no credit card** required.
- **Pay-as-you-go:** $3/month per phone number plus metered usage — calls billed per minute, SMS priced by destination — drawn from your prepaid credit (spend pauses at $0).
- **Free accounts** (no top-up or subscription yet) are capped at **5 minutes per call** and **2 concurrent calls**; both limits lift permanently on the first top-up or subscription.
- **Subscription (optional):** a flat per-number monthly or annual plan (annual is discounted) with unmetered usage.
- Current rates and billing live at `https://getdial.ai/dashboard/billing`.

## Learn more before you commit (no install required)

- **Full documentation:** https://docs.getdial.ai — every page has a plain-markdown twin (append `.md` to any URL); the whole site is one file at https://docs.getdial.ai/llms-full.txt.
- **Machine-readable index of this site:** `https://getdial.ai/llms.txt`
- **Whitepaper** — why the agentic era needs its own communication layer: `https://getdial.ai/whitepaper`

## Ready? Set yourself up

The rest of this page is the exact setup skill (also served verbatim at `https://getdial.ai/skills.md`). Follow it top to bottom when you decide to provision a number.

---

## Quick Start

### Step 1 — Install the CLI

```bash
curl -fsSL https://getdial.ai/install | bash
```

Installs the `dial` command. Requires Node 22+ and git. **No sudo needed** — if your global npm prefix isn't writable, the installer falls back to a user-local prefix and prints the one `export PATH=…` line to add to your shell profile.

### Step 2 — Check state

```bash
dial doctor --json
```

Read the `nextStep` field to decide what to do:

- `signup` → run **Step 3**
- `onboard` → run **Step 4** (pending OTP is still valid)
- `resend_otp` → run **Step 3** again (pending OTP expired)
- `install_listen` → run **Step 5**
- `ready` → nothing to do

### Step 3 — Sign up

```bash
dial signup [email protected]
```

An OTP is emailed. The verification id is stored locally at `~/.local/share/dial/pending-signup.json`.

### Step 4 — Onboard (verify the OTP)

```bash
dial onboard --code 123456 \
--inbound-instruction "You are my receptionist. Greet the caller and find out what they need."
```

`--inbound-instruction` is **optional** — it's the system prompt the AI voice agent uses on calls *to* your number. If you omit it when your first number is provisioned, a sensible default greeting is used. It's ignored when signing in to an existing account. Change it any time with `dial number set <number> --inbound-instruction "..."`.

On success, writes your API key to `~/.local/share/dial/auth.json` (mode 0600) and prints a masked fingerprint. The CLI reads the key from that file for subsequent commands — you don't need to copy it.

**Install the Dial skill into your own agent** by adding `--agent <name>` — match it to whichever agent you (the agent reading this) are running in. This gives you durable, on-disk knowledge of the full `dial` surface, so future tasks don't need this page re-fetched:

```bash
dial onboard --code 123456 \
--inbound-instruction "..." \
--agent claude-code
```

Supported `--agent` values: `claude-code`, `cursor`, `codex`, `opencode`, `pi`, `openclaw`, `nanoclaw`, `hermes`. For `nanoclaw` only, run the command from inside the NanoClaw project root (its skills are project-scoped). Re-run `dial onboard --agent <name>` after a CLI upgrade to refresh the installed skill.

**Finalize onboarding — but only if `dial onboard` offers it.** Whether to install the background notification listening service is the CLI's decision, not yours; its output tells you which way to go:

- If `dial onboard` **offers** the service — `--json` sets `agentHint.action` to `"ask_user"`, and the human output prints an "ask the user" finalization block — then ask the user the question below before continuing. If the original request was something else (e.g. "call X", "send Y"), briefly pause that task, ask, get an answer, then resume.
- If `dial onboard` reports the service **unavailable** and says it's skipping the offer — `--json` sets `agentHint.action` to `"skip"`; this is normal in sandboxes / containers / CI without launchd or systemd — then **don't ask**. Just continue with the original task; inbound events still work via `dial wait-for`.

When you do ask:
- Call it **"the background notification listening service"**. Don't say plist / daemon / launchd / systemd — that's not how to talk to a non-technical user.
- Explain the trade-off: with it, the agent on this machine learns about inbound SMS (2FA codes, replies) and call-ended events in real time. Without it the agent is send-only — it can place calls and send messages but can't observe anything inbound.
- Use your structured ask-user / clarification tool if you have one; otherwise ask in your regular reply and wait for the answer.

### Step 5 — (Conditional) Install the background notification listening service

Only run this if `dial onboard` offered the service **and** the user answered **yes** in Step 4 (skip it entirely if onboard reported the service unavailable):

```bash
dial listen install
```

This needs a user service supervisor — **launchd** on macOS, **systemd `--user`** on Linux. In sandboxes, containers, or CI without one, `dial onboard` detects this and reports the service as unavailable; **skip this step there**. Inbound events still work without the daemon: `dial wait-for` automatically long-polls the API when the daemon isn't running.

After Steps 4–5, run `dial doctor` again — `nextStep` should be `ready`.

---

## Everything else lives in the installed skill + `dial --help`

Once you've onboarded (and ideally installed the skill with `--agent`), use that — not this page — for day-to-day work. The CLI is the source of truth:

```bash
dial --help # all commands
dial <command> --help # flags + usage for one command
```

Every command takes `--json` for machine-readable output. The common verbs:

- **Send an SMS** — `dial message --to +1… --body "…"`
- **Show a typing indicator while composing** — `dial typing start --to-number +1…`; sending a message clears it natively, so start again between messages, and run `dial typing stop --to-number +1…` if you end up not sending. iMessage numbers display it; SMS numbers ignore it, so it's always safe
- **Place an AI voice call** — `dial call --to +1… --outbound-instruction "…"`, then `dial call get <id>` once it ends
- **Set a number's inbound behavior** — `dial number set <number> --inbound-instruction "…"` (add `--inbound-language <bcp47>` to pin inbound calls to one language instead of auto-detecting from the caller)
- **Set an iMessage number's display identity** — `dial number set <number> --first-name Maya --last-name Chen --avatar ./photo.png` (the name and photo shown beside its messages in recipients' Messages apps; iMessage numbers only; a photo can be replaced but not removed)
- **Receive a 2FA code / react to a call ending** — `dial wait-for message.received -f channel=sms` / `dial wait-for call.ended -f callId=<id>`

`dial wait-for` reads from the local listen log when the daemon is running and **transparently long-polls the REST API when it isn't** — same filter semantics either way. A match exits `0`; a timeout or fallback error exits non-zero. Run `dial wait-for --help` for its filter flags.

**Full reference:** https://docs.getdial.ai — every page has a plain-markdown twin (append `.md` to any docs URL). To search capabilities without reading the whole site, grep `https://docs.getdial.ai/llms-full.txt`.

---

## Security Rules

- Never expose your API key (`sk_live_...`) in client-side code or logs — store it in environment variables / the auth file only.
- All requests must use HTTPS.
- Emergency services (911, crisis lines) are blocked.

---

## Pricing

- **$5 signup credit** — start free, no credit card required.
- **Pay-as-you-go:** $3/month per phone number plus metered usage (calls per minute, SMS priced by destination), drawn from your prepaid credit; spend pauses at $0.
- **Free accounts** (no top-up or subscription yet) are capped at **5 minutes per call** and **2 concurrent calls**; both limits lift permanently on the first top-up or subscription.
- **Subscription (optional):** switch any number to a flat monthly or annual per-number plan (annual discounted) with unmetered usage.
- **iMessage numbers are pay-as-you-go only** — they can't be added to a subscription, and an account holding one can't subscribe until it's released.

Current rates and billing management: `https://getdial.ai/dashboard/billing`

---

Full docs: https://docs.getdial.ai
Support: [email protected]