Manejo automatizado de CAPTCHA de inicio de sesión con CaptchaAI

La parte difícil de automatizar un inicio de sesión casi nunca es rellenar el usuario y la contraseña: es el CAPTCHA que aparece justo antes de enviar el formulario. La solución es repartir el trabajo. Tu script se ocupa del formulario, las cookies y la sesión; el desafío —reCAPTCHA v2/v3, Turnstile o un CAPTCHA de imagen— se lo delegas a la API de CaptchaAI, que te devuelve un token listo para inyectar en el envío. En esta guía verás tres formas de hacerlo, con y sin navegador, y cómo encajar la resolución dentro de un flujo de login real.

Antes de empezar: automatizar accesos solo tiene sentido sobre cuentas propias, cuentas de clientes que te lo autorizan o un entorno de staging que controlas. Respeta siempre los términos de servicio del sitio y la normativa de protección de datos aplicable.

Qué CAPTCHA vas a encontrar en un login

Los formularios de acceso concentran casi todos los tipos de CAPTCHA que existen. Estos son los cuatro más habituales y el método de la API con el que se resuelven:

¿Con navegador o sin él? Elige tu enfoque

La primera decisión no es de código, sino de arquitectura. La regla práctica es sencilla:

1. Si el formulario acepta un POST estándar y el sitekey está en el HTML, no necesitas navegador: requests es más rápido, consume menos memoria y escala mejor en segundo plano.
2. Si el login solo se envía mediante JavaScript, genera el sitekey de forma dinámica o encadena pasos que dependen del DOM, usa Selenium o Puppeteer.

Para agencias y equipos que facturan en USD y automatizan pruebas a diario, empezar por el enfoque sin navegador suele traducirse en menos infraestructura y un costo más predecible.

Método 1: solo con solicitudes HTTP

Para formularios de inicio de sesión que aceptan solicitudes POST estándar, este es el camino más directo. Cargas la página para obtener las cookies y el sitekey, resuelves el CAPTCHA y envías el formulario con el token en el campo correspondiente, todo dentro de una misma requests.Session():

import requests
import time

API_KEY = "YOUR_API_KEY"

def solve_recaptcha(site_key, page_url):
    resp = requests.get("https://ocr.captchaai.com/in.php", params={
        "key": API_KEY, "method": "userrecaptcha",
        "googlekey": site_key, "pageurl": page_url
    })
    task_id = resp.text.split("|")[1]
    for _ in range(60):
        time.sleep(5)
        result = requests.get("https://ocr.captchaai.com/res.php", params={
            "key": API_KEY, "action": "get", "id": task_id
        })
        if result.text == "CAPCHA_NOT_READY": continue
        if result.text.startswith("OK|"): return result.text.split("|")[1]
        raise Exception(result.text)
    raise TimeoutError()

# Login flow
session = requests.Session()
login_url = "https://staging.example.com/qa-login"

# Load login page to get cookies and site key
page = session.get(login_url)
# Extract site_key from the page HTML...
site_key = "6Le-wvkS..."

# Solve CAPTCHA
token = solve_recaptcha(site_key, login_url)

# Submit login form
resp = session.post(login_url, data={
    "username": "user@example.com",
    "password": "your_password",
    "g-recaptcha-response": token
})

if resp.url != login_url:
    print("Login successful!")
    # session now has auth cookies for subsequent requests

El token de reCAPTCHA viaja en el campo g-recaptcha-response; para Turnstile sería cf-turnstile-response. La misma sesión conserva las cookies de autenticación para las solicitudes posteriores.

Método 2: Selenium con Python

Cuando la página de inicio de sesión necesita ejecutar JavaScript, un navegador real te ahorra sorpresas. Selenium rellena las credenciales, lee el sitekey directamente del DOM, resuelve el CAPTCHA con la misma función anterior e inyecta el token antes de pulsar el botón de envío:

from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
import requests
import time

API_KEY = "YOUR_API_KEY"

options = webdriver.ChromeOptions()
driver = webdriver.Chrome(options=options)

# Navigate to login page
driver.get("https://staging.example.com/qa-login")
wait = WebDriverWait(driver, 10)

# Fill in credentials
username_field = wait.until(EC.presence_of_element_located((By.NAME, "username")))
username_field.send_keys("user@example.com")
driver.find_element(By.NAME, "password").send_keys("your_password")

# Extract site key and solve
recaptcha = driver.find_element(By.CLASS_NAME, "g-recaptcha")
site_key = recaptcha.get_attribute("data-sitekey")

token = solve_recaptcha(site_key, driver.current_url)

# Inject token
driver.execute_script(
    f"document.getElementById('g-recaptcha-response').innerHTML = '{token}';"
)

# Submit
driver.find_element(By.CSS_SELECTOR, 'button[type="submit"]').click()
wait.until(EC.url_changes(driver.current_url))
print(f"Logged in! Now at: {driver.current_url}")

Método 3: Puppeteer con Node.js

Si tu stack es JavaScript, Puppeteer sigue exactamente el mismo patrón: abre el navegador headless, escribe las credenciales, obtiene el sitekey con $eval, resuelve el CAPTCHA contra la API y coloca el token en el DOM antes de enviar.

