Cómo resolver CAPTCHA con TinyFish AgentQL – Guía paso a paso usando CapSolver

Cuando tu automatización web impulsada por IA choca con un muro de CAPTCHA, toda la cadena de procesamiento se detiene. Las páginas no se cargan, los formularios no se pueden enviar y la extracción de datos se detiene — todo porque un desafío diseñado para bloquear bots. TinyFish AgentQL es un potente conjunto de herramientas para conectar la IA con la web, que incluye consultas en lenguaje natural, integraciones con Playwright y extracción de datos estructurados a escala empresarial. Pero como cualquier marco de automatización de navegadores, se queda atascado en los CAPTCHAs.

CapSolver cambia esto por completo. Al cargar la extensión de Chrome CapSolver en el contexto del navegador de AgentQL basado en Playwright, los CAPTCHAs se resuelven automáticamente y de forma invisible en segundo plano. Sin resolver manualmente. Sin orquestación compleja de API por tu parte. Tus scripts de automatización continúan ejecutándose como si el CAPTCHA nunca hubiera existido.

Lo mejor de todo es que tus consultas y scripts de AgentQL no necesitan ni una línea de código relacionado con CAPTCHA. La extensión se encarga por completo de la detección, resolución e inyección de tokens, mientras que tu agente se enfoca en lo que hace mejor: extraer datos y automatizar flujos de trabajo.

¿Qué es TinyFish AgentQL?

TinyFish AgentQL es una herramienta empresarial para conectar agentes de IA y LLMs con entornos web en vivo. Desarrollado por TinyFish, proporciona un lenguaje de consulta impulsado por IA que te permite localizar elementos de página y extraer datos estructurados usando lenguaje natural — sin necesidad de selectores CSS frágiles o XPaths.

Características clave

• Lenguaje de consultas impulsado por IA: Encuentra elementos intuitivamente basado en el contenido de la página. Las consultas se reparan automáticamente a medida que cambia la interfaz de usuario.
• Integración con Playwright: Los SDKs de Python y JavaScript se integran sin problemas con Playwright para automatización avanzada de navegadores.
• Extracción de datos estructurados: Define formas de salida y obtén datos limpios y estructurados de cualquier página — pública o privada, estática o dinámica.
• API REST: Ejecuta consultas sin SDKs a través de un punto de conexión REST.
• Depurador de navegador: Una extensión de Chrome para probar y perfeccionar consultas en tiempo real.
• Resiliencia cruzada de sitios: Funciona en sitios similares sin modificación, adaptándose dinámicamente a los cambios en la página.
• Escala empresarial: Diseñado para cargas de trabajo de alto rendimiento, ejecutando cientos de tareas en paralelo.

AgentQL opera en cualquier página — incluyendo contenido autenticado y páginas generadas dinámicamente — lo que lo hace ideal para automatización a gran escala, recolección de datos y flujos de trabajo de agentes de IA.

¿Qué es CapSolver?

CapSolver es un servicio líder de resolución de CAPTCHA impulsado por IA que resuelve automáticamente diversos desafíos de CAPTCHA. Con tiempos de respuesta rápidos y amplia compatibilidad, CapSolver se integra sin problemas en flujos de trabajo automatizados.

Tipos de CAPTCHA compatibles

• reCAPTCHA v2 (casilla y invisible)
• reCAPTCHA v3 & v3 Enterprise
• Cloudflare Turnstile
• Cloudflare 5-second Challenge
• AWS WAF CAPTCHA
• Más

¿Por qué esta integración es diferente?

La mayoría de las integraciones de resolución de CAPTCHA requieren que escribas código repetitivo: crear tareas, consultar resultados, inyectar tokens en campos ocultos. Ese es el enfoque estándar con scripts de Playwright o Puppeteer.

AgentQL + CapSolver toma un enfoque fundamentalmente diferente:

La clave del insight: La extensión de CapSolver se ejecuta dentro del contexto del navegador de Playwright de AgentQL. Cuando AgentQL navega a una página con un CAPTCHA, la extensión lo detecta, lo resuelve en segundo plano y inyecta el token — todo antes de que tu script interactúe con el formulario. Tu código de automatización permanece limpio, enfocado y libre de CAPTCHA.

Requisitos previos

Antes de configurar la integración, asegúrate de tener:

