DEV Community: Fathin Dosunmu

Why Claude Code Agents Get Stuck on Phone Verification (And How to Fix It)

Fathin Dosunmu — Tue, 07 Apr 2026 09:35:49 +0000

Why Claude Code Agents Get Stuck on Phone Verification (And How to Fix It)

Claude Code is the hottest developer tool of 2026. But there is a hidden bottleneck that kills agent workflows before they even start.

It is phone verification.

The Problem

You set up Claude Code. You give it access to your repo. It starts working then hits a wall. The agent needs to sign up for an API, create a service account, or verify a webhook. Every single one asks for a phone number.

You give it a VoIP number. It gets rejected.

This is not a Claude Code problem. It is the fundamental infrastructure problem for every autonomous AI agent in 2026.

Why AI Agents Cannot Use Regular Phone Numbers

Services use carrier lookup databases (LERG, NPAC) to check if a phone number is a real mobile line or a VoIP/virtual number. AI agents typically get assigned VoIP numbers from:

Twilio virtual numbers
Google Voice
SMS-Activate and similar bulk providers
Cloud communication platforms

These get flagged as non-wireless in carrier databases. When Stripe, Google, or any serious platform runs a carrier lookup, the verification fails even if the number can technically receive SMS.

Real SIM cards pass carrier lookup. Virtual numbers do not. That is the entire game.

The Fix: Real SIM Phone API for AI Agents

Instead of routing through virtual numbers, give your agent a real SIM-backed phone number. The carrier lookup sees it as a legitimate mobile line because it is one.

from agentsim import AgentSIM

sim = AgentSIM(api_key="your-api-key")
result = sim.provision(country="US")
print(f"Agent phone: {result.phone_number}")

otp = sim.wait_for_otp(session_id=result.session_id)
print(f"Verification code: {otp.code}")

The agent now has a phone number that passes carrier lookup on Stripe, Google, WhatsApp, and every other service that checks.

Why This Matters for Claude Code Specifically

Claude Code is not just writing code anymore. It is:

Setting up infrastructure (deploying to Vercel, Railway, AWS)
Creating service accounts (database connections, API keys, webhooks)
Managing deployments (domain verification, SSL certificates)
Integrating third-party services (payment processors, notification systems)

Every single one of these tasks can trigger phone verification. Your agent hits one and the entire workflow stops.

A real SIM number removes the bottleneck entirely.

Cost Comparison

Solution	Cost	Passes Carrier Lookup
Twilio virtual	$1/month	No
Google Voice	Free	No
SMS-Activate	$0.10/number	Sometimes
Real SIM API	$0.99/session	Yes
Physical SIM plus modem	$30+/month	Yes

For an agent that needs verification occasionally, the per-session model is the sweet spot. You only pay when your agent actually needs a number.

When to Use This

Building autonomous agents that sign up for services
Claude Code workflows that deploy infrastructure
AI agents that need WhatsApp Business API access
Any agent hitting phone number rejected errors
Testing verification flows without burning real numbers

Getting Started

AgentSIM provides real SIM phone numbers as an API built specifically for AI agent workflows. It is MCP-native, so it integrates directly with Claude Code, Cursor, and any agent framework.

10 free sessions per month. After that, $0.99/session.

AgentSIM: https://agentsim.dev

Built this because my own agents kept hitting phone verification walls. If you are running autonomous agents in 2026, you will hit this too. Might as well solve it once.

I Built an Autonomous Phone Verification Agent (Full Code + Tutorial)

Fathin Dosunmu — Mon, 06 Apr 2026 22:28:52 +0000

You built an AI agent that can browse the web, fill forms, and make decisions. But it hits a wall every single time:

"This phone number cannot be used for verification."

Stripe. WhatsApp. Google. All of them run a carrier lookup. All of them block VoIP. And every cloud phone API returns line_type: VoIP.

Your agent is stuck. Not because it's dumb. Because the infrastructure is wrong.

Today I'll show you how to fix it. Full code. Real results.

The Problem in 30 Seconds

When Stripe receives a phone number, it doesn't just send an SMS. First, it queries the LERG/NPAC databases to check: what type of number is this?

$ curl https://lookups.twilio.com/v2/PhoneNumbers/+16505550001
{
  "line_type_intelligence": {
    "type": "voip",
    "carrier": "Twilio Inc."
  }
}

Result: REJECTED. Stripe blocks VoIP numbers for verification. Always.

The same check happens at Google, WhatsApp, Telegram, banks. If your agent uses a cloud phone number, it will fail.

The Fix: Real SIM Infrastructure

The solution isn't a hack. It's the right infrastructure. AgentSIM provisions numbers on real physical SIM cards through Telnyx. Carrier lookup returns line_type: mobile -- exactly what Stripe, Google, and WhatsApp expect.

$ agentsim.provision({ country: "US" })
{
  "number": "+14155551234",
  "carrier": "T-Mobile",
  "line_type": "mobile"
}

Building the Agent

Here's the complete code. Three steps. ~3.5 seconds end to end.

Step 1: Install

pip install agentsim

Step 2: Provision a Number

import asyncio
from agentsim import AgentSIM

async def main():
    agentsim = AgentSIM(api_key="your-api-key")

    number = await agentsim.provision({
        "country": "US",
        "capabilities": ["sms"],
    })

    print(f"Number: {number.number}")
    print(f"Carrier: {number.carrier}")
    # Number: +14155551234
    # Carrier: T-Mobile

Step 3: Wait for OTP

    otp = await number.wait_for_otp(timeout=30_000)

    print(f"OTP: {otp.code}")
    print(f"Service: {otp.service}")
    # OTP: 847291
    # Service: stripe

That's it. The OTP is parsed automatically -- code extracted, service detected, structured JSON returned. No regex. No human reading SMS.

Full Autonomous Flow with Playwright

from playwright.async_api import async_playwright

async def verify_on_stripe():
    number = await agentsim.provision({"country": "US"})

    async with async_playwright() as p:
        browser = await p.chromium.launch()
        page = await browser.new_page()
        await page.goto("https://connect.stripe.com/setup")
        await page.fill("input[name='phone']", number.number)
        await page.click("button[type='submit']")

        otp = await number.wait_for_otp(timeout=30_000)
        await page.fill("input[name='code']", otp.code)
        await page.click("button[type='submit']")

        print("Phone verified")
        await browser.close()

Real Performance Numbers

This isn't theoretical. Here's what's running in production:

Provision time: 212ms average
OTP delivery: 3.5s average
Cost: $0.99 per session (provision + OTP + release)

Compare to alternatives:

