Discord Verification With a Real-SIM API for AI Agents (2026)

Why Discord Rejects VoIP — And Why Your Agent Stalls

Build any AI agent that signs up for Discord — moderation bot operator, multi-server outreach, regional community manager, even a one-off QA harness — and you hit the same wall: the SMS gate. Discord runs a deterministic carrier-prefix check at the moment of signup. If the prefix belongs to a known VoIP range — Twilio, Bandwidth, Plivo, Vonage, or any of the cheap aggregators that appear on the front page when you Google “cheap SMS API” — the request is dropped before it leaves the platform’s queue. The agent waits forever for an SMS that was never sent.

That failure mode is uniquely bad for autonomous agents. The HTTP response from the verification provider looks fine (number purchased, no error). The Discord signup form looks fine (“we’ve sent you a code”). The agent dutifully polls for an SMS that does not exist, the timeout fires, and the agent retries with another number from the same VoIP pool. Same wall. Same wasted credit. Add it up across a multi-account pipeline and you have an agent that burns budget infinitely on dead activations.

The mechanism is unpacked in the VoIP vs physical SIM deep-dive. The short version is that Discord — like WhatsApp, Telegram, Tinder, and most major consumer platforms — has zero appetite for the throwaway-VoIP signup pattern, and the carrier-prefix check is the cheapest way for them to enforce it. The fix is upstream: the agent needs a verification backend that delivers numbers from real mobile carriers, not VoIP aggregators.

The Real-SIM API Fix — VirtualSMS for Discord Agents

VirtualSMS supplies real-SIM phone numbers across 145+ countries and 2,500+ services — Discord, WhatsApp, Telegram, Tinder, Google, X, Bumble, Snapchat, the long tail. From an agent’s perspective, the integration shape is identical to any other verification API: buy a number, wait for the SMS, get the code. What changes is that the SMS actually arrives, because the underlying number sits in a real mobile carrier’s prefix range — not a VoIP aggregator.

Two surfaces are available, both expose the same backend, and both are designed for autonomous agents:

• MCP server — install once with one command, and the agent gains 18 SMS-verification tools natively. Best for Claude Desktop, Claude Code, or any other MCP-compatible agent runtime. See the Claude MCP setup guide.
• REST API — three endpoints (buy, poll, cancel) with Bearer-token auth. Best for LangChain, OpenAI Assistants, CrewAI, or any custom orchestration outside the MCP ecosystem. Full spec at the API docs.

Path A — Install the VirtualSMS MCP Server (Claude / MCP runtimes)

If your agent runs inside Claude Desktop, Claude Code, or any MCP-compatible client (Cursor, Continue, Cline, etc.) the integration is one command:

claude mcp add --scope user virtualsms \
  -- npx -y virtualsms-mcp \
  -e VIRTUALSMS_API_KEY=vsms_your_api_key_here

Restart the agent runtime and the VirtualSMS tools light up. The agent can now respond to a prompt like:

Buy the cheapest Discord activation number from the UK,
wait up to 5 minutes for the verification SMS, and return the
six-digit code. If the SMS doesn't arrive, swap_number once
before giving up.

Behind the scenes the agent calls buy_number(service="discord", country="uk"), wait_for_code(order_id=…), and swap_number(order_id=…) as needed — no wrapper code required. For the full 18-tool catalog and three production workflow patterns, read the Claude + VirtualSMS MCP workflow guide.

The MCP server also runs as a hosted endpoint at https://mcp.virtualsms.io/mcp for zero-install adoption — pass your key in the x-api-key header and you’re live. Pick stdio for local-first sandboxes, hosted HTTP for serverless agent runtimes.

Path B — Three REST Calls (LangChain / OpenAI / CrewAI / custom)

For agents outside the MCP ecosystem, the REST API is three endpoints. Bearer-token auth in the Authorization header. Get a key in 30 seconds at the API docs — no KYC, no platform fee, no minimum spend.

1. Discover the cheapest country (optional, unauthenticated)

# 1. (Optional) Discover the cheapest Discord country — unauthenticated
curl https://api.virtualsms.io/v1/services/discord/cheapest

2. Buy a real-SIM number for Discord

# 2. Buy a real-SIM number for Discord (UK in this example)
curl -X POST https://api.virtualsms.io/v1/orders \
  -H "Authorization: Bearer $VIRTUALSMS_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"service": "discord", "country": "uk"}'

# Response:
# { "id": "ord_8FQ...", "phone": "+447700900123", "price": 0.05, "status": "waiting" }

3. Poll for the SMS code