• TinyFish AgentQL instalado (SDK de Python o SDK de JavaScript)
• Una cuenta de CapSolver con clave de API (regístrate aquí)
• Node.js 16+ y Python 3.8+ (dependiendo de tu elección de SDK)
• Playwright instalado con Chromium

Importante: Las extensiones de Chrome solo funcionan en Chromium con un contexto persistente en Playwright. Esto es un requisito de Playwright, no una limitación de AgentQL.

Configuración paso a paso

Paso 1: Instalar AgentQL

SDK de Python:

pip install agentql
playwright install chromium

SDK de JavaScript:

npm install agentql
npx playwright install chromium

Paso 2: Descargar la extensión de Chrome de CapSolver

Descarga la extensión de Chrome de CapSolver y cópiala a un directorio dedicado:

1. Ve a la versión 1.17.0 de la extensión de Chrome de CapSolver
2. Descarga CapSolver.Browser.Extension-chrome-v1.17.0.zip
3. Extrae el zip:

mkdir -p ~/capsolver-extension
unzip CapSolver.Browser.Extension-chrome-v*.zip -d ~/capsolver-extension/

4. Verifica que la extracción haya funcionado:

ls ~/capsolver-extension/manifest.json

Deberías ver manifest.json — esto confirma que la extensión está en el lugar correcto.

Paso 3: Configurar tu clave de API de CapSolver

Abre el archivo de configuración de la extensión en ~/capsolver-extension/assets/config.js y reemplaza el valor de apiKey con el tuyo:

export const defaultConfig = {
  apiKey: 'CAP-XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX', // ← aquí tu clave
  useCapsolver: true,
  // ... resto de la configuración
};

Puedes obtener tu clave de API desde tu panel de CapSolver.

Paso 4: Iniciar AgentQL con la extensión de CapSolver

El paso crítico es iniciar Chromium de Playwright con un contexto persistente que cargue la extensión de CapSolver.

Ejemplo en Python:

import agentql
from playwright.sync_api import sync_playwright
import time
import os

# Ruta de la extensión de CapSolver
CAPSOLVER_EXTENSION_PATH = os.path.expanduser("~/capsolver-extension")

def main():
    with sync_playwright() as p:
        # Iniciar Chromium con contexto persistente y extensión de CapSolver
        context = p.chromium.launch_persistent_context(
            user_data_dir="./browser-data",
            headless=False,  # Las extensiones requieren modo no cabeza
            args=[
                f"--disable-extensions-except={CAPSOLVER_EXTENSION_PATH}",
                f"--load-extension={CAPSOLVER_EXTENSION_PATH}",
            ],
        )

        # Envolver la página con AgentQL para consultas impulsadas por IA
        page = agentql.wrap(context.pages[0])

        # Navegar a tu página objetivo
        page.goto("https://example.com/protected-page")

        # Esperar a que CapSolver detecte y resuelva cualquier CAPTCHA
        time.sleep(30)

        # Encontrar y hacer clic en el botón de envío usando consultas de lenguaje natural de AgentQL
        response = page.query_elements("""
        {
            submit_button
        }
        """)

        # Hacer clic en el botón de envío — ¡el CAPTCHA ya está resuelto!
        response.submit_button.click()

        # Extraer datos después del envío
        result = page.query_data("""
        {
            confirmation_message
        }
        """)

        print(f"Resultado: {result['confirmation_message']}")

        context.close()

if __name__ == "__main__":
    main()

Ejemplo en JavaScript:

const { chromium } = require('playwright');
const agentql = require('agentql');
const path = require('path');
const os = require('os');

const CAPSOLVER_EXTENSION_PATH = path.join(os.homedir(), 'capsolver-extension');

(async () => {
  // Iniciar Chromium con contexto persistente y extensión de CapSolver
  const context = await chromium.launchPersistentContext('./browser-data', {
    headless: false, // Las extensiones requieren modo no cabeza
    args: [
      `--disable-extensions-except=${CAPSOLVER_EXTENSION_PATH}`,
      `--load-extension=${CAPSOLVER_EXTENSION_PATH}`,
    ],
  });

  // Obtener la primera página y envolverla con AgentQL
  const page = agentql.wrap(context.pages()[0]);

  // Navegar a la página objetivo
  await page.goto('https://example.com/protected-page');

  // Esperar a que CapSolver maneje cualquier CAPTCHA
  await page.waitForTimeout(30000);

  // Usar consultas de AgentQL para interactuar — ¡el CAPTCHA ya está resuelto
  const response = await page.queryElements(`{
    submit_button
  }`);

  await response.submit_button.click();

  // Extraer datos de resultado
  const result = await page.queryData(`{
    confirmation_message
  }`);

  console.log('Resultado:', result.confirmation_message);

  await context.close();
})();