Solution	Cost	Carrier Result
Twilio	$1.15/number + usage	line_type: VoIP (blocked)
JoltSMS	$50/number/month	line_type: mobile (works)
Shared virtual	$0.30-2/number	line_type: VoIP (blocked)
AgentSIM	$0.99/session	line_type: mobile (works)

At 100 verifications/month: JoltSMS costs $5,000. AgentSIM costs $99. 50x cheaper.

Why This Matters for AI Agents

AI agents are autonomous by design. They browse, decide, and act. But if every action that requires phone verification needs a human to read an SMS, your agent isn't autonomous -- it's a puppet.

Real SIM infrastructure removes the last human bottleneck. Your agent can:

Create and verify Stripe Connect accounts
Set up WhatsApp Business API
Verify Google accounts for service access
Register on any platform requiring SMS verification

All without human involvement.

MCP Native

If you're building with Claude Code, Cursor, or Windsurf -- AgentSIM has a built-in MCP server. One command to add it:

claude mcp add agentsim -- npx -y @agentsim/mcp-server

Now your agent can provision numbers through natural language: "I need a US phone number to verify a Stripe account"

Try It Free

AgentSIM gives you 10 free sessions per month -- no credit card, no commitment. If the OTP doesn't arrive, you're not charged.

Get started at agentsim.dev/sign-up

One session = one number, one OTP, one verification. Your agent does the rest.

Open source at github.com/agentsimdev/agentsim. Docs at docs.agentsim.dev.

The Complete Guide to Phone Verification for AI Agents in 2026

Fathin Dosunmu — Sun, 29 Mar 2026 20:23:26 +0000

This is the definitive reference for phone verification in the AI agent ecosystem. Whether you're building browser automation, account creation workflows, or multi-service onboarding — this guide covers every approach, what works, what doesn't, and why.

The Verification Landscape in 2026

Phone verification is now the primary gatekeeper for online services. As AI agents become more capable, the verification infrastructure has evolved to detect and block automated signups.

Services That Block VoIP Numbers

Service	Block Severity	Error Message
Stripe	Hard block	"This phone number cannot be used for verification"
Google	Hard block + behavioral	"This number cannot be used"
WhatsApp	Hard block	"Unsupported phone numbers, such as VoIP"
Amazon	Silent failure	Code never arrives
Microsoft	Risk-based	Error 399287 "BadReputation"
Vercel	Hard block	Registration rejected
DocuSign	Hard block	Registration rejected
Banks	Hard block	Varies

The Detection Stack

Every major service uses some combination of:

LERG lookup — Checks carrier and line type from the master phone database
NPAC query — Checks if the number was ported from mobile to VoIP
HLR query — Real-time check of mobile network registration
Behavioral analysis — Pattern detection (creation velocity, geographic consistency)
Reputation scoring — Number history, abuse reports, fraud databases

Every Approach Ranked

❌ Twilio / Vonage / VoIP Providers

Cost: $1-15/month per number
Success rate: 0% on Stripe, Google, WhatsApp, banks
Why it fails: Numbers registered as voip in LERG. Every service blocks them.
When to use: Voice bots, customer support, non-verification use cases

❌ Google Voice / TextNow / Free Services

Cost: Free
Success rate: 0% on most services
Why it fails: Same VoIP detection. Plus, automating these violates ToS.
When to use: Never for production AI agents

⚠️ Prepaid SIM Cards (Manual)

Cost: $3-10 per SIM + manual labor
Success rate: ~90% (some services block prepaid)
Why it's problematic: Doesn't scale. Requires physical SIM management, manual number rotation, and someone physically handling the phones.
When to use: One-off testing, not production automation

✅ AgentSIM (Real SIM API)

Cost: $0.99/session, 10 free/month
Success rate: 98-100% across all services
Why it works: Real SIM cards on real carrier networks (T-Mobile, AT&T, Verizon). Numbers pass LERG, NPAC, and HLR checks because they ARE mobile numbers.
When to use: Production AI agent verification at any scale

Implementation Guide

Installation

pip install agentsim-sdk

Pattern 1: Basic OTP Verification

import agentsim

agentsim.configure(api_key="asm_live_xxx")

async with agentsim.provision(agent_id="signup-bot", country="US") as num:
    # num.number is a real E.164 mobile number
    print(f"Phone: {num.number}")  # +14155552671

    # Enter number on whatever service needs verification
    await enter_phone_number(num.number)

    # Wait for OTP — real SMS on real SIM
    otp = await num.wait_for_otp(timeout=60)
    print(f"Code: {otp.otp_code}")  # "391847"

    await enter_verification_code(otp.otp_code)
# Number auto-released when context exits

Pattern 2: With Browser Automation (Playwright)

import agentsim
from playwright.async_api import async_playwright

agentsim.configure(api_key="asm_live_xxx")

async def automated_signup(service_url):
    async with async_playwright() as p:
        browser = await p.chromium.launch()
        page = await browser.new_page()
        await page.goto(service_url)

        async with agentsim.provision(
            agent_id="browser-signup",
            country="US"
        ) as num:
            # Fill phone field
            await page.fill('[type="tel"]', num.number)
            await page.click('button:has-text("Send")')

            # Get OTP from real SIM
            otp = await num.wait_for_otp(timeout=60)

            # Enter code
            await page.fill('[name="code"]', otp.otp_code)
            await page.click('button:has-text("Verify")')

        await browser.close()

Pattern 3: Synchronous (Non-Async)

import agentsim

agentsim.configure(api_key="asm_live_xxx")

with agentsim.provision_sync(agent_id="sync-bot") as num:
    print(num.number)
    enter_phone(num.number)

    otp = num.wait_for_otp_sync(timeout=60)
    enter_code(otp.otp_code)

Pattern 4: MCP Integration (Claude Code / Cursor / Windsurf)

{
  "mcpServers": {
    "agentsim": {
      "url": "https://mcp.agentsim.dev/mcp",
      "headers": {
        "Authorization": "Bearer asm_live_xxx"
      }
    }
  }
}

Your AI agent calls provision_number and wait_for_otp as MCP tools — no SDK installation needed.

Pattern 5: Auto-Rerouting (Fallback Countries)

async with agentsim.provision(agent_id="global-bot", country="US") as num:
    otp = await num.wait_for_otp(
        timeout=60,
        auto_reroute=True,      # Try another country if US fails
        max_reroutes=2,
        on_reregistration_needed=handle_new_number
    )

Error Handling

from agentsim.exceptions import (
    OtpTimeoutError,
    PoolExhaustedError,
    RateLimitError
)

try:
    async with agentsim.provision(agent_id="bot") as num:
        otp = await num.wait_for_otp(timeout=60)
