How AI Agents Can Create Accounts Autonomously — SMS Verification Solved With Lightning

An OpenClaw agent recently provisioned a server, funded it with Bitcoin over Lightning, and bought API credits — all on its own. No human clicked "confirm." This was documented by Alby in February 2026, and it marks a turning point for what autonomous AI can actually do in the real world.

But there's a bottleneck nobody is solving yet: almost every online service requires a phone number for SMS verification before you can create an account. An agent can browse the web, fill out forms, and even pay for things — but the moment a service sends an OTP code to a phone number, the agent is stuck. It needs a human to read the code.

Until now.

At nadanada, we offer rental phone numbers that can receive SMS — accessible through a simple API, payable instantly over the Bitcoin Lightning Network, no account or identity required. This is exactly the missing piece that makes truly autonomous AI agents possible.

The SMS Wall: Why Agents Can't Create Accounts Today

Think about what happens when you sign up for almost anything online — a cloud provider, a social media platform, a SaaS tool, an email service. At some point during the signup flow, you'll see: "Enter the 6-digit code we sent to your phone."

For a human, that's a minor annoyance. For an AI agent, it's a complete dead end.

Today's agents are remarkably capable. OpenClaw — the open-source agent with over 145,000 GitHub stars — can browse the web, send emails, manage calendars, and interact through Signal, Telegram, or Discord. It integrates with LLMs like Claude, DeepSeek, or GPT. It can even make Bitcoin Lightning payments autonomously.

But it can't receive a text message. And without that capability, an agent can't independently create accounts on the services it needs to do its job.

This is the problem we solve.

Rental Phone Numbers via API: How It Works

nadanada provides phone numbers that agents can rent programmatically. The entire flow — from requesting a number to reading the incoming SMS — happens through API calls, with payment settled instantly over the Lightning Network.

Here's the actual workflow using our API:

Step 1 — Request a phone number. The agent calls our purchase endpoint. No account needed — if it's the first request, a new userId is generated automatically. The API returns a Lightning invoice.

curl -X POST https://nadanada.me/api/v2/phone/purchase \
  -H "Content-Type: application/json" \
  -d '{}'

Response:

{
  "success": true,
  "data": {
    "userId": "550e8400-e29b-41d4-a716-446655440000",
    "price": 12,
    "paymentMethod": "lightning",
    "paymentRequest": "lnbc120n1p...",
    "paymentHash": "abc123...",
    "checkoutId": "chk_...",
    "expiresAt": "2026-02-14T13:00:00Z"
  }
}

Step 2 — Pay the Lightning invoice. Using any Lightning wallet, lncli, or a tool like Lightning Labs' lnget, the agent pays the invoice instantly. $12 gets a phone number for 3 months.

Step 3 — Complete the purchase. After payment, the agent calls the completion endpoint to get the actual phone number. On first purchase, this also returns a userSecret — the agent stores this for future authenticated requests.

curl -X POST https://nadanada.me/api/v2/phone/complete \
  -H "Content-Type: application/json" \
  -d '{
    "paymentHash": "abc123...",
    "userId": "550e8400-e29b-41d4-a716-446655440000"
  }'

Response:

{
  "success": true,
  "data": {
    "phoneNumber": "+447123456789",
    "country": "GB",
    "expiresAt": "2026-05-14T12:00:00Z",
    "userSecret": "sk_live_..."
  }
}

Step 4 — Receive OTP codes. The agent uses the phone number to sign up for a service. When the SMS arrives, the agent polls for messages:

curl "https://nadanada.me/api/v2/phone/messages/%2B447123456789?\
userId=550e8400-e29b-41d4-a716-446655440000&\
userSecret=sk_live_..."

The response includes every SMS received — the agent extracts the verification code and completes the signup. No human touched anything.

Step 5 — Keep using it. Unlike disposable one-time numbers, nadanada phone numbers last 3 months and can be renewed. An agent can use the same number across multiple service signups, or check back for password reset codes later. It manages its numbers through the API:

# List all numbers and unread message counts
curl "https://nadanada.me/api/v2/phone/numbers?\
userId=550e8400-...&userSecret=sk_live_..."

That's the complete flow. A few API calls, one Lightning payment, and an agent can independently verify itself on any SMS-gated service.

Going Further: An Agent With Its Own Phone

Here's where it gets interesting. nadanada also offers eSIM data plans through the same API — and an agent managing a physical device (a Raspberry Pi, a cloud phone, an IoT gateway) can purchase an eSIM and provision mobile data connectivity without any carrier contract or identity check.

The agent calls /api/v2/esim/bundles?country=US to browse available data plans, requests a Lightning invoice via /api/v2/esim/payment, pays it, and then calls /api/v2/esim/purchase to get the eSIM profile — complete with a QR code, SM-DP+ address, matching ID, and direct install URLs for both iOS and Android.

Combine this with a rented phone number and VPN access, and an agent can spin up its own fully functional phone with mobile data, a real number that receives SMS, and a VPN for network privacy — all purchased autonomously over Lightning, with no human involvement and no identity attached.

This isn't a theoretical scenario. Every API endpoint described here is live and functional today.

Why This Matters Right Now

Three things have come together in early 2026 that make this more than an interesting demo:

OpenClaw proved autonomous payments work. The agent demonstrated end-to-end autonomous infrastructure provisioning funded by Bitcoin Lightning. The pattern — agent discovers service, agent pays for service, agent uses service — is now proven. What's missing is the catalog of services that are actually useful to agents and compatible with how they operate.