Paso 5: Verificar que la extensión esté cargada

Después de iniciar el navegador, puedes verificar que la extensión de CapSolver esté activa navegando a chrome://extensions en la ventana del navegador. Deberías ver la extensión de CapSolver listada y habilitada.

Alternativamente, revisa la consola del navegador en busca de mensajes de registro de CapSolver indicando que el servicio de trabajo está en ejecución.

Cómo usarlo

Una vez que la configuración esté completa, usar CapSolver con AgentQL es sencillo.

La regla dorada

No escribas código específico de CAPTCHA. Simplemente agrega un tiempo de espera antes de interactuar con formularios protegidos por CAPTCHA y deja que la extensión haga su trabajo.

Ejemplo 1: Envío de formulario detrás de reCAPTCHA

page.goto("https://example.com/contact")

# Rellenar el formulario usando consultas de AgentQL
response = page.query_elements("""
{
    contact_form {
        name_field
        email_field
        message_field
        submit_button
    }
}
""")

response.contact_form.name_field.fill("John Doe")
response.contact_form.email_field.fill("john@example.com")
response.contact_form.message_field.fill("Hello, I have a question about your services.")

# Esperar a que CapSolver resuelva el CAPTCHA
time.sleep(30)

# Enviar — el token de CAPTCHA ya está inyectado
response.contact_form.submit_button.click()

Ejemplo 2: Página de inicio de sesión con Cloudflare Turnstile

page.goto("https://example.com/login")

# Esperar a que CapSolver resuelva el desafío de Turnstile
time.sleep(25)

# Encontrar elementos del formulario de inicio de sesión con AgentQL
response = page.query_elements("""
{
    login_form {
        email_input
        password_input
        login_button
    }
}
""")

# Rellenar el formulario — Turnstile ya está manejado
response.login_form.email_input.fill("me@example.com")
response.login_form.password_input.fill("mypassword123")

# Hacer clic en iniciar sesión
response.login_form.login_button.click()

Ejemplo 3: Extracción de datos de páginas protegidas

page.goto("https://example.com/data")

# Esperar a que cualquier desafío de CAPTCHA se resuelva
time.sleep(30)

# Extraer datos estructurados con AgentQL
data = page.query_data("""
{
    products[] {
        name
        price
        rating
        availability
    }
}
""")

for product in data['products']:
    print(f"{product['name']}: ${product['price']} ({product['rating']} estrellas)")

Tiempos de espera recomendados

Consejo: Si dudas, usa 30 segundos. Es mejor esperar un poco más que enviar demasiado pronto. El tiempo adicional no afecta el resultado.

Cómo funciona en segundo plano

Esto es lo que ocurre cuando AgentQL se ejecuta con la extensión de CapSolver cargada:

Tu script de AgentQL
───────────────────────────────────────────────────
page.goto("https://...")       ──► Chromium carga la página
                                           │
                                           ▼
                               ┌─────────────────────────────┐
                               │  Página con widget de CAPTCHA     │
                               │                               │
                               │  Extensión de CapSolver:         │
                               │  1. El script de contenido detecta │
                               │     CAPTCHA en la página        │
                               │  2. El trabajador de servicio llama │
                               │     a la API de CapSolver       │
                               │  3. Se recibe el token          │
                               │  4. El token se inyecta en       │
                               │     un campo de formulario oculto │
                               └─────────────────────────────┘
                                           │
                                           ▼
time.sleep(30)                   La extensión resuelve el CAPTCHA...
                                           │
                                           ▼
page.query_elements(...)         AgentQL encuentra los elementos del formulario
submit_button.click()            El formulario se envía CON el token válido
                                           │
                                           ▼
                               "Verificación exitosa!"

Cómo carga la extensión

Cuando Playwright inicia Chromium con la bandera --load-extension:

1. Chromium inicia con la extensión de CapSolver cargada
2. La extensión se activa — su trabajador de servicio comienza y los scripts de contenido se inyectan en cada página
3. En páginas con CAPTCHAs — el script de contenido detecta el widget, llama a la API de CapSolver y inyecta el token de solución en la página
4. AgentQL opera normalmente — las consultas, clics y extracción de datos funcionan como de costumbre, con los CAPTCHAs ya resueltos

