En una plataforma de venta de entradas, el CAPTCHA suele ser la parte del checkout que menos se prueba y la primera que falla en un lanzamiento con mucha demanda. La forma fiable de validarlo es levantar tu staging, generar tokens reales con una API de resolución y comprobar que cada etapa —cola de acceso, selección de asientos y pago— acepta el token que recibe. Aquí montamos esas pruebas con CaptchaAI contra tu propia infraestructura.
Nota: Los ejemplos apuntan a un entorno de staging que tú controlas. No los ejecutes contra plataformas de terceros sin autorización explícita.
Qué CAPTCHA aparecen en un checkout de entradas
Antes de escribir una prueba, mapea dónde se dispara cada verificación:
| Tipo de CAPTCHA | Punto de activación habitual | Complejidad de integración |
|---|---|---|
| reCAPTCHA v3 | Acceso a evento, envío de formulario | Alta (umbral de puntuación configurable) |
| reCAPTCHA v2 (casilla) | Asignación de ubicaciones de prueba, pago ficticio | Media |
| Cloudflare Turnstile | Acceso a página, checkout | Media |
| reCAPTCHA v2 Invisible | Envío de formulario de pago | Alta |
Piensa en un festival que sale a la venta en Ciudad de México o Madrid a las 10:00: querrás confirmar de antemano que la cola no rechaza tokens válidos ni el pago se cuelga con un token recién resuelto.
Configura el resolutor de CAPTCHA para tu staging
Empieza por una función única que envíe la tarea a CaptchaAI y sondee el resultado; la reutilizas en cada etapa cambiando el method. Para reCAPTCHA v2 el campo de respuesta es g-recaptcha-response:
import requests
import time
CAPTCHAAI_KEY = "YOUR_API_KEY"
CAPTCHAAI_URL = "https://ocr.captchaai.com"
STAGING_SITEKEY = "6LeIxAcTAAAAAJcZVRqyHh71UMIEGNQ_MXjiZKhI" # sitekey de prueba de Google
STAGING_URL = "https://staging.tu-plataforma.com/checkout"
def solve_captcha(method: str, sitekey: str, pageurl: str, **kwargs) -> str:
"""Resolver CAPTCHA para pruebas de flujos de checkout."""
data = {
"key": CAPTCHAAI_KEY,
"method": method,
"googlekey": sitekey,
"pageurl": pageurl,
"json": 1,
}
data.update(kwargs)
resp = requests.post(f"{CAPTCHAAI_URL}/in.php", data=data)
resp.raise_for_status()
task_id = resp.json()["request"]
for _ in range(60):
time.sleep(5)
result = requests.get(f"{CAPTCHAAI_URL}/res.php", params={
"key": CAPTCHAAI_KEY, "action": "get",
"id": task_id, "json": 1,
})
data = result.json()
if data["request"] != "CAPCHA_NOT_READY":
return data["request"]
raise TimeoutError("Tiempo de espera agotado para resolver CAPTCHA")
token = solve_captcha("userrecaptcha", STAGING_SITEKEY, STAGING_URL)
print(f"Token obtenido: {token[:40]}...")
Prueba el flujo completo: cola, asientos y pago ficticio
Encapsula las tres etapas en una clase de prueba. Cada método devuelve un resultado verificable para afirmarlo (assert) en tu CI y detectar dónde se rompe el flujo. La clase cubre tres comprobaciones:
test_queue_entry: la cola acepta el token de reCAPTCHA v2.test_seat_selection: se reservan los asientos de prueba.test_checkout: el pago ficticio se completa con un token nuevo.
class CheckoutFlowTester:
"""Pruebas de flujos de checkout con CAPTCHA en staging."""
def __init__(self, base_url: str, sitekey: str):
self.base_url = base_url
self.sitekey = sitekey
self.session = requests.Session()
def test_queue_entry(self) -> bool:
"""Prueba la entrada a la cola de acceso con CAPTCHA."""
queue_url = f"{self.base_url}/event/queue"
resp = self.session.get(queue_url)
assert resp.status_code == 200, f"Error al cargar cola: {resp.status_code}"
token = solve_captcha("userrecaptcha", self.sitekey, queue_url)
resp = self.session.post(queue_url, data={"g-recaptcha-response": token})
return resp.status_code == 200
def test_seat_selection(self, seats: list) -> dict:
"""Prueba la asignación de ubicaciones de prueba."""
resp = self.session.post(f"{self.base_url}/seats", json={"seats": seats})
return {"status": resp.status_code, "success": resp.status_code == 200}
def test_checkout(self, payment_data: dict) -> dict:
"""Prueba el checkout final con CAPTCHA."""
checkout_url = f"{self.base_url}/checkout"
token = solve_captcha("userrecaptcha", self.sitekey, checkout_url)
resp = self.session.post(checkout_url, json={
"payment": payment_data,
"g-recaptcha-response": token,
})
return {
"status_code": resp.status_code,
"success": resp.status_code == 200,
}
# Ejecutar prueba completa en staging
tester = CheckoutFlowTester(
base_url="https://staging.tu-plataforma.com",
sitekey=STAGING_SITEKEY,
)
queue_ok = tester.test_queue_entry()
seats_result = tester.test_seat_selection(["A1", "A2"])
checkout_result = tester.test_checkout({"test_card": "4111111111111111"})
print(f"Cola: {'OK' if queue_ok else 'FALLO'} | Asientos: {seats_result} | Checkout: {checkout_result}")
Resolvemos un token distinto para la cola y para el checkout a propósito: cada token es de un solo uso y caduca en unos dos minutos, así que conviene resolverlo justo antes de enviarlo.
reCAPTCHA v3 con umbral de puntuación
Si tu acceso usa reCAPTCHA v3, la prueba solo cambia en version y action. La action declarada en el frontend debe viajar en la solicitud para que la puntuación cuadre con el umbral de tu backend:
def solve_recaptcha_v3(sitekey: str, pageurl: str, action: str = "purchase",
"""Resolver reCAPTCHA v3 con puntuación mínima para staging."""
return solve_captcha(
method="userrecaptcha",
sitekey=sitekey,
pageurl=pageurl,
version="v3",
action=action,
)
reCAPTCHA v3 no muestra un desafío: devuelve una puntuación. Por eso la prueba útil es confirmar que tu umbral de backend acepta un token legítimo sin bloquear compras reales de baja puntuación.
Cloudflare Turnstile en las páginas de evento
Muchas plataformas de eventos recientes protegen el acceso con Cloudflare Turnstile. El campo de respuesta pasa a cf-turnstile-response; en tu prueba basta con elegir el method:
def solve_turnstile(sitekey: str, pageurl: str) -> str:
"""Resolver Cloudflare Turnstile en staging."""
return solve_captcha(
method="turnstile",
sitekey=sitekey,
pageurl=pageurl,
)
El resto del flujo no cambia: la misma función solve_captcha gestiona el envío, el sondeo y los reintentos. Turnstile suele resolverse en menos de 10 segundos y reCAPTCHA v3 en menos de 4, cómodo para bucles de prueba frecuentes. Para QA el volumen es bajo: el plan BASIC ($15/mes, 5 threads) sobra, con un costo mensual predecible en USD.
Cuándo resolver cada CAPTCHA en el flujo
El token caduca rápido, así que el momento importa tanto como el código:
- Cola de acceso: resuelve al entrar y envía el token de inmediato.
- Selección de asientos: no requiere CAPTCHA; reserva el asiento y sigue.
- Checkout: resuelve justo antes de enviar el pago, nunca antes de elegir asiento.
Solución de problemas
| Problema | Causa probable | Solución |
|---|---|---|
| Token rechazado en checkout | Token caducado (>120 s) | Resolver el CAPTCHA justo antes de enviar |
ERROR_ZERO_BALANCE |
Saldo de cuenta agotado | Recargar saldo en captchaai.com/account |
| Tiempo de espera agotado | Alta demanda del servidor | Aumentar reintentos y tiempo de espera |
ERROR_WRONG_GOOGLEKEY |
Sitekey incorrecta | Verificar la sitekey en el HTML de la página |
| Token válido pero el formulario lo rechaza | Parámetro action o IP incoherentes |
Revisar la configuración del backend |
Preguntas frecuentes
¿Qué sitekey uso para probar reCAPTCHA en staging?
La de tu propio entorno; para arrancar sirve la sitekey de prueba pública de Google (6LeIxAcTAAAAAJcZVRqyHh71UMIEGNQ_MXjiZKhI) y luego migras a la clave real.
¿Puedo reutilizar el mismo token en varias etapas del checkout?
No. Cada token es de un solo uso y caduca en unos 120 segundos; resuelve uno nuevo para cada paso que exija verificación.
¿Qué plan de CaptchaAI necesito para una suite de pruebas?
El plan BASIC ($15/mes, 5 threads) suele bastar; necesitarás más threads solo si integras las pruebas en un CI con muchas ejecuciones simultáneas.
¿Turnstile o reCAPTCHA v3 se resuelve antes?
Turnstile suele completarse en menos de 10 segundos y reCAPTCHA v3 en menos de 4, con una alta tasa de éxito en los tipos compatibles.
¿Cómo integro estas pruebas en mi pipeline de CI?
Ejecuta la clase CheckoutFlowTester como un job antes de cada despliegue: si una etapa devuelve un código distinto de 200, falla el build y revisa el backend antes de publicar.
Guías relacionadas
- Guía de inicio rápido de CaptchaAI
- Resolver reCAPTCHA v2 con la API
- Resolver Cloudflare Turnstile con la API
Integra CaptchaAI en tus pruebas de checkout y confirma que tu plataforma de venta de entradas resuelve el CAPTCHA en cada etapa. Obtén tu API key de CaptchaAI