# 3. Poll for the SMS code (or use the wait-for-code WebSocket)
curl -H "Authorization: Bearer $VIRTUALSMS_API_KEY" \
  https://api.virtualsms.io/v1/orders/ord_8FQ...

# Response when the SMS lands:
# { "id": "ord_8FQ...", "phone": "+447700900123",
#   "code": "374912", "sms": "Your Discord code is 374912.",
#   "status": "completed" }

For higher throughput (5-figure activations/month), swap the polling loop for the WebSocket-backed wait_for_code endpoint — same wrapper shape, no wasted HTTP. The same pattern works for any of the 2,500+ supported services — see the full service list.

4. Cancel-on-timeout (auto-refunds)

# 4. Cancel-on-timeout — auto-refund if no SMS arrived
curl -X POST -H "Authorization: Bearer $VIRTUALSMS_API_KEY" \
  https://api.virtualsms.io/v1/orders/ord_8FQ.../cancel

The cancel call is the safety net. Failed activations auto-refund — the agent loop never consumes budget on a number that never received an SMS.

Reference Python Script — Drop Into Any Agent

The full integration in ~25 lines of Python. Works as a LangChain @tool body, an OpenAI Assistants function handler, or a Claude tool-use dispatcher — wrap as needed:

import os, time, requests

API = "https://api.virtualsms.io/v1"
KEY = os.environ["VIRTUALSMS_API_KEY"]
H   = {"Authorization": f"Bearer {KEY}"}

def verify_discord(country: str = "uk", timeout_s: int = 300) -> dict:
    """Buy a real-SIM number for Discord, wait for the SMS code, return it.
    Auto-cancels (and auto-refunds) on timeout."""
    order = requests.post(
        f"{API}/orders", headers=H,
        json={"service": "discord", "country": country},
    ).json()
    oid, phone = order["id"], order["phone"]

    deadline = time.time() + timeout_s
    while time.time() < deadline:
        sms = requests.get(f"{API}/orders/{oid}", headers=H).json()
        if sms.get("code"):
            return {"phone": phone, "code": sms["code"]}
        time.sleep(3)

    requests.post(f"{API}/orders/{oid}/cancel", headers=H)
    return {"error": "timeout — order auto-cancelled and refunded",
            "phone": phone}

if __name__ == "__main__":
    print(verify_discord("uk"))

Drop this into your agent and it can sign up for Discord on demand. For the full multi-framework wrapping examples (LangChain decorator, OpenAI JSON schema, CrewAI agent role, Claude tool-use), see the AI agent phone verification guide. For the broader strategic context — why agents need this primitive at all — read the post on why AI agents need real phone numbers.

Pricing + Rate Limits — Built For Agent Throughput

• Activations from $0.05 per SMS code. Exact price per service+country is visible on the live pricing page and via the API.
• Auto-refund on no-SMS. Failed activations cost zero. The agent loop can retry without cost paranoia.
• 120 requests/min per API key default rate limit. Production accounts can be lifted higher — email [email protected] with expected throughput.
• Multi-chain crypto deposits. Top up via USDC on Base, Tron, Polygon, Arbitrum, Solana, or BNB Chain. Crypto deposit fees are cents, not dollars. No KYC, no monthly minimum, unused balance never expires.
• Discovery endpoints are free. The agent can plan before committing spend.

For a deposit-first, pay-per-call model where the agent settles its own balance via HTTP 402, see the companion guide on x402 SMS verification.

Comparison — VoIP API vs Real-SIM API for Discord

The economics flip the moment you account for failed activations. A VoIP API that’s “cheaper” per-message but rejected by Discord costs infinity per successful verification. A real-SIM API at $0.05/code with ~95% delivery and auto-refund on the failures costs roughly $0.05 per successful verification. The decision is structural, not price-shopping.

Troubleshooting — When The SMS Doesn’t Arrive

Symptom: order completes, no code after 5 minutes

Cancel the order (auto-refund), then call list_countries and pick a different country with stock. UK / Germany / Netherlands are the highest-trust ranges for Discord — default to one of these and only fall back to mid-tier countries when stock runs thin.

Symptom: Discord rejects “invalid phone number”

Country mismatch — the agent picked a country whose mobile prefix Discord soft-blocks for new accounts. Swap to UK / Germany / Netherlands and retry. The discovery endpoint find_cheapest already filters by service compatibility.

Symptom: agent loops on the same failure

Almost always the agent is wired to a VoIP backend, not a real-SIM API — confirm the verification provider. The reference Python on this page is wired to VirtualSMS by default; if you see this symptom, double-check the API base URL hasn’t been swapped.