El registro manual de cuentas es el cuello de botella de cualquier operación que quiera escalar. Cuando necesitas más de 100 registros al día, el trabajo humano se convierte en el principal gasto. La API de números virtuales es el puente entre lo manual y lo automático: el script obtiene un número, recibe el SMS, extrae el código y completa el registro sin intervención humana.

Arquitectura del registro automatizado

Flujo básico

Cada registro automático pasa por los siguientes pasos:

  1. El script solicita un número virtual a través de la API (indicando el servicio y el país)
  2. El servicio devuelve el número y el ID de activación
  3. El script introduce el número en el formulario de registro del servicio de destino
  4. El servicio de destino envía un SMS con el código OTP
  5. El script consulta periódicamente (polling) los SMS entrantes a través de la API
  6. La API devuelve el código del SMS
  7. El script introduce el código y completa el registro
  8. El script libera el número (o espera a que expire)

Trabajar con la API de turbon: endpoints principales

Obtener un número

El primer paso es solicitar un número disponible para el servicio y el país que necesitas:

GET /api/getNumber?api_key=YOUR_KEY&service=telegram&country=ru Respuesta: { "status": "success", "id": 12345678, "phone": "79991234567" }

Esperar el SMS

Después de enviar el número al servicio de destino, haz polling para obtener el código:

GET /api/getStatus?api_key=YOUR_KEY&id=12345678 Respuesta (en espera): {"status": "STATUS_WAIT_CODE"} Respuesta (código recibido): {"status": "STATUS_OK", "code": "12345"}

Confirmar el uso

GET /api/setStatus?api_key=YOUR_KEY&id=12345678&status=6 # status=6 — informar de que el SMS se recibió y todo está OK

Ejemplos de implementación

Python: clase base para trabajar con la API

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 }) # Uso: turbon = TurbonAPI("your_api_key") act_id, phone = turbon.get_number("telegram") # ... registro en Telegram con el número phone ... code = turbon.wait_sms(act_id) # ... introducir el código code ... turbon.confirm(act_id)

JavaScript/Node.js: variante asíncrona

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'); }

Registro en paralelo

Patrón Worker Pool

Para registrar 100 cuentas en paralelo se usa el patrón worker pool: N workers trabajan al mismo tiempo y cada uno ejecuta el ciclo completo de registro. Con N=10, el tiempo para registrar 100 cuentas se reduce 10 veces.

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 # Ejecución en paralelo 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]

Manejo de errores y reintentos

Errores típicos

ErrorCausaSolución NO_NUMBERSNo hay números disponibles para el servicio/paísReintentar en 30–60 s o cambiar de país STATUS_CANCELNo llegó el SMS y la activación se cancelóObtener un número nuevo y repetir BANNEDLa cuenta de la API está bloqueadaRevisar el saldo y los límites TimeoutErrorEl SMS llegó después del timeoutAumentar el timeout y añadir reintentos

Exponential backoff

Ante errores NO_NUMBERS no bombardees la API: haz pausas con un intervalo creciente: 5 s → 10 s → 20 s → 40 s. Así reduces la carga y aumentas la probabilidad de conseguir un número cuando hay mucha demanda.

Integración con un navegador antidetect

Playwright o Selenium lanza un perfil de navegador → el script obtiene un número a través de la API de turbon → introduce el número en el formulario mediante la automatización del navegador → recibe el código por la API → lo introduce en el navegador. Un ciclo completo sin intervención humana.

Un punto clave: entre la obtención del número y la introducción del código SMS debe haber una pausa de 5 a 30 segundos (simula a un usuario real que «lee el SMS»). Sin esa pausa, algunas plataformas detectan la automatización.

Buenas prácticas al automatizar

  • Confirma siempre el uso del número (status=6): eso ayuda a mejorar la calidad del pool
  • No solicites un número hasta que el formulario de registro esté listo para recibirlo: el número puede expirar
  • Registra en el log cada activación con su resultado, para analizar la tasa de éxito por servicio
  • Usa distintos países para distintas plataformas: así reduces los patrones
  • No superes una velocidad razonable de peticiones a la API: respeta los rate limits

Conclusión

Automatizar el registro mediante la API de números virtuales es pasar del trabajo manual a un proceso escalable. 10 líneas de código sustituyen 10 minutos de trabajo manual de un operador. turbon.rent ofrece una API para obtener números automáticamente, recibir SMS y gestionar activaciones: todo lo necesario para integrarlo en tus scripts y pipelines.