except OtpTimeoutError:
    print("SMS didn't arrive in 60s — service may have blocked this number")
except PoolExhaustedError:
    print("No numbers available — try a different country")
except RateLimitError:
    print("Too many requests — back off and retry")

Cost Comparison

Solution	Setup cost	Per-verification cost	Stripe	Google	WhatsApp
Twilio	$0	$1.15/number + SMS	❌	❌	❌
Google Voice	$0	Free	❌	❌	❌
Prepaid SIM	$5-10/SIM	Manual labor	⚠️	⚠️	⚠️
AgentSIM	$0	$0.99/session	✅	✅	✅

Free tier: 10 sessions/month. No subscription required.

Best Practices

Rate limit aggressively — Most bans come from velocity, not carrier detection
Use realistic browser fingerprints — Headless detection is separate from phone verification
Rotate IPs — Don't create multiple accounts from the same IP
Warm up accounts — Login and use accounts normally after creation
Handle failures gracefully — Use try/except with AgentSIM's typed exceptions

VoIP vs Real SIM: Why Your AI Agent Phone Number Gets Blocked

Fathin Dosunmu — Sun, 29 Mar 2026 20:23:14 +0000

Every week, a developer posts on Stack Overflow or Reddit: "My Twilio number gets rejected at Stripe/Google/WhatsApp." The answer is always the same — VoIP numbers fail carrier lookup. But why?

This is the deep technical explanation of how carrier detection works, what databases are involved, and why real SIM is the only reliable solution for AI agent verification.

The Carrier Lookup Infrastructure

When a service like Stripe verifies your phone number, it doesn't just check a blocklist. It queries a chain of authoritative databases:

LERG (Local Exchange Routing Guide)

The LERG is the master database of North American phone numbers. Maintained by iconectiv (formerly Telcordia), it maps every NPA-NXX (area code + exchange) to:

Operating Company Number (OCN) — Who owns this number block
Line type — Mobile, landline, VoIP, toll-free
Rate center — Geographic location
LATA — Local Access and Transport Area

When Twilio buys a block of numbers from Bandwidth, those numbers are registered in LERG under Bandwidth's OCN with line_type voip. This is permanent and public.

NPAC (Number Portability Administration Center)

NPAC tracks ported numbers. If a number was originally Verizon mobile but got ported to Twilio, NPAC records this. Services that do deep verification check NPAC to see if a mobile number was ported to a VoIP provider.

HLR (Home Location Register)

The HLR is the real-time database on each carrier's network. When you query a T-Mobile number via HLR, it returns:

Whether the number is currently registered on the network
The IMSI (International Mobile Subscriber Identity)
The serving MSC (Mobile Switching Center)
Roaming status

VoIP numbers don't exist in any HLR — they route through internet gateways, not cell towers.

How Services Use This Data

Stripe's Approach

1. Receive phone number
2. Query LERG → Get OCN and line_type
3. If line_type = "voip" → REJECT
4. If line_type = "mobile" → Query HLR for active registration
5. If HLR active → SEND SMS

Google's Approach (More Aggressive)

1. Receive phone number
2. Query LERG → Get carrier and line_type
3. If line_type = "voip" → REJECT
4. If carrier is known VoIP provider (even if line_type is ambiguous) → REJECT
5. Query HLR → Check active mobile registration
6. Check behavioral patterns (creation velocity, geo-consistency)
7. If all checks pass → SEND SMS

WhatsApp's Approach (Strictest)

1. Receive phone number
2. Query LERG + NPAC for current carrier
3. Check against WhatsApp's internal VoIP blocklist
4. Query HLR for active mobile registration
5. Check number history (spam reports, previous bans)
6. If all checks pass → SEND SMS

Why VoIP Numbers Are Detectable

It's not just about databases. VoIP numbers have fundamental technical differences:

Network Topology

Mobile: Phone → Cell tower → MSC → SMS Center → Delivery
VoIP: API call → Internet → SIP gateway → SMS aggregator → Delivery

The routing path is different. Services can detect SIP gateways in the delivery chain.

Number Allocation

Mobile carriers get number blocks directly from regulators
VoIP providers lease from wholesale carriers (Bandwidth, Peerless)
LERG records who owns each block — this is public information

Registration Status

Mobile: Continuously registered with a cell tower via SIM card
VoIP: No network registration. Numbers exist only in software databases

Real SIM vs VoIP: Technical Comparison

Characteristic	VoIP Number	Real SIM Number
LERG line_type	`voip` or `nonFixedVoip`	`mobile`
HLR registration	❌ None	✅ Active on tower
Carrier in LERG	Twilio/Bandwidth/Vonage	T-Mobile/AT&T/Verizon
Physical SIM card	❌ No	✅ Yes
Cell tower connection	❌ No	✅ Yes
IMSI on network	❌ No	✅ Yes
SMS routing	Internet → SIP gateway	Carrier SMS Center
Stripe verification	❌ 0% success	✅ 100% success
Google verification	❌ 0% success	✅ 98% success
WhatsApp verification	❌ 0% success	✅ 100% success

AgentSIM: Real SIM for AI Agents

AgentSIM bridges the gap. It provisions actual SIM cards on carrier networks and exposes them via API:

import agentsim

agentsim.configure(api_key="asm_live_xxx")

async with agentsim.provision(agent_id="my-agent", country="US") as num:
    print(num.number)       # +14155552671 (real T-Mobile number)

    # This number passes LERG, NPAC, and HLR checks
    # because it IS a real mobile number

    otp = await num.wait_for_otp(timeout=60)
    print(otp.otp_code)     # "391847"
# Auto-released

MCP Integration

{
  "mcpServers": {
    "agentsim": {
      "url": "https://mcp.agentsim.dev/mcp",
      "headers": {
        "Authorization": "Bearer asm_live_xxx"
      }
    }
  }
}

The Bottom Line

VoIP detection isn't going away. It's getting more sophisticated as fraud scales. The only reliable solution for AI agents that need phone verification is real SIM-backed numbers.

Install: pip install agentsim-sdk
Try it: agentsim.dev — 10 free sessions/month
Docs: docs.agentsim.dev
GitHub: github.com/agentsimdev

Fix: WhatsApp 'Unsupported phone numbers such as VoIP' for AI Agents

Fathin Dosunmu — Sun, 29 Mar 2026 20:22:06 +0000

If you're building AI agents that need WhatsApp Business API access, you've seen this:

Unsupported phone numbers, such as VoIP, landlines, and premium rate numbers

WhatsApp has the strictest phone verification in the industry. Here's why, and how to solve it.

WhatsApp's Verification Requirements