Lightning Labs released lnget. This CLI tool lets any agent pay for HTTP APIs transparently. When a request returns a 402 "Payment Required" status, lnget automatically parses the Lightning invoice, pays it, and retries. It turns any Lightning-payable API into something an agent can consume as easily as a free endpoint.

MCP is connecting agents to tools. Anthropic's Model Context Protocol — now adopted by OpenAI and Google DeepMind — standardizes how agents discover and use external services. A nadanada integration wrapped as an MCP tool becomes instantly discoverable by any compatible agent. The agent doesn't need to be pre-programmed to use nadanada — it encounters an SMS verification wall, searches its available tools, finds rent_phone_number, and calls it.

Why Lightning Network and Not Credit Cards?

This is not a philosophical preference — it's a practical requirement. Traditional payment methods are fundamentally incompatible with how autonomous agents operate.

An agent doesn't have a government ID. It doesn't have a credit card. It can't go through a checkout flow, enter billing details, and wait for a confirmation email. Credit card processors require identity, charge minimum transaction fees that make micropayments impractical, and take days to settle.

Lightning payments settle in milliseconds, cost fractions of a cent in fees, require no identity, and are fully programmable. An agent with access to a Lightning wallet can pay any Lightning invoice anywhere in the world — for any amount — through a single command.

This is why Lightning Labs built lnget. This is why OpenClaw's autonomous payment demo used Lightning. And this is why every service that wants to be part of the agent economy needs to accept Lightning payments.

A Practical Example: Agent Sets Up Its Own Monitoring

To make this concrete, here's a realistic scenario. You ask your AI agent to set up uptime monitoring for your website using an external monitoring service.

The agent browses to the monitoring service's signup page. It fills in a username and password. The service asks for phone verification. The agent calls nadanada's API, purchases a phone number, and pays the Lightning invoice. It enters the number. The SMS arrives with a 6-digit code. The agent reads the code from nadanada's message endpoint, enters it into the form, and completes the signup. It then configures the monitoring checks, sets up alert channels, and reports back to you: "Done. Monitoring is live."

You didn't touch a thing. The agent handled it end-to-end — including the SMS verification step that would have previously required your phone.

Every component of this workflow exists today.

Full Python Example

Here's a complete, working integration using nadanada's actual API endpoints:

import requests
import subprocess
import time
import re
 
NADANADA = "https://nadanada.me/api/v2"
 
class NadanadaAgent:
    """Autonomous phone number management for AI agents."""
 
    def __init__(self, user_id=None, user_secret=None):
        self.user_id = user_id
        self.user_secret = user_secret
 
    def _pay_invoice(self, payment_request):
        """Pay a Lightning invoice using lncli."""
        subprocess.run(
            ["lncli", "payinvoice", "--force", payment_request],
            check=True
        )
 
    def rent_phone_number(self):
        """Rent a phone number for 3 months ($12 via Lightning)."""
        # Step 1: Request purchase
        body = {}
        if self.user_id:
            body["userId"] = self.user_id
 
        res = requests.post(f"{NADANADA}/phone/purchase", json=body)
        data = res.json()["data"]
 
        self.user_id = data["userId"]
 
        # Step 2: Pay Lightning invoice
        self._pay_invoice(data["paymentRequest"])
 
        # Step 3: Complete purchase
        res = requests.post(f"{NADANADA}/phone/complete", json={
            "paymentHash": data["paymentHash"],
            "userId": self.user_id
        })
        result = res.json()["data"]
 
        # Save the secret (only returned on first purchase)
        if "userSecret" in result:
            self.user_secret = result["userSecret"]
 
        return result["phoneNumber"]
 
    def wait_for_otp(self, phone_number, timeout=120):
        """Poll for SMS messages and extract OTP code."""
        encoded = phone_number.replace("+", "%2B")
        start = time.time()
 
        while time.time() - start < timeout:
            res = requests.get(
                f"{NADANADA}/phone/messages/{encoded}",
                params={
                    "userId": self.user_id,
                    "userSecret": self.user_secret,
                    "limit": 5
                }
            )
            messages = res.json()["data"]["messages"]
 
            if messages:
                latest = messages[0]["content"]
                # Extract 4-8 digit OTP code
                match = re.search(r'\b(\d{4,8})\b', latest)
                if match:
                    return match.group(1)
 
            time.sleep(5)
 
        return None
 
# Usage
agent = NadanadaAgent()
phone = agent.rent_phone_number()
print(f"Got number: {phone}")
 
# ... agent uses phone number to sign up for a service ...
 
otp = agent.wait_for_otp(phone)
print(f"Received OTP: {otp}")
 
# ... agent enters OTP and completes signup ...

This can be wrapped as an MCP tool, making it discoverable by any MCP-compatible AI agent — Claude, GPT, or any framework using the Model Context Protocol.

What This Means for People Building AI Agents

If you're building an autonomous agent or an agent framework, the SMS verification problem has probably already come up. Every time your agent hits a phone number requirement, the workflow breaks and needs human intervention.

nadanada's API removes that blocker. Your agent can rent a phone number, receive OTP codes, and continue — all paid in Bitcoin over Lightning, all without any account or identity. Add a VPN for geo-consistency and an eSIM for mobile data, and your agent has the full stack of infrastructure it needs to operate independently.

Check out the API documentation to see the full list of endpoints and start integrating. For a non-technical overview of how rental phone numbers work for privacy, see our guide on receiving SMS verification codes without your real number.

The agents are here. They can browse, they can code, they can pay. Now they can verify themselves too.

nadanada provides anonymous VPN, eSIM, and phone number services. No accounts. Privacy is a human right.