Referencia de configuración completa

Aquí tienes una configuración completa en Python con todas las opciones de configuración para la integración de AgentQL + CapSolver:

import agentql
from playwright.sync_api import sync_playwright
import os

# Configuración
CAPSOLVER_EXTENSION_PATH = os.path.expanduser("~/capsolver-extension")
USER_DATA_DIR = "./browser-data"

with sync_playwright() as p:
    context = p.chromium.launch_persistent_context(
        user_data_dir=USER_DATA_DIR,
        headless=False,
        args=[
            f"--disable-extensions-except={CAPSOLVER_EXTENSION_PATH}",
            f"--load-extension={CAPSOLVER_EXTENSION_PATH}",
        ],
    )
    page = agentql.wrap(context.pages[0])
    # ... tu código de automatización aquí
    context.close()

Opciones de configuración

La clave de la API de CapSolver se configura directamente en el archivo assets/config.js de la extensión (consulte el paso 3 anterior).

Uso de CapSolver con TinyFish Browser

Todo lo anterior asume que está ejecutando Chromium por su cuenta, localmente, con un contexto de Playwright persistente para que la extensión de CapSolver se pueda cargar. Pero no todos los entornos le dan este tipo de control: si su automatización se ejecuta contra TinyFish Browser, el servicio remoto de sesiones de navegador a demanda de TinyFish, no gestiona directamente el proceso de Chromium, por lo que no puede cargar una extensión desempaquetada de la misma manera.

Para ese escenario, CapSolver se puede integrar a través de su API, directamente en su script: solicita una sesión de navegador remoto desde TinyFish Browser, se conecta a través de CDP con Playwright, resuelve el CAPTCHA con el SDK de CapSolver y inyecta el token resultante en la página usted mismo. Es el enfoque más "tradicional", basado en código, descrito anteriormente en este artículo: pero es la herramienta adecuada cuando no se puede cargar una extensión en la instancia del navegador que está controlando.

Antes de comenzar, instale el SDK de CapSolver:

pip install capsolver

El siguiente código muestra cómo usar CapSolver para resolver un reCAPTCHA dentro de una sesión de TinyFish Browser:

import time
import requests
import capsolver
from playwright.sync_api import sync_playwright


TINYFISH_API_KEY = "SU CLAVE DE API DE TINYFISH"
capsolver.api_key = "SU CLAVE DE API DE CAPSOLVER"


website_url = "https://www.google.com/recaptcha/api2/demo"
website_key = "6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-"
captcha_type = "ReCaptchaV2TaskProxyLess"


def create_tinyfish_browser(url):
    resp = requests.post(
        "https://api.browser.tinyfish.ai",
        headers={
            "X-API-Key": TINYFISH_API_KEY,
            "Content-Type": "application/json",
        },
        json={
            "url": url,
            "timeout_seconds": 300,
        },
        timeout=90,
    )
    resp.raise_for_status()
    return resp.json()


def close_tinyfish_browser(session_id):
    try:
        requests.delete(
            f"https://api.browser.tinyfish.ai/{session_id}",
            headers={"X-API-Key": TINYFISH_API_KEY},
            timeout=30,
        )
    except Exception as exc:
        print("   Fallo al cerrar la sesión del navegador TinyFish:", repr(exc))


def solve_recaptcha_v2():
    print("3. Resolviendo reCAPTCHA con CapSolver")
    solution = capsolver.solve({
        "type": captcha_type,
        "websiteURL": website_url,
        "websiteKey": website_key,
    })

    token = solution.get("gRecaptchaResponse")
    if not token:
        raise RuntimeError(f"CapSolver no devolvió un token de reCAPTCHA: {solution}")

    print("   Tarea de CapSolver resuelta：", token)
    return token


def inject_recaptcha_token(page, token):
    page.evaluate(
        """
        (token) => {
            const textarea = document.getElementById('g-recaptcha-response');
            if (textarea) {
                textarea.value = token;
            }
        }
        """,
        token,
    )
    print("   Token de CapSolver inyectado")
    page.click('input[type="submit"]')
    print("   Botón de enviar clicado")