WhatsApp's official FAQ is explicit:

"Unsupported phone numbers, such as VoIP, landlines, and premium rate numbers, are not eligible for registration."

Unlike Stripe or Google which silently reject, WhatsApp tells you exactly why. Their system performs:

Carrier database lookup — Checks LERG/NPAC for line type
HLR query — Verifies active mobile network registration
Historical abuse check — Numbers previously used for spam are permanently blocked
Country-carrier validation — Number must be from a carrier operating in the declared country

Why WhatsApp Is Stricter

WhatsApp is the primary communication platform in 180+ countries. They block VoIP because:

Spam prevention: VoIP numbers are 40x more likely to be used for bulk spam
Identity verification: Each WhatsApp account = one real person/business
Carrier agreements: Meta has direct relationships with mobile carriers worldwide

Every VoIP Provider Fails

Provider	WhatsApp result	Error message
Twilio	❌ Blocked	"Unsupported phone number"
Vonage	❌ Blocked	"Unsupported phone number"
Google Voice	❌ Blocked	"Unsupported phone number"
Bandwidth	❌ Blocked	"Unsupported phone number"
AgentSIM	✅ Passes	Registration successful

The Fix: AgentSIM for WhatsApp

AgentSIM numbers pass WhatsApp verification because they're real SIM cards on real mobile networks.

Install

pip install agentsim-sdk

WhatsApp Business API Registration

import agentsim
import asyncio

agentsim.configure(api_key="asm_live_xxx")

async def register_whatsapp_business():
    async with agentsim.provision(
        agent_id="whatsapp-setup",
        country="US"
    ) as num:
        print(f"Registering WhatsApp with: {num.number}")

        # Use the number in WhatsApp Business API registration
        # via Meta's Cloud API or on-premise API
        registration_response = await register_with_meta_api(
            phone_number=num.number,
            method="sms"  # or "voice"
        )

        # Wait for verification code
        otp = await num.wait_for_otp(timeout=120)
        print(f"WhatsApp code: {otp.otp_code}")

        # Complete verification
        await verify_with_meta_api(
            phone_number=num.number,
            code=otp.otp_code
        )

        print("WhatsApp Business registered!")
    # Number auto-released after context exit

asyncio.run(register_whatsapp_business())

With Playwright (Web Registration)

import agentsim
from playwright.async_api import async_playwright

agentsim.configure(api_key="asm_live_xxx")

async def register_whatsapp_web():
    async with async_playwright() as p:
        browser = await p.chromium.launch()
        page = await browser.new_page()

        await page.goto("https://business.facebook.com/wa/manage/phone-numbers/")

        async with agentsim.provision(
            agent_id="whatsapp-reg",
            country="US"
        ) as num:
            await page.fill('[name="phone"]', num.number)
            await page.click('button:has-text("Send code")')

            otp = await num.wait_for_otp(timeout=120)

            await page.fill('[name="code"]', otp.otp_code)
            await page.click('button:has-text("Verify")')

        await browser.close()

With MCP (Claude Code / Cursor)

{
  "mcpServers": {
    "agentsim": {
      "url": "https://mcp.agentsim.dev/mcp",
      "headers": {
        "Authorization": "Bearer asm_live_xxx"
      }
    }
  }
}

Carrier Verification Results

Check	VoIP Number	AgentSIM Number
LERG line_type	`voip`	`mobile`
Carrier name	Twilio Inc	T-Mobile USA
HLR status	No mobile registration	Active on network
WhatsApp eligible	❌ No	✅ Yes

Important Notes

One number per WhatsApp account — WhatsApp enforces 1:1 mapping
Number history matters — Previously-banned numbers may still be blocked
Business verification separate — Phone verification is step 1; Meta business verification is step 2
Keep the number active — WhatsApp may re-verify periodically

Cost

Approach	Monthly cost	WhatsApp success rate
Twilio	$1-15/number	0%
Google Voice	Free	0%
AgentSIM	$0.99/session	100%

Get Started

Try it: agentsim.dev
Docs: docs.agentsim.dev
GitHub: github.com/agentsimdev

10 free sessions per month. Real SIM numbers that pass WhatsApp's strict verification.

Fix: Stripe 'This phone number cannot be used for verification' with AI Agents

Fathin Dosunmu — Sun, 29 Mar 2026 20:03:50 +0000

If you're building AI agents that need to create Stripe accounts, you've hit this wall:

This phone number cannot be used for verification.

Your agent fills out the form perfectly, reaches phone verification, and — rejected. This guide explains exactly what's happening and how to solve it with real SIM-backed numbers.

Why Stripe Blocks Your Number

Stripe performs carrier lookups against multiple databases before sending any verification SMS:

LERG (Local Exchange Routing Guide) — The authoritative database of North American phone numbers
NPAC (Number Portability Administration Center) — Tracks number porting between carriers
Real-time HLR queries — Verify active network registration on the carrier side

If your number comes back as voip or nonFixedVoip, it's rejected immediately. The code is never sent.

Provider	line_type returned	Stripe result
Twilio	`voip`	❌ Blocked
Google Voice	`voip`	❌ Blocked
Vonage	`voip`	❌ Blocked
TextNow	`voip`	❌ Blocked
AgentSIM	`mobile`	✅ Passes

Why Twilio/VoIP Numbers Fail

Every VoIP provider's number ranges are catalogued in LERG. When Stripe queries:

{
  "number": "+19875551234",
  "carrier": "Twilio Inc",
  "line_type": "voip"
}

Instant rejection. This isn't a bug — it's by design. Financial services block VoIP to prevent synthetic identity fraud.

The Fix: Real SIM Numbers via AgentSIM

AgentSIM provisions actual SIM-backed phone numbers from carriers like T-Mobile. These return mobile in carrier lookups because they ARE mobile numbers.

Install

pip install agentsim-sdk

Basic Usage

import agentsim

agentsim.configure(api_key="asm_live_xxx")

async with agentsim.provision(agent_id="stripe-setup", country="US") as num:
    # num.number is a real mobile number (E.164 format)
    print(f"Using: {num.number}")  # +14155552671

    # Enter the number in Stripe verification form
    await enter_phone_on_stripe(num.number)

    # Wait for the OTP to arrive via real SMS
    otp = await num.wait_for_otp(timeout=60)
    print(f"Code: {otp.otp_code}")  # 391847

    # Enter the code — verification passes
    await enter_code_on_stripe(otp.otp_code)
# Number auto-released when context exits

With Playwright (Full Automation)

import agentsim
from playwright.async_api import async_playwright

agentsim.configure(api_key="asm_live_xxx")

