SMS codes, email codes and captchas behind one API. Send one request: it waits until the code arrives, then returns it. No polling loops, no webhook servers, no juggling vendors.
GET api.clearance.rest/numbers/sms/wait
number=+14155550100
code_regex=\d{6}
Request is open. Nothing to poll, nothing to host.
{
"success": true,
"code": "482913",
"from": "+15559998888",
"body": "Your code is 482913"
}GET api.clearance.rest/emails/get-email
email_account=qa@acme.dev
code_regex=\d{6}
Request is open. Nothing to poll, nothing to host.
{
"code": "730214",
"from": "noreply@example.com",
"subject": "Confirm your sign-up",
"text": "Your code is 730214"
}POST api.clearance.rest/captchas/resolve
"captcha_type": "turnstile"
"website_url": "https://target.example"
Request is open. Nothing to poll, nothing to host.
{
"status": "solved",
"captcha_provider": "capsolver",
"solution": { "token": "0.Xk3v…9fQ" }
}One API key in front of the providers you'd otherwise integrate one by one
Product
Phone verification, email confirmation and captchas usually mean three vendors, three SDKs and three sets of edge cases. Here they share one key, one auth model and one way of waiting.
Numbers
Rent a number or bring a real SIM, trigger the verification, and wait for the SMS. The same call works for every kind of number.
GET /numbers/sms/waitEmails
Wait for the confirmation email and get the code, whether the address lives on your own domain or in a connected mailbox.
GET /emails/get-emailCaptchas
Describe the captcha and get the solution in the same request. The request and response look the same whichever solver does the work.
POST /captchas/resolveHow it works
Every verification step hides the same chore: trigger it, then poll, parse and retry until the code shows up. clearance.rest turns that whole loop into a single call.
// Trigger the sign-up, then...
const deadline = Date.now() + 120_000;
let code;
while (!code && Date.now() < deadline) {
const inbox = await provider.listMessages(number);
const msg = inbox.find((m) => m.at > startedAt);
code = msg?.body.match(/\d{6}/)?.[0];
if (!code) await sleep(3000);
}
// + a webhook endpoint, retries, a second
// vendor for email, a third for captchasconst { code } = await clearanceRest.numbers.wait({
number: '+14155550100',
codeRegex: '\\d{6}',
timeout: 120_000,
});code → "482913"Name the number, the address or the captcha. Add a regex to filter messages and one to pull out the code.
The request stays open until a matching SMS or email lands, or the solver finishes. If it already arrived, you get it at once.
The response is the result: the extracted code, the full message and the metadata. You set the longest wait with one header.
Real SIM cards
Some services only accept real carrier numbers. Put a SIM in any Android phone, install the SIM Bridge app and scan your project's QR code. Every SMS it receives reaches the same/sms/wait call as any other number.
Captcha coverage
Every type has a closed, validated contract, and every solver returns the same response shape. Pick a solver per request, set a default per project, or let clearance.rest choose one that supports your request.
Confirmation links and one-time codes land wherever your users and workflows live. You write the same code for all of them.
Gmail and Outlook with OAuth. The mailbox owner grants access in their own browser, so you never see a password. Share a single authorization link and let your users connect themselves.
Route a domain through Cloudflare Email Routing and every address on it receives mail. Open as many addresses as a workflow needs, with no mailbox to create.
It does not matter how the email reaches us. You wait with one request and get the message back, with the code already extracted.
For developers
One key authenticates everything. Bound the wait with a header, and the response is the result.
Read the docscurl -G https://api.clearance.rest/numbers/sms/wait \
-H "X-API-Key: $CLEARANCE_REST_API_KEY" \
-H "X-Service-Timeout: 120000" \
--data-urlencode "number=+14155550100" \
--data-urlencode "code_regex=\d{6}"const clearanceRest = require('@clearance-rest/sdk');
const sms = await clearanceRest.numbers.wait({
number: '+14155550100',
codeRegex: '\\d{6}',
timeout: 120000,
});
console.log(sms.code);use ClearanceRest\Client;
$client = new Client(); // reads CLEARANCE_REST_API_KEY
$sms = $client->numbers->wait(
number: '+14155550100',
codeRegex: '\d{6}',
timeout: 120_000,
);
echo $sms['code'];Both SDKs set a hard deadline and raise typed errors, including timeouts.
Subscribe to number and mailbox events. Every delivery is HMAC-signed and retried with backoff.
Keep your own ownership data on numbers and mailboxes, and assign safely with If-Match.
Projects and API keys, usage, an inbox for received messages and a quick cURL builder.
A full API reference, and docs your AI agents can read directly.
Node, Cloudflare Workers and the browser, with the same SDK.
FAQ
clearance.rest is in a private beta. Join the waitlist and we will email you when your spot opens.
Pricing is not announced yet. Waitlist members will hear about it first.
Yes. Numbers, mailboxes and captcha solving run on provider accounts (Twilio, Hero SMS, Capsolver, 2Captcha and so on). You connect them once, and your code never touches them.
The request ends at the timeout you set with the X-Service-Timeout header, and the response says so. The SDKs raise a typed timeout error.
No. A wait is a single request that stays open. Webhooks are optional, for hearing about changes to your numbers and mailboxes.
Anything that speaks HTTP. There are official SDKs for Node.js (also Cloudflare Workers and browsers) and PHP.
Private beta
Join the waitlist. Tell us what you need to get past and we will prioritise your invite.