def main():
    session_id = None
    try:
        print("1. Creando sesión del navegador TinyFish")
        session = create_tinyfish_browser(website_url)

        session_id = session["session_id"]
        cdp_url = session["cdp_url"]
        print("   ID de sesión TinyFish:", session_id)
        print("   URL de CDP de TinyFish:", cdp_url)

        with sync_playwright() as p:
            print("2. Conectando al navegador TinyFish a través de CDP")
            browser = p.chromium.connect_over_cdp(cdp_url)
            context = browser.contexts[0]
            page = context.pages[0] if context.pages else context.new_page()
            page.wait_for_load_state("domcontentloaded", timeout=60000)
            print("   URL de la página actual:", page.url)

            token = solve_recaptcha_v2()

            print("4. Inyectando el token de Capsolver")
            inject_recaptcha_token(page, token)

            page.wait_for_load_state("domcontentloaded", timeout=30000)
            time.sleep(3)

            body_text = page.locator("body").inner_text(timeout=10000)
            print("5. Resultado de la página:", " ".join(body_text.split()))

            print("6. Cerrando sesiones del navegador")
            browser.close()
    finally:
        if session_id:
            close_tinyfish_browser(session_id)


if __name__ == "__main__":
    main()

Cualquiera que sea el enfoque que se adapte a su configuración — cargar la extensión de CapSolver en un contexto de Playwright local y persistente, o llamar directamente a la API de CapSolver contra una sesión de TinyFish Browser remoto — el objetivo es el mismo: la automatización de AgentQL nunca debe necesitar lógica de manejo de CAPTCHA propia.

Solución de problemas

Extensión no cargada

Síntoma: Los CAPTCHAS no se resuelven automáticamente.

Causa: Es posible que esté usando un contexto de navegador regular en lugar de un contexto persistente, o que esté ejecutándose en modo sin cabeza.

Solución: Las extensiones en Playwright requieren un contexto persistente y modo con interfaz gráfica:

# ✅ Correcto — contexto persistente, modo con interfaz gráfica
context = p.chromium.launch_persistent_context(
    user_data_dir="./browser-data",
    headless=False,
    args=[...argumentos de extensión...]
)

# ❌ Incorrecto — contexto regular (las extensiones no se cargarán)
browser = p.chromium.launch()
context = browser.new_context()

CAPTCHA no resuelto (formulario falla)

Posibles causas:

• Tiempo de espera insuficiente — Aumente a 60 segundos
• Clave de API inválida — Verifique su panel de CapSolver
• Saldo insuficiente — Recargue su cuenta de CapSolver
• Extensión no cargada — Vea "Extensión no cargada" anteriormente

Modo sin cabeza no compatible

Síntoma: El script se ejecuta pero no aparece la extensión.

Causa: Las extensiones de Chrome no funcionan en modo sin cabeza.

Solución: Use el modo con interfaz gráfica con un entorno virtual en servidores:

# Instalar Xvfb
sudo apt-get install xvfb

# Iniciar un entorno virtual
Xvfb :99 -screen 0 1280x720x24 &

# Establecer DISPLAY
export DISPLAY=:99

Compatibilidad con Chrome 137+

Síntoma: La bandera de extensión se ignora silenciosamente.

Causa: Chrome 137+ eliminó el soporte para --load-extension en builds oficiales.

Solución: Use el Chromium de Playwright (recomendado) o Chrome para Testing:

# Instalar Chromium de Playwright (recomendado)
npx playwright install chromium

# O descargar Chrome para Testing
# Visite: https://googlechromelabs.github.io/chrome-for-testing/

Buenas prácticas

1. Siempre use tiempos de espera generosos. Más tiempo de espera siempre es más seguro. El CAPTCHA generalmente se resuelve en 5-20 segundos, pero la latencia de red, desafíos complejos o reintentos pueden agregar tiempo. 30-60 segundos es el punto óptimo.

2. Mantenga sus scripts de automatización limpios. No agregue lógica específica de CAPTCHA a sus consultas de AgentQL. La extensión maneja todo — su código debe centrarse únicamente en la extracción de datos e interacción.

3. Monitoree su saldo de CapSolver. Cada resolución de CAPTCHA cuesta créditos. Verifique su saldo en capsolver.com/dashboard regularmente para evitar interrupciones.

4. Use consistentemente el contexto persistente. Siempre inicie con launch_persistent_context() cuando necesite extensiones. Esto también preserva cookies y datos de sesión entre ejecuciones, lo que puede reducir la frecuencia de CAPTCHA.