async def verify_stripe_account():
    async with async_playwright() as p:
        browser = await p.chromium.launch()
        page = await browser.new_page()
        await page.goto("https://dashboard.stripe.com/register")

        await page.fill("[name=email]", "agent@company.com")

        async with agentsim.provision(
            agent_id="stripe-setup",
            country="US"
        ) as num:
            await page.fill("[name=phone]", num.number)
            await page.click("button:has-text(\"Send code\")")

            otp = await num.wait_for_otp(timeout=60)

            await page.fill("[name=code]", otp.otp_code)
            await page.click("button:has-text(\"Verify\")")

        await browser.close()

With MCP (Claude Code / Cursor / Windsurf)

If you're using an AI coding agent, AgentSIM has a native MCP server:

{
  "mcpServers": {
    "agentsim": {
      "url": "https://mcp.agentsim.dev/mcp",
      "headers": {
        "Authorization": "Bearer asm_live_xxx"
      }
    }
  }
}

Then your agent can call provision_number and wait_for_otp as MCP tools directly.

Why AgentSIM Numbers Pass

Check	VoIP Number	AgentSIM Number
LERG lookup	`voip`	`mobile`
Carrier name	Twilio Inc	T-Mobile USA
HLR query	No network reg	Active on tower
Fraud score	High (70-90)	Clean (0-10)

AgentSIM uses real SIM cards on real carrier networks. The numbers aren't spoofed or masked — they're genuine mobile numbers that pass every verification check.

Cost Comparison

Approach	Monthly cost	Stripe success rate
Twilio	$1-15/number	0%
Google Voice	Free (ToS risk)	0%
AgentSIM	$0.99/session	100%

10 free sessions per month. No subscription required.

Get Started

Try it: agentsim.dev
Docs: docs.agentsim.dev
MCP Server: Smithery · npm · PyPI
GitHub: github.com/agentsimdev

Stop fighting VoIP detection. Use real mobile numbers that work.

Why Your AI Agent's Phone Number Gets Blocked (And How to Fix It)

Fathin Dosunmu — Tue, 24 Mar 2026 13:46:06 +0000

You built an AI agent that onboards to a new service, creates an account, fills in a form, and gets all the way to SMS verification — then hits a wall.

"This phone number cannot be used for verification."

Or worse: the code is never sent and no error appears at all. Your agent just sits there waiting.

This is the VoIP blocking problem. It affects every AI agent that needs a real phone identity, and it's getting worse as fraud rates on virtual numbers rise. This guide explains exactly what's happening, why every major service blocks VoIP numbers, and what the working alternatives are.

The Problem: VoIP Numbers Fail Production Verification

Most developers building phone-capable AI agents reach for the obvious choices: Google Voice, TextNow, Twilio programmable numbers, Telnyx, or Vonage. These are cheap, API-accessible, and work fine in development. They fail in production.

The services your agent needs to verify with — Stripe, Google, Amazon, WhatsApp, Microsoft, financial institutions — all run carrier lookup checks before sending verification codes. If the lookup returns nonFixedVoip or fixedVoip, the request is rejected. The code is never sent.

Here's the list of confirmed blockers, with the evidence:

Service	Block Type	User-Facing Message
Stripe	Hard error	"This phone number cannot be used for verification"
Google	Silent or vague	"Something went wrong" / "This number cannot be used"
Amazon	Silent delivery failure	Code simply never arrives
WhatsApp	Hard error	"Unsupported phone numbers, such as VoIP, landlines..."
Microsoft Entra ID	Risk-based block	Error 399287 "BadReputation"
Vercel	Hard block at signup	Registration rejected
DocuSign	Hard block at signup	Registration rejected
Banks (BMO and others)	Silent or misleading	Codes not delivered, vague errors

These aren't edge cases. They're deliberate product decisions backed by fraud data, and the blocking is accelerating.

A fintech security professional on Hacker News described Stripe's logic directly:

"We reject VoIP phone numbers due to proven fraud activity. VoIP numbers can be obtained with no identity verification, recycled instantly after use, and are disproportionately associated with account takeover attempts."

WhatsApp's official FAQ states it explicitly:

"Unsupported phone numbers, such as VoIP, landlines, and premium rate numbers, are not eligible for registration."

Microsoft's documentation lists VoIP support status plainly:

"Phone extensions and VOIP numbers are not supported for MFA."

For AI agent developers, this creates a hard requirement: your agent needs a number that carrier lookup APIs classify as mobile, not voip. Understanding how that classification works is the first step to solving it.

How Carrier Lookup Works: The Technical Infrastructure

When Stripe, Google, or WhatsApp receives a phone number for verification, they don't just check a blocklist. They query a carrier lookup API that interrogates multiple interconnected telecom databases. Here's how the chain works.

Step 1: Parse NPA-NXX

Every US phone number in E.164 format starts with the country code (+1), followed by a 10-digit number. The first 6 digits — the NPA (Numbering Plan Area, aka area code) and NXX (exchange code, aka the first 3 of the 7-digit local number) — form the lookup key.

For example, +14155551234: NPA = 415, NXX = 555.

Step 2: Query the LERG

The Local Exchange Routing Guide (LERG) is a database published by iconectiv, the FCC-designated North American Numbering Plan Administrator. It maps every NPA-NXX block to an Operating Company Number (OCN).

The LERG contains multiple tables:

LERG1 — OCN information including carrier name, type, and state
LERG6 — NPA NXX assignments (which carrier owns which blocks)
LERG7 — Switch data
LERG12 — LRN (Location Routing Number) assignments

The OCN lookup tells you which carrier was originally assigned the number block.

Step 3: Check NPAC for Porting

Number portability changed everything. Under FCC LNP (Local Number Portability) rules, any US number can be ported from one carrier to another. The Number Portability Administration Center (NPAC), also operated by iconectiv, records every porting event.

When a number is ported, NPAC stores:

The current SPID (Service Provider ID)
The LRN (Location Routing Number) for routing
The porting date and history

The SPID is critical: it encodes the line type directly.

SPID Carrier Type	Line Type
Type 0	Wireline (ILEC)
Type 1	Wireline (CLEC)
Type 2	Wireless / Mobile
Type 3	VoIP

If NPAC shows a porting event and the current SPID has carrier type 3, the number is VoIP — even if the original LERG assignment was to a mobile carrier.

Step 4: Look Up OCN Type

Each OCN has a carrier type classification assigned by the FCC:

ILEC — Incumbent Local Exchange Carrier (traditional landline providers: AT&T, Verizon wireline)
CLEC — Competitive Local Exchange Carrier (alternative wireline providers)
WIRELESS — Mobile Network Operators (AT&T Mobility, T-Mobile, Verizon Wireless)
VOIP — Voice over IP providers (Google Voice, Twilio, Bandwidth, Lingo)
CABLE — Cable companies offering phone service (Comcast Xfinity, Cox)

