reCAPTCHA v2 Invisible: Detección y resolución de activadores

Si un formulario deja de enviarse y no ves ninguna casilla que marcar, lo más probable es que estés ante reCAPTCHA v2 Invisible. A diferencia de la variante clásica, no pinta una casilla de verificación: se dispara solo cuando envías el formulario o pulsas un botón, y únicamente muestra un desafío cuando el análisis de riesgos de Google considera sospechoso al visitante. Para quien automatiza un flujo, eso significa un fallo silencioso: el submit se ejecuta, pero el backend rechaza la petición porque falta un token que nunca supiste que hacía falta.

Esta guía te muestra cómo reconocer la variante invisible, extraer los parámetros que necesita el solver y resolverla con la API de CaptchaAI —que la resuelve de forma nativa— sin romper la devolución de llamada que el sitio espera.

En qué se diferencia de reCAPTCHA v2 estándar

La versión estándar es explícita: hay una casilla, el usuario la marca y ese gesto genera el token. La invisible mueve esa lógica al envío del formulario, así que la única pista visible suele ser una pequeña insignia (badge) en una esquina. La tabla resume las diferencias que importan al automatizar:

La consecuencia práctica: no puedes esperar a verlo; tienes que detectarlo por sus rastros en el DOM y en los scripts antes de resolverlo.

Cómo detectar reCAPTCHA v2 Invisible en la página

Hay cuatro señales fiables, de la más directa a la más indirecta:

• el atributo data-size="invisible" en el div .g-recaptcha;
• la insignia .grecaptcha-badge en una esquina de la página;
• llamadas a grecaptcha.execute() dentro de los scripts en línea;
• un parámetro render= con la clave del sitio en la URL del script.

Recórrelas en orden: la primera confirma la mayoría de los casos y las demás cubren las páginas que invocan el widget por código.

Método 1: revisa el atributo data-size

// Browser console
const widgets = document.querySelectorAll('.g-recaptcha');
widgets.forEach((el, i) => {
  const size = el.getAttribute('data-size');
  const sitekey = el.getAttribute('data-sitekey');
  console.log(`Widget ${i}: size=${size}, sitekey=${sitekey}`);
  if (size === 'invisible') {
    console.log('  → This is Invisible reCAPTCHA');
  }
});

El data-size="invisible" es la confirmación más directa, y de paso obtienes el data-sitekey que enviarás a CaptchaAI.

Método 2: busca la insignia (badge)

reCAPTCHA v2 Invisible muestra una pequeña insignia en la esquina, aunque no haya ningún desafío visible:

const badge = document.querySelector('.grecaptcha-badge');
if (badge) {
  console.log('reCAPTCHA badge found — likely Invisible reCAPTCHA');
  console.log('Badge visibility:', getComputedStyle(badge).visibility);
}

Si existe .grecaptcha-badge pero no hay casilla, es una señal fuerte de la variante invisible o de reCAPTCHA v3.

Método 3: rastrea las llamadas a grecaptcha.execute

Cuando la página invoca el widget por código (sin div .g-recaptcha), la pista está en los scripts en línea:

// Look for grecaptcha.execute in page scripts
document.querySelectorAll('script:not([src])').forEach(s => {
  if (s.textContent.includes('grecaptcha.execute')) {
    console.log('Found grecaptcha.execute — Invisible reCAPTCHA');
    const match = s.textContent.match(/grecaptcha\.execute\s*\(\s*['"]?([^'",\s)]+)/);
    if (match) console.log('Sitekey:', match[1]);
  }
});

Método 4: inspecciona el parámetro render del script

document.querySelectorAll('script[src*="recaptcha"]').forEach(s => {
  if (s.src.includes('render=') && !s.src.includes('render=explicit')) {
    console.log('Invisible/v3 reCAPTCHA detected in script:', s.src);
  }
});

Un render= con la clave del sitio (en lugar de render=explicit) delata la carga automática de la variante invisible.

Cómo resolverlo con la API de CaptchaAI

Una vez que tienes el sitekey y la URL de la página, el flujo es el habitual de CaptchaAI:

1. envías la tarea a in.php con el sitekey y invisible=1;
2. sondeas el resultado en res.php cada pocos segundos;
3. recibes el token y lo inyectas en la página.

La diferencia con la casilla clásica cabe en un parámetro: pasa invisible=1 para que el solver sepa que resuelve la variante invisible. Si lo omites, puede devolver un token que el sitio rechazará.

Regla práctica: si el token se resuelve pero el sitio lo rechaza, comprueba antes que nada que enviaste invisible=1.

Python

import requests
import time

API_KEY = "YOUR_API_KEY"

# Submit with invisible flag
resp = requests.post("https://ocr.captchaai.com/in.php", data={
    "key": API_KEY,
    "method": "userrecaptcha",
    "googlekey": "6Le-SITEKEY",
    "pageurl": "https://staging.example.com/qa-login",
    "invisible": "1",  # critical for Invisible reCAPTCHA
    "json": "1",
}).json()

if resp["status"] != 1:
    raise Exception(f"Submit error: {resp['request']}")

task_id = resp["request"]
print(f"Submitted: {task_id}")

# Poll for result
for _ in range(24):
    time.sleep(5)
    result = requests.get("https://ocr.captchaai.com/res.php", params={
        "key": API_KEY, "action": "get", "id": task_id, "json": "1"
    }).json()

    if result["status"] == 1:
        print(f"Token: {result['request'][:50]}...")
        break
    if result["request"] != "CAPCHA_NOT_READY":
        raise Exception(f"Error: {result['request']}")

El bucle sondea cada 5 segundos y sale al llegar el token; CAPCHA_NOT_READY solo indica que el solver sigue trabajando.

JavaScript

const axios = require('axios');

const resp = await axios.post('https://ocr.captchaai.com/in.php', null, {
  params: {
    key: 'YOUR_API_KEY',
    method: 'userrecaptcha',
    googlekey: '6Le-SITEKEY',
    pageurl: 'https://staging.example.com/qa-login',
    invisible: 1,
    json: 1,
  }
});
const taskId = resp.data.request;
console.log(`Submitted: ${taskId}`);

Piensa en las pruebas de regresión del login de tu propia aplicación —el panel de una agencia en España o un portal de clientes en México— protegido con reCAPTCHA v2 Invisible. Con este patrón, tu suite de QA obtiene un token válido en cada corrida, con un coste mensual predecible en USD.

Cómo inyectar el token y disparar el envío

reCAPTCHA v2 Invisible casi siempre está atado a un botón o al envío del formulario. Recibir el token no basta: hay que colocarlo en el campo g-recaptcha-response y después disparar la devolución de llamada o enviar el formulario, tal como haría un usuario real.

from selenium import webdriver
from selenium.webdriver.common.by import By

driver = webdriver.Chrome()
driver.get("https://staging.example.com/qa-login")

# After solving, inject and trigger
driver.execute_script("""
    // Set the token
    document.querySelector('textarea[name="g-recaptcha-response"]').value = arguments[0];

    // Find and trigger the callback
    var widget = document.querySelector('.g-recaptcha');
    var callbackName = widget ? widget.getAttribute('data-callback') : null;

    if (callbackName && typeof window[callbackName] === 'function') {
        window[callbackName](arguments[0]);
    }
""", token)

# Submit the form
driver.find_element(By.CSS_SELECTOR, "form#login").submit()

El orden importa:

1. coloca el token en el textarea[name="g-recaptcha-response"];
2. llama a la función indicada en data-callback;
3. si el sitio lo requiere, ejecuta el submit final.

Cómo identificar el elemento que dispara el desafío

Antes de inyectar nada conviene saber qué dispara el CAPTCHA. Hay dos patrones. En el primero, el propio botón lleva la clase g-recaptcha:

<button class="g-recaptcha"
        data-sitekey="6Le-SITEKEY"
        data-callback="onSubmit"
        data-size="invisible">
  Submit
</button>

En el segundo, un script llama a grecaptcha.execute() cuando se pulsa un botón cualquiera:

// Site's code
document.getElementById('submit-btn').addEventListener('click', function() {
  grecaptcha.execute();
});

Comprueba los dos casos de una vez para localizar el disparador y sus parámetros:

// Find elements with g-recaptcha class that are buttons
document.querySelectorAll('button.g-recaptcha, input.g-recaptcha').forEach(el => {
  console.log('Trigger element:', el.tagName, el.textContent.trim());
  console.log('  data-sitekey:', el.getAttribute('data-sitekey'));
  console.log('  data-callback:', el.getAttribute('data-callback'));
});

Errores frecuentes al resolver reCAPTCHA v2 Invisible

Preguntas frecuentes

¿Por qué el formulario se envía pero el sitio rechaza la sesión?

Casi siempre es la devolución de llamada. En la variante invisible, colocar el token en g-recaptcha-response no es suficiente: el sitio suele validar dentro de la función data-callback. Si no la disparas, el submit viaja sin la señal que el backend espera.

¿Necesito abrir un navegador para resolverlo?

No para conseguir el token: a la API le basta el sitekey y la URL de la página. Solo necesitas un navegador (o Selenium) para inyectar el token en el DOM y disparar la devolución de llamada dentro del flujo real.

¿Cómo sé si es Invisible v2 o v3?

Invisible v2 llama a grecaptcha.execute() sin parámetro action; v3 usa grecaptcha.execute(sitekey, {action: 'submit'}) con una acción y carga el script con render=SITEKEY. Si ves una acción o una puntuación de por medio, estás ante v3.

¿Qué plan de CaptchaAI conviene para automatizar muchos formularios invisibles?

Depende de la concurrencia, no del número de resoluciones: todos los planes incluyen resoluciones ilimitadas por thread. BASIC ($15/mes, 5 threads) cubre un flujo de QA modesto; para muchas corridas en paralelo, sube a STANDARD ($30/mes, 15 threads) o ADVANCE ($90/mes, 50 threads).

Resuelve reCAPTCHA v2 Invisible con CaptchaAI

Obtén tu clave API en captchaai.com y resuelve tu primer formulario invisible en minutos.

Guías relacionadas

• Mecanismo de devolución de llamada de reCAPTCHA v2
• Extraer parámetros de reCAPTCHA desde el código de la página
• Detectar CAPTCHA desde la consola del navegador