Registration Automation via turbon API

Manual account registration is the bottleneck of any scalable operation. When needing 100+ registrations daily, human labor becomes the main cost. Virtual number API is a bridge from manual to automatic: script gets number, receives SMS, parses code, completes registration without human involvement.

Architecture of automated registration

Basic flow

Each automatic registration passes the following steps:

1. Script requests virtual number via API (specifies service and country)
2. Service returns number and activation ID
3. Script enters number into target service registration form
4. Target service sends SMS with OTP code
5. Script polls for incoming SMS via API
6. API returns code from SMS
7. Script enters code, completes registration
8. Script releases number (or waits for expiration)

Working with turbon API: main endpoints

Getting a number

First step is requesting available number for needed service and country:

GET /api/getNumber?api_key=YOUR_KEY&service=telegram&country=ru

Response:
{
  "status": "success",
  "id": 12345678,
  "phone": "79991234567"
}

Waiting for SMS

After sending number to target service — polling to get code:

GET /api/getStatus?api_key=YOUR_KEY&id=12345678

Response (waiting):
{"status": "STATUS_WAIT_CODE"}

Response (code received):
{"status": "STATUS_OK", "code": "12345"}

Confirming use

GET /api/setStatus?api_key=YOUR_KEY&id=12345678&status=6
# status=6 — report SMS received and all OK

Implementation examples

Python: basic API class

import requests
import time

class TurbonAPI:
    BASE_URL = "https://turbon.rent/api"

    def __init__(self, api_key):
        self.api_key = api_key

    def get_number(self, service, country="ru"):
        r = requests.get(f"{self.BASE_URL}/getNumber", params={
            "api_key": self.api_key,
            "service": service,
            "country": country
        })
        data = r.json()
        if data["status"] == "success":
            return data["id"], data["phone"]
        raise Exception(f"Failed to get number: {data}")

    def wait_sms(self, activation_id, timeout=120, interval=5):
        deadline = time.time() + timeout
        while time.time() < deadline:
            r = requests.get(f"{self.BASE_URL}/getStatus", params={
                "api_key": self.api_key,
                "id": activation_id
            })
            data = r.json()
            if data["status"] == "STATUS_OK":
                return data["code"]
            if "CANCEL" in data["status"]:
                raise Exception("Activation cancelled")
            time.sleep(interval)
        raise TimeoutError(f"SMS not received in {timeout}s")

    def confirm(self, activation_id):
        requests.get(f"{self.BASE_URL}/setStatus", params={
            "api_key": self.api_key,
            "id": activation_id,
            "status": 6
        })

# Usage:
turbon = TurbonAPI("your_api_key")
act_id, phone = turbon.get_number("telegram")
# ... register with phone in Telegram ...
code = turbon.wait_sms(act_id)
# ... enter code ...
turbon.confirm(act_id)

JavaScript/Node.js: async variant

const axios = require('axios');

async function getNumber(apiKey, service, country = 'ru') {
  const { data } = await axios.get('https://turbon.rent/api/getNumber', {
    params: { api_key: apiKey, service, country }
  });
  if (data.status !== 'success') throw new Error(data.status);
  return { id: data.id, phone: data.phone };
}

async function waitSms(apiKey, id, timeout = 120000) {
  const deadline = Date.now() + timeout;
  while (Date.now() < deadline) {
    await new Promise(r => setTimeout(r, 5000));
    const { data } = await axios.get('https://turbon.rent/api/getStatus', {
      params: { api_key: apiKey, id }
    });
    if (data.status === 'STATUS_OK') return data.code;
    if (data.status.includes('CANCEL')) throw new Error('Cancelled');
  }
  throw new Error('Timeout');
}

Parallel registration

Worker Pool pattern

To register 100 accounts in parallel, use worker pool pattern: N workers work simultaneously, each completes full registration cycle. With N=10, registration time for 100 accounts is reduced 10 times.

from concurrent.futures import ThreadPoolExecutor
import time

def register_account(turbon, service, registrar):
    act_id, phone = turbon.get_number(service)
    registrar.start_registration(phone)
    code = turbon.wait_sms(act_id)
    account = registrar.complete_registration(code)
    turbon.confirm(act_id)
    return account

# Parallel launch
with ThreadPoolExecutor(max_workers=10) as executor:
    futures = [
        executor.submit(register_account, turbon, "telegram", registrar)
        for _ in range(100)
    ]
    accounts = [f.result() for f in futures]

Error handling and retry

Typical errors

Error	Reason	Solution
NO_NUMBERS	No available numbers for service/country	Retry in 30–60 sec or change country
STATUS_CANCEL	SMS not received, activation cancelled	Get new number, repeat
BANNED	API account blocked	Check balance and limits
TimeoutError	SMS arrived later than timeout	Increase timeout, add retry

Exponential backoff

On NO_NUMBERS errors — don't bombard API, use pauses with growing intervals: 5s → 10s → 20s → 40s. This reduces load and increases chance to get number at high demand.

Integration with antidetect browser

Playwright or Selenium launches browser profile → script gets number via turbon API → enters number in form via automation → gets code via API → enters in browser. Full cycle without human involvement.

Key moment: between getting number and entering SMS code there should be 5–30 second delay (imitate real user who "reads SMS"). Without delay, some platforms detect automation.

Best Practices for automation

• Always confirm number use (status=6) — helps improve pool quality
• Don't request number until registration form is ready — number may expire
• Log each activation with result — for success analysis by services
• Use different countries for different platforms — reduces patterns
• Don't exceed reasonable API request speed — respect rate limits

Conclusion

Registration automation via virtual number API is a transition from manual labor to scalable process. 10 lines of code replace 10 minutes of operator work. turbon.rent provides API for automatic number acquisition, SMS reception, and activation management — everything needed for integration into your scripts and pipelines.