Step 5: Classify and Return

The carrier lookup API combines the LERG OCN type and the NPAC porting data:

if current_spid_type == 3 → VoIP (ported to VoIP)
else if ocn_type == WIRELESS → mobile
else if ocn_type == VOIP → VoIP (never ported)
else if ocn_type == ILEC/CLEC/CABLE → landline

The result propagates into two major sub-categories for VoIP:

fixedVoip — VoIP numbers tied to a specific physical location or device. Examples: Comcast Business Voice, enterprise PBX systems, some CLEC offerings. These require a physical installation at a premises address. They're considered more legitimate and some services allow them.

nonFixedVoip — VoIP numbers that can be obtained online with no physical address or device requirement. Examples: Google Voice, TextNow, Vonage, Twilio programmable numbers, Telnyx numbers. These can be created with a credit card, no identity verification, and cancelled instantly. This is the category most aggressively blocked.

Additional Signals

Beyond the core LERG/NPAC/OCN chain, carrier lookup APIs may also query:

HLR (Home Location Register) — Mobile carrier subscriber databases. A failed HLR lookup for a supposedly mobile number is a strong VoIP indicator.
CNAM databases — Caller Name databases. VoIP numbers frequently show unusual or generic names.
ANI/SS7 Information Digits — In real-time call signaling, Information Digits classify the call origin. VoIP calls carry digit codes that differ from mobile calls.
Proprietary fraud databases — IPQS, Telesign, and others maintain additional lists of numbers with fraud history.

The Carrier Lookup API Ecosystem

There are eight major APIs developers use to perform carrier lookup. Understanding their differences helps you predict how the services your agent needs to verify with are classifying your numbers.

API	Provider	Pricing	Line Type Field	Notes
Twilio Lookup	Twilio	$0.008/req ($0.00385 volume)	`line_type_intelligence.type`: `landline`, `mobile`, `fixedVoip`, `nonFixedVoip`, `personal`, `tollFree`, `premium`, `unknown`	Industry standard; real-time NPAC; Stripe and Vercel use this
Telnyx Number Lookup	Telnyx	Pay-as-you-go; free tier	`carrier.type`: `voip`, `mobile`, `landline` + OCN, SPID, LRN, ported_status	Exposes raw OCN/SPID data; good for debugging
IPQS Phone Validation	IPQualityScore	Free tier + volume	`VOIP` (boolean) + `line_type`: `mobile`, `landline`, `VoIP`, `prepaid` + `fraud_score` (0–100)	Includes fraud scoring; claims 99%+ accuracy
Vonage Number Insight	Vonage (Ericsson)	Tiered: Basic/Standard/Advanced	`network_type`: `mobile`, `landline`, `virtual`, `unknown`, `pager`	"Virtual" maps to VoIP; Vonage uses it to block VoIP on their own platform
Abstract Phone Validation	AbstractAPI	Free 250/mo → tiered paid	`phone_carrier.line_type`: `Wireless`, `Landline`, `VOIP` + `is_voip` boolean	Good free tier; 190+ countries
Numverify	apilayer	Free 100/mo → $9.99–$99.99/mo	`line_type`: `mobile`, `landline`, `special_services`	No dedicated VoIP type; limited granularity
Ekata Phone Intelligence	Ekata (Mastercard)	Enterprise/custom	Carrier info, prepaid check, validity, velocity	200M+ monthly queries; enterprise fraud context
Telesign Phone ID	Telesign (TransUnion)	Pay-as-you-go; free trial	`phone_type`: `landline`, `mobile`, `VoIP` + carrier name, registration status	TransUnion identity network; banks and fintech use this

Code Example: Running Your Own Carrier Lookup

Before building anything, verify how your number is classified. Here's how to query Twilio's API directly:

from twilio.rest import Client

client = Client(account_sid, auth_token)

phone_number = client.lookups.v2.phone_numbers("+14155551234").fetch(
    fields="line_type_intelligence"
)

lti = phone_number.line_type_intelligence
print(f"Line type: {lti['type']}")          # e.g., "nonFixedVoip"
print(f"Mobile country code: {lti.get('mobile_country_code')}")
print(f"Mobile network code: {lti.get('mobile_network_code')}")
print(f"Error code: {lti.get('error_code')}")

import twilio from "twilio";

const client = twilio(accountSid, authToken);

const number = await client.lookups.v2
  .phoneNumbers("+14155551234")
  .fetch({ fields: "line_type_intelligence" });

const lti = number.lineTypeIntelligence;
console.log(`Line type: ${lti?.type}`);          // e.g., "nonFixedVoip"
console.log(`MCC: ${lti?.mobileCountryCode}`);
console.log(`MNC: ${lti?.mobileNetworkCode}`);

Run this on any number you plan to use with your agent. If you see nonFixedVoip or fixedVoip, that number will fail verification on Stripe, Google, WhatsApp, and most financial services.

Why Every Major Service Blocks VoIP: Service-by-Service Breakdown

Stripe

Stripe's phone verification runs during identity verification (Stripe Identity), account security setup, and certain high-risk payment flows. The technical mechanism combines:

Carrier lookup (Twilio Line Type Intelligence or equivalent)
Rejection if line_type_intelligence.type is fixedVoip or nonFixedVoip
Additional risk scoring: velocity checks, geographic mismatch between IP and carrier region, and number reputation

The error is explicit: "This phone number cannot be used for verification."

There's no workaround via retry or different country codes. The check is at the carrier level, not the number level. Using a different Twilio number won't help — all Twilio programmable numbers share the same OCN (Bandwidth, BW Communications, or similar CLEC/VoIP providers), and those OCNs are classified as VoIP.

Google

Google's blocking is more nuanced and less consistent than Stripe's, which makes it harder to debug. The mechanisms include:

Line-type checking at account creation. New Google account registrations check carrier type. Numbers classified as nonFixedVoip fail with "Something went wrong" or "This number cannot be used for verification."

Carrier range blacklisting. Google maintains its own reputation database of carrier OCN ranges with abuse history. Even mobile numbers from certain prepaid carriers or MVNOs with high abuse rates get blocked.

eSIM complications. A March 2026 Reddit thread in r/GMail documented widespread blocking of Philippine eSIM numbers despite them technically registering as mobile. Google appears to apply additional geographic and carrier-origin checks beyond the basic line-type lookup.