5. Use Xvfb en servidores sin cabeza. Las extensiones de Chrome requieren un contexto de visualización. Configure Xvfb para entornos de servidor donde no haya una pantalla física disponible.

6. Ajuste la integración a su entorno. Use el enfoque basado en extensión siempre que controle directamente el proceso de Chromium y pueda lanzar un contexto persistente. Use el enfoque basado en API con el SDK de CapSolver siempre que se conecte a un navegador que no controle el lanzamiento — como una sesión de TinyFish Browser remoto a través de CDP.

Conclusión

La integración de TinyFish AgentQL + CapSolver trae la resolución de CAPTCHA invisible a uno de los conjuntos de herramientas de automatización web más poderosos disponibles. En lugar de escribir código complejo para manejar CAPTCHAS, simplemente:

1. Descargue la extensión de CapSolver y configure su clave de API
2. Inicie el navegador de AgentQL de Playwright con la extensión cargada a través de un contexto persistente
3. Escriba sus scripts de automatización como de costumbre — simplemente agregue un tiempo de espera antes de enviar formularios

La extensión de CapSolver maneja el resto — detecta CAPTCHAS, los resuelve a través de la API de CapSolver y inyecta tokens en la página. Sus scripts de AgentQL nunca necesitan saber nada sobre CAPTCHAS en absoluto.

Y cuando su automatización se ejecute contra una sesión remota en lugar de un navegador local — como TinyFish Browser — el SDK y la API de CapSolver le permiten obtener el mismo resultado con unos pocos líneas adicionales de código: solicite la sesión, conéctese a través de CDP, resuelva y inyecte.

Este es el aspecto de la resolución de CAPTCHA cuando combina automatización web impulsada por IA con resolución de CAPTCHA impulsada por IA: invisible, automática y sin código.

¿Listo para comenzar? Regístrese en CapSolver y use el código de bonificación AGENTQL para obtener un 6% adicional en su primer recarga!

Preguntas frecuentes

¿Necesito escribir código específico para CAPTCHA en mis scripts de AgentQL?

No. La extensión de CapSolver funciona completamente en segundo plano dentro del contexto del navegador de Playwright. Simplemente agregue un time.sleep() o waitForTimeout() antes de enviar formularios, y la extensión maneja la detección, resolución e inyección de tokens automáticamente.

¿Por qué necesito un contexto persistente?

Playwright solo admite extensiones de Chrome cuando se usa launch_persistent_context(). Esto es un requisito arquitectónico de Playwright. Los contextos de navegador regulares creados mediante browser.new_context() no pueden cargar extensiones.

¿Puedo ejecutar esto en modo sin cabeza?

No. Las extensiones de Chrome requieren un navegador con interfaz gráfica. Para entornos de servidor sin pantalla, use Xvfb (X Virtual Framebuffer) para crear una pantalla virtual.

¿Qué pasa si estoy usando una sesión de TinyFish Browser remoto en lugar de mi propio Chromium local?

Como no controla directamente el lanzamiento del navegador, no puede cargar la extensión de CapSolver en una sesión de TinyFish Browser. En su lugar, use el SDK de CapSolver para resolver el CAPTCHA e inyectar el token resultante usted mismo a través de page.evaluate() después de conectarse a través de CDP, como se muestra en la sección "Uso de CapSolver con TinyFish Browser" anteriormente.

¿Qué tipos de CAPTCHA admite CapSolver?

CapSolver admite reCAPTCHA v2 (casilla e invisible), reCAPTCHA v3, Cloudflare Turnstile, AWS WAF CAPTCHA y más. La extensión detecta automáticamente el tipo de CAPTCHA y lo resuelve en consecuencia.

¿Cuánto cuesta CapSolver?

CapSolver ofrece precios competitivos según el tipo de CAPTCHA y el volumen. Visite capsolver.com para conocer los precios actuales.

¿Es gratis TinyFish AgentQL?

AgentQL ofrece tarifas gratuitas y pagadas. El SDK y el lenguaje de consulta están disponibles para desarrollo y pruebas. Visite tinyfish.ai para obtener detalles de precios.

¿Cuánto tiempo debo esperar para que se resuelva el CAPTCHA?

Para la mayoría de los CAPTCHAS, 30-60 segundos son suficientes. El tiempo de resolución real suele ser de 5-20 segundos, pero agregar un tiempo adicional garantiza la fiabilidad. Si hay dudas, use 30 segundos.