const puppeteer = require("puppeteer");
const axios = require("axios");

const API_KEY = "YOUR_API_KEY";

async function solveRecaptcha(siteKey, pageUrl) {
  const submit = await axios.get("https://ocr.captchaai.com/in.php", {
    params: {
      key: API_KEY,
      method: "userrecaptcha",
      googlekey: siteKey,
      pageurl: pageUrl,
    },
  });
  const taskId = submit.data.split("|")[1];

  while (true) {
    await new Promise((r) => setTimeout(r, 5000));
    const result = await axios.get("https://ocr.captchaai.com/res.php", {
      params: { key: API_KEY, action: "get", id: taskId },
    });
    if (result.data === "CAPCHA_NOT_READY") continue;
    if (result.data.startsWith("OK|")) return result.data.split("|")[1];
    throw new Error(result.data);
  }
}

(async () => {
  const browser = await puppeteer.launch({ headless: "new" });
  const page = await browser.newPage();
  await page.goto("https://staging.example.com/qa-login");

  // Fill credentials
  await page.type("#username", "user@example.com");
  await page.type("#password", "your_password");

  // Get site key and solve
  const siteKey = await page.$eval(".g-recaptcha", (el) =>
    el.getAttribute("data-sitekey")
  );
  const token = await solveRecaptcha(siteKey, page.url());

  // Inject and submit
  await page.evaluate(
    (t) => (document.getElementById("g-recaptcha-response").innerHTML = t),
    token
  );
  await page.click('button[type="submit"]');
  await page.waitForNavigation();

  console.log("Logged in:", page.url());
  await browser.close();
})();

Cuando el login añade verificación en dos pasos

Muchos portales encadenan el CAPTCHA con una autenticación multifactor (MFA). El patrón no cambia: resuelves el CAPTCHA y envías las credenciales; si el sitio te redirige a una pantalla de verificación, respondes con el código en un segundo POST sobre la misma sesión. Así se ve el flujo completo:

# Step 1: Solve CAPTCHA and submit login
token = solve_recaptcha(site_key, login_url)
resp = session.post(login_url, data={
    "username": "user@example.com",
    "password": "your_password",
    "g-recaptcha-response": token
})

# Step 2: Handle MFA page (if redirected)
if "verify" in resp.url or "mfa" in resp.url:
    # Your MFA code logic here
    mfa_code = get_mfa_code()
    resp = session.post(resp.url, data={"code": mfa_code})

# Step 3: Verify logged in
assert "dashboard" in resp.url

Un caso práctico: QA del panel interno de una agencia

Imagina un equipo en Ciudad de México que mantiene un panel de control interno protegido con Turnstile antes del formulario de acceso. Cada despliegue necesita una prueba de humo que confirme que el login sigue funcionando. Con el Método 1 basta un script programado que repite tres pasos:

1. Resuelve el Turnstile con la API y obtiene el token.
2. Envía las credenciales de una cuenta de prueba en staging junto con el token.
3. Comprueba que la respuesta redirige al dashboard.

Si el token caduca o el envío falla, la prueba avisa antes de que lo note un usuario. Es automatización de tu propio flujo, sobre un entorno que controlas, y encaja igual de bien en pipelines de CI que en un cron sencillo.

Errores frecuentes y cómo resolverlos

Preguntas frecuentes

¿Necesito un navegador para automatizar un login?

No siempre. Si el formulario acepta un POST estándar, requests es suficiente y más rápido. Recurre a Selenium o Puppeteer solo cuando el acceso dependa de JavaScript o de interacciones dinámicas del DOM.

¿Cuánto tarda en caducar el token del CAPTCHA?

Los tokens de reCAPTCHA y Turnstile viven alrededor de dos minutos. Resuelve el CAPTCHA justo antes de enviar el formulario y no lo guardes para reutilizarlo más tarde: si el envío se demora, vuelve a resolver.

¿CaptchaAI resuelve el reCAPTCHA v3 invisible de un login?

Sí. reCAPTCHA v3 es invisible y asigna una puntuación en segundo plano; CaptchaAI devuelve un token válido con el método userrecaptcha y la versión v3. Asegúrate de enviar el mismo action que espera la página de acceso.

¿Qué plan de CaptchaAI necesito para automatizar inicios de sesión?

Depende de cuántos logins resuelvas a la vez. El plan BASIC ($15/mes, 5 threads) cubre pruebas y automatizaciones pequeñas; si lanzas muchos accesos concurrentes, ADVANCE ($90/mes, 50 threads) da más margen. Cada thread admite resoluciones ilimitadas durante el mes.

Cuando tengas el patrón claro, ponerlo en marcha lleva minutos. Crea tu cuenta en captchaai.com, toma tu API key y resuelve el primer CAPTCHA de tu flujo de login.

Guías relacionadas

• Pipeline de pruebas automatizadas con Selenium
• Resolver CAPTCHA con Puppeteer en Node.js
• Manejo de CAPTCHA con Playwright