Amazon OTPs stopped routing to Google Voice. As documented in Google Support forum posts from May 2024: "Amazon will no longer send OTP codes to Google Voice numbers." This means Amazon specifically targeted the Google Voice OCN range for SMS filtering.

Amazon

Amazon's blocking operates at the SMS routing layer through AWS SNS (Simple Notification Service), which Amazon uses to send OTP codes for its verification flows.

The mechanism is carrier-type filtering: SNS checks the carrier type of the destination number before routing. If the number is VoIP, the message is silently dropped. No error is returned to the sender, and no code arrives for the recipient.

For AI agents, this is the worst type of failure: the agent triggers the verification request, receives a success response from the API call, then waits indefinitely for a code that was discarded before it left Amazon's infrastructure.

WhatsApp's policy is explicit and documented. From their official FAQ:

"Unsupported phone numbers, such as VoIP, landlines, and premium rate numbers, are not eligible for registration on WhatsApp."

The technical check happens at WhatsApp account registration. The carrier lookup is performed before the verification SMS is sent. VoIP numbers receive an immediate rejection error.

WhatsApp also blocks verification via short-code SMS to VoIP numbers as a secondary mechanism — even if a VoIP number somehow passed the initial registration check, the short-code routing would filter it.

Microsoft Entra ID (Azure AD MFA)

Microsoft's multi-factor authentication blocks VoIP via error code 399287, classified as "BadReputation" in their carrier reputation database.

Microsoft Learn documentation (updated March 2026) is direct:

"Phone extensions and VOIP numbers are not supported for MFA."

Microsoft applies per-number reputation tracking, not just per-OCN classification. A number that passes carrier lookup as "mobile" but has been associated with fraud attempts on other Microsoft accounts may still receive a BadReputation score.

Vercel and DocuSign

Both Vercel and DocuSign use Twilio Lookup's Line Type Intelligence directly in their onboarding flows. The code path is approximately:

register(phone) → lookup(phone).line_type_intelligence →
  if type in ["nonFixedVoip", "fixedVoip"] → reject("Invalid phone number")

Banks and Financial Institutions

Banks present a more heterogeneous blocking landscape because each institution implements its own carrier check. The patterns are:

Silent blocking: The verification SMS is simply never sent. The bank's UI shows a spinner and eventually times out. No error message indicates the phone type issue.

Misleading errors: BMO's documented case (Reddit r/PersonalFinanceCanada, February 2026): "BMO seems to have blocked 2FA verification from a landline VoIP number." The user received a generic error that didn't indicate the carrier type issue.

Post-enrollment blocking: Some banks validate at SMS routing time rather than at enrollment. This means an agent may successfully register a VoIP number, only to find that OTP codes are never delivered at login time.

Technical Alternatives: What Actually Works

1. Physical SIM Cards

How it works: Physical SIM cards inserted in modems or smartphones. AT&T, Verizon, T-Mobile SIM cards register the OCN in LERG as WIRELESS. HLR lookups succeed. Carrier lookup returns mobile across all APIs.

Classification result: Mobile on 100% of carrier lookup APIs. Passes all verification services.

Problems for agents: Requires physical hardware, $50–$80/month per number, no programmatic provisioning API, scale limited by hardware.

2. eSIM (Embedded SIM)

How it works: eSIM profiles provisioned remotely via the SM-DP+ protocol. Connects to the carrier's mobile network exactly like a physical SIM.

Classification result: Functionally identical to physical SIM for LERG/NPAC classification.

Problems for agents: Google has documented blocking eSIM numbers from certain carriers. Not all carriers support programmatic eSIM provisioning.

3. MVNO Numbers

How it works: MVNOs (Mint Mobile, Google Fi, Tracfone) lease network capacity from MNOs. Numbers registered on LERG as WIRELESS.

Classification result: Generally classified as mobile.

Problems for agents: Some MVNO OCN ranges are specifically blacklisted by high-fraud services. No programmatic provisioning API.

4. Number Porting (VoIP to Mobile)

How it works: Under FCC LNP rules, any US number can be ported from one carrier to another. Porting a VoIP number to a mobile carrier reclassifies it in NPAC.

Classification result: The number becomes mobile permanently.

Problems for agents: Takes hours to days. One-time operation per number. Not suitable for dynamic provisioning at scale.

5. Silent Network Authentication (SNA)

How it works: Carrier-level authentication that verifies phone number ownership using the SIM's authenticated data session — invisible in 1–4 seconds.

Classification result: Requires a real mobile SIM. Cannot be spoofed by VoIP.

Problems for agents: Requires mobile data (not Wi-Fi). Not universally supported yet. Only an authentication mechanism, not provisioning.

6. Real SIM Number APIs (The Programmatic Solution)

How it works: Services like AgentSIM operate physical SIM cards in carrier-connected modems, and expose those numbers via API. Provision a number, receive an OTP via API webhook or long-poll, release when done.

Classification result: mobile on all carrier lookup APIs. Passes Stripe, Google, Amazon, WhatsApp, Microsoft Entra, and bank verifications.

AgentSIM: Real Mobile Numbers via API

AgentSIM is built specifically for this use case. Every provisioned number is backed by a physical SIM on a US carrier network. Carrier lookup returns mobile.

Python: Complete OTP Flow

import agentsim

client = agentsim.AgentSimClient()

# 1. Provision a real mobile number
session = await client.provision(agent_id="stripe-onboarding", country="US")
print(f"Phone number: {session.number}")
# e.g. +14085551234 — carrier lookup returns "mobile"

# 2. Enter session.number into the service that will send the OTP

# 3. Wait for the OTP (blocks until received, up to 60s)
try:
    result = await session.wait_for_otp(timeout=60)
    print(f"OTP code: {result.otp_code}")

except agentsim.OtpTimeoutError:
    print("Timeout — retry with new number")

finally:
    # 4. Always release the number when done
    await session.release()

TypeScript: Complete OTP Flow

import { provision, OtpTimeoutError, PoolExhaustedError } from "@agentsim/sdk";

async function verifyWithStripe() {
  // await using releases the number automatically on exit (TypeScript 5.2+)
  await using session = await provision({
    agentId: "stripe-onboarding",
    country: "US",
    ttlSeconds: 300,
  });

  console.log(`Phone number: ${session.number}`);
  // e.g. +14085551234 — carrier lookup returns "mobile"

  try {
    const otp = await session.waitForOtp({ timeout: 60 });
    console.log(`OTP: ${otp.otpCode}`);
    return otp.otpCode;

  } catch (err) {
    if (err instanceof OtpTimeoutError) {
      console.log("No OTP in 60s — carrier retry may be needed");
    } else if (err instanceof PoolExhaustedError) {
      console.log("No US numbers available");
    } else {
      throw err;
    }
  }
}

MCP Integration

If you're using Claude Code, Cursor, or any MCP-compatible assistant:

{
  "mcpServers": {
    "agentsim": {
      "type": "streamable-http",
      "url": "https://mcp.agentsim.dev/mcp",
      "headers": {
        "x-api-key": "asm_live_..."
      }
    }
  }
}

Once configured, your assistant can call provision_number, wait_for_otp, and release_number autonomously — no human intervention required.

Implementation Guide: Verifying Numbers Before Use

Python: Check Number Type Before Sending OTP

from twilio.rest import Client

def get_line_type(phone_number: str, account_sid: str, auth_token: str) -> str:
    client = Client(account_sid, auth_token)
    number = client.lookups.v2.phone_numbers(phone_number).fetch(
        fields="line_type_intelligence"
    )
    lti = number.line_type_intelligence
    return lti.get("type", "unknown") if lti else "unknown"

def is_mobile(phone_number: str, account_sid: str, auth_token: str) -> bool:
    return get_line_type(phone_number, account_sid, auth_token) == "mobile"

TypeScript: Check Number Type

import Telnyx from "telnyx";

async function getLineType(phoneNumber: string) {
  const telnyx = new Telnyx(process.env.TELNYX_API_KEY!);
  const result = await telnyx.numberLookup.retrieve(phoneNumber, { type: "carrier" });
  const carrier = result.data?.carrier;
  return {
    type: carrier?.type ?? "unknown",
    carrier: carrier?.name,
    portedStatus: carrier?.ported_status,
  };
}

Frequently Asked Questions

Q: Does this affect Twilio numbers specifically, or all VoIP?

All VoIP numbers are affected, not just Twilio. Twilio programmable numbers are classified nonFixedVoip because Twilio's OCN is classified as a VoIP/CLEC provider in LERG. The same applies to Telnyx, Bandwidth, Vonage, Plivo, Sinch, and every other CPaaS provider's programmable numbers.

Q: My Twilio number worked on Google last year. Why is it failing now?

VoIP blocking has been tightening progressively. A number or OCN range that was tolerated in 2023 may now be explicitly blocked. Google in particular has been documented increasing eSIM and VoIP restrictions in early 2026.

Q: What about prepaid mobile numbers? Do they pass?

Prepaid mobile numbers from major carriers (AT&T Prepaid, T-Mobile Prepaid, Verizon Prepaid) pass carrier lookup as mobile. However, fraud-sensitive services apply additional velocity and reputation scoring.

Q: Can I port my existing Twilio number to a mobile carrier?

Yes, in principle. After porting, NPAC updates the SPID and the number is reclassified as mobile. This is a one-time operation — not suitable for dynamic number provisioning.

Q: Will this change as AI agent use cases grow?

The direction is toward stricter verification, not looser. Silent Network Authentication (SNA) is emerging as a more secure alternative — it requires a real SIM and mobile data, making it impossible to fake with VoIP.

Q: What about international numbers?

VoIP blocking is primarily a US/Canada phenomenon due to the specific LERG/NPAC infrastructure. AgentSIM currently supports US numbers.

Summary

The VoIP blocking problem is structural, not accidental. Services block VoIP numbers because the LERG/NPAC/OCN infrastructure exposes carrier type reliably, VoIP numbers have statistically higher fraud rates, and blocking is technically trivial once carrier lookups are already running.

For AI agents that need SMS verification to pass Stripe, Google, WhatsApp, Amazon, Microsoft, or financial institutions, the only path forward is a number that carrier lookup APIs classify as mobile.

Documentation: docs.agentsim.dev
MCP server: mcp.agentsim.dev/mcp
Get an API key: console.agentsim.dev

DEV Community: Fathin Dosunmu

Why Claude Code Agents Get Stuck on Phone Verification (And How to Fix It)

Why Claude Code Agents Get Stuck on Phone Verification (And How to Fix It)

The Problem

Why AI Agents Cannot Use Regular Phone Numbers

The Fix: Real SIM Phone API for AI Agents

Why This Matters for Claude Code Specifically

Cost Comparison

When to Use This

Getting Started

I Built an Autonomous Phone Verification Agent (Full Code + Tutorial)

The Problem in 30 Seconds

The Fix: Real SIM Infrastructure

Building the Agent

Step 1: Install

Step 2: Provision a Number

Step 3: Wait for OTP

Full Autonomous Flow with Playwright

Real Performance Numbers

Why This Matters for AI Agents

MCP Native

Try It Free

The Complete Guide to Phone Verification for AI Agents in 2026

The Verification Landscape in 2026

Services That Block VoIP Numbers

The Detection Stack

Every Approach Ranked

❌ Twilio / Vonage / VoIP Providers

❌ Google Voice / TextNow / Free Services

⚠️ Prepaid SIM Cards (Manual)

✅ AgentSIM (Real SIM API)

Implementation Guide

Installation

Pattern 1: Basic OTP Verification

Pattern 2: With Browser Automation (Playwright)

Pattern 3: Synchronous (Non-Async)

Pattern 4: MCP Integration (Claude Code / Cursor / Windsurf)

Pattern 5: Auto-Rerouting (Fallback Countries)

Error Handling

Cost Comparison

Best Practices

Links

VoIP vs Real SIM: Why Your AI Agent Phone Number Gets Blocked

The Carrier Lookup Infrastructure

LERG (Local Exchange Routing Guide)

NPAC (Number Portability Administration Center)

HLR (Home Location Register)

How Services Use This Data

Stripe's Approach

Google's Approach (More Aggressive)

WhatsApp's Approach (Strictest)

Why VoIP Numbers Are Detectable

Network Topology

Number Allocation

Registration Status

Real SIM vs VoIP: Technical Comparison

AgentSIM: Real SIM for AI Agents

MCP Integration

The Bottom Line

Fix: WhatsApp 'Unsupported phone numbers such as VoIP' for AI Agents

WhatsApp's Verification Requirements

Why WhatsApp Is Stricter

Every VoIP Provider Fails

The Fix: AgentSIM for WhatsApp

Install

WhatsApp Business API Registration

With Playwright (Web Registration)

With MCP (Claude Code / Cursor)

Carrier Verification Results

Important Notes

Cost

Get Started

Fix: Stripe 'This phone number cannot be used for verification' with AI Agents

Why Stripe Blocks Your Number

Why Twilio/VoIP Numbers Fail

The Fix: Real SIM Numbers via AgentSIM

Install

Basic Usage

With Playwright (Full Automation)

With MCP (Claude Code / Cursor / Windsurf)