CAPSOLVER
Blog
web scraping
Cómo integrar Camoufox con CapSolver para la resolución de CAPTCHA sin interrupciones

Cómo integrar Camoufox con CapSolver para la resolución de CAPTCHA sin interrupciones

Logo of CapSolver

Aloísio Vítor

Image Processing Expert

16-Dec-2025

TL;DR: Usa Camoufox para evitar el fingerprinting del navegador y CapSolver para resolver automáticamente los CAPTCHAs como Cloudflare Turnstile y reCAPTCHA v2/v3. Juntos, permiten la automatización web estable y con comportamiento humano a escala con mínima detección y altas tasas de éxito.

Introducción

La automatización web se ha vuelto esencial para la recopilación de datos, pruebas y diversas operaciones empresariales. Sin embargo, los sitios web modernos implementan medidas anti-bot y CAPTCHAs sofisticados que pueden detener incluso los scripts de automatización más cuidadosamente elaborados.

La combinación de Camoufox y CapSolver proporciona una solución poderosa para este desafío:

  • Camoufox: Un navegador anti-detección de código abierto basado en Firefox que evita la detección de bots mediante un spoofing avanzado de fingerprinting
  • CapSolver: Un servicio de resolución de CAPTCHA impulsado por inteligencia artificial que maneja Cloudflare Turnstile, reCAPTCHA y más

Juntos, estos herramientas permiten una automatización web fluida que evita tanto la detección de fingerprinting como los desafíos de CAPTCHA.

Objetivos de la integración

Este guía te ayudará a lograr tres objetivos principales:

  1. Evitar la detección de bots - Usa la inyección de fingerprinting de Camoufox para parecer un navegador legítimo
  2. Resolver CAPTCHAs automáticamente - Integra la API de CapSolver para manejar desafíos de CAPTCHA sin intervención manual
  3. Mantener un comportamiento similar al humano - Combina movimientos de mouse humanizados con resolución inteligente de CAPTCHAs

¿Qué es Camoufox?

Camoufox es una versión personalizada minimalista de Firefox diseñada específicamente para scraping y automatización web. A diferencia de otras soluciones anti-detección que dependen de la inyección de JavaScript (que puede ser detectada), Camoufox implementa el spoofing de fingerprinting a nivel de C++ dentro del navegador mismo.

Características clave

  • Inyección de fingerprinting - Spoofea propiedades de navigator, dimensiones de pantalla, WebGL, WebRTC, fuentes, etc., a nivel nativo
  • Movimiento de mouse similar al humano - Algoritmo integrado para interacciones realistas
  • Integración con BrowserForge - Genera fingerprints que imitan distribuciones de dispositivos del mundo real
  • Soporte GeoIP - Calcula automáticamente zona horaria, configuración regional y geolocalización basado en la IP del proxy
  • Soporte para complementos de Firefox - Carga extensiones personalizadas incluyendo bloqueadores de anuncios

Instalación

bash Copy 
# Instalar el paquete de Python
pip install -U camoufox[geoip]

# Descargar el navegador Camoufox
camoufox fetch

Uso básico

python Copy 
from camoufox.sync_api import Camoufox

with Camoufox(humanize=True) as browser:
    page = browser.new_page()
    page.goto("https://example.com")

¿Qué es CapSolver?

CapSolver es un servicio de resolución automática de CAPTCHA impulsado por inteligencia artificial que soporta una amplia gama de tipos de CAPTCHA. Proporciona una API sencilla que te permite enviar desafíos de CAPTCHA y recibir soluciones en segundos.

Tipos de CAPTCHA soportados

  • Cloudflare Turnstile - El desafío anti-bot más común en la actualidad
  • reCAPTCHA v2 - Variantes basadas en imágenes e invisibles
  • reCAPTCHA v3 - Verificación basada en puntuación
  • AWS WAF - CAPTCHA de Amazon Web Services
  • Y muchos más...

Comenzar con CapSolver

  1. Regístrese en capsolver.com
  2. Agregue fondos a su cuenta
  3. Obtenga su clave de API desde el panel de control

Bonus: Use el código CAMOUFOX al registrarse para recibir créditos adicionales!

Desafíos previos a la integración

Antes de combinar Camoufox con CapSolver, la automatización web enfrentaba varios problemas:

Desafío Impacto
Detección de fingerprinting de navegador Los scripts se bloqueaban antes de llegar al contenido
Desafíos de CAPTCHA Se requería resolución manual, interrumpiendo la automatización
Sistemas de reputación de IP Los proxies se marcaban y prohibían rápidamente
Análisis de comportamiento Patrones no humanos detectados

La integración de Camoufox + CapSolver resuelve todos estos desafíos en un solo flujo de trabajo.

Métodos de integración

Método 1: Integración de API (Recomendado)

El enfoque de integración de API te da control total sobre el proceso de resolución de CAPTCHA y funciona con cualquier tipo de CAPTCHA.

Requisitos de configuración

bash Copy 
pip install camoufox[geoip] httpx

Patrón de integración principal

python Copy 
import asyncio
import httpx
from camoufox.async_api import AsyncCamoufox

CAPSOLVER_API_KEY = "SU_CLAVE_DE_API"
CAPSOLVER_API = "https://api.capsolver.com"


async def create_task(task_payload: dict) -> str:
    """Crear una tarea de resolución de CAPTCHA y devolver el ID de la tarea."""
    async with httpx.AsyncClient() as client:
        response = await client.post(
            f"{CAPSOLVER_API}/createTask",
            json={
                "clientKey": CAPSOLVER_API_KEY,
                "task": task_payload
            }
        )
        result = response.json()
        if result.get("errorId") != 0:
            raise Exception(f"Error de CapSolver: {result.get('errorDescription')}")
        return result["taskId"]


async def get_task_result(task_id: str, max_attempts: int = 120) -> dict:
    """Esperar el resultado de la tarea hasta que se resuelva o se agote el tiempo."""
    async with httpx.AsyncClient() as client:
        for _ in range(max_attempts):
            response = await client.post(
                f"{CAPSOLVER_API}/getTaskResult",
                json={
                    "clientKey": CAPSOLVER_API_KEY,
                    "taskId": task_id
                }
            )
            result = response.json()

            if result.get("status") == "ready":
                return result["solution"]
            elif result.get("status") == "failed":
                raise Exception(f"Tarea fallida: {result.get('errorDescription')}")

            await asyncio.sleep(1)

    raise TimeoutError("La resolución de CAPTCHA expiró")


async def solve_captcha(task_payload: dict) -> dict:
    """Completar el flujo de resolución de CAPTCHA."""
    task_id = await create_task(task_payload)
    return await get_task_result(task_id)

También puedes usar la extensión de CapSolver con Camoufox para un enfoque más pasivo.

Pasos de instalación

  1. Descargue la extensión de CapSolver desde capsolver.com/en/extension
  2. Extraiga los archivos de la extensión
  3. Cargue la extensión en Camoufox:
python Copy 
from camoufox.sync_api import Camoufox

with Camoufox(
    addons=["/ruta/a/la-extensión-capsolver"],
    headless=False  # Las extensiones requieren modo con interfaz
) as browser:
    page = browser.new_page()
    # La extensión detectará y resolverá automáticamente los CAPTCHAs

Ejemplos de código

Ejemplo 1: Resolver Cloudflare Turnstile

Cloudflare Turnstile es uno de los desafíos de CAPTCHA más comunes. Así es como lo resuelves:

python Copy 
import asyncio
from camoufox.async_api import AsyncCamoufox

CAPSOLVER_API_KEY = "SU_CLAVE_DE_API"
CAPSOLVER_API = "https://api.capsolver.com"


async def solve_turnstile(site_key: str, page_url: str) -> str:
    """Resolver Cloudflare Turnstile y devolver el token."""
    import httpx

    async with httpx.AsyncClient() as client:
        # Crear la tarea
        response = await client.post(
            f"{CAPSOLVER_API}/createTask",
            json={
                "clientKey": CAPSOLVER_API_KEY,
                "task": {
                    "type": "AntiTurnstileTaskProxyLess",
                    "websiteURL": page_url,
                    "websiteKey": site_key,
                }
            }
        )
        task_id = response.json()["taskId"]

        # Esperar el resultado
        while True:
            result = await client.post(
                f"{CAPSOLVER_API}/getTaskResult",
                json={
                    "clientKey": CAPSOLVER_API_KEY,
                    "taskId": task_id
                }
            )
            data = result.json()

            if data.get("status") == "ready":
                return data["solution"]["token"]

            await asyncio.sleep(1)


async def main():
    target_url = "https://example.com/página-protegida"
    turnstile_site_key = "0x4XXXXXXXXXXXXXXXXX"  # Encuentre esto en el código fuente de la página

    async with AsyncCamoufox(
        humanize=True,
        headless=False,
        os="windows"
    ) as browser:
        page = await browser.new_page()
        await page.goto(target_url)

        # Esperar a que se cargue Turnstile
        await page.wait_for_selector('input[name="cf-turnstile-response"]', timeout=10000)

        # Resolver el CAPTCHA
        token = await solve_turnstile(turnstile_site_key, target_url)
        print(f"Obtuve el token de Turnstile: {token[:50]}...")

        # Inyectar el token
        await page.evaluate(f'''
            document.querySelector('input[name="cf-turnstile-response"]').value = "{token}";

            // También establecer el callback oculto si está presente
            const callback = document.querySelector('[data-callback]');
            if (callback) {{
                const callbackName = callback.getAttribute('data-callback');
                if (window[callbackName]) {{
                    window[callbackName]('{token}');
                }}
            }}
        ''')

        # Enviar el formulario
        await page.click('button[type="submit"]')
        await page.wait_for_load_state("networkidle")

        print("¡Turnstile evadido con éxito!")


if __name__ == "__main__":
    asyncio.run(main())

Ejemplo 2: Resolver reCAPTCHA v2

python Copy 
import asyncio
from camoufox.async_api import AsyncCamoufox

CAPSOLVER_API_KEY = "SU_CLAVE_DE_API"
CAPSOLVER_API = "https://api.capsolver.com"


async def solve_recaptcha_v2(site_key: str, page_url: str) -> str:
    """Resolver reCAPTCHA v2 y devolver el token."""
    import httpx

    async with httpx.AsyncClient() as client:
        # Crear la tarea
        response = await client.post(
            f"{CAPSOLVER_API}/createTask",
            json={
                "clientKey": CAPSOLVER_API_KEY,
                "task": {
                    "type": "ReCaptchaV2TaskProxyLess",
                    "websiteURL": page_url,
                    "websiteKey": site_key,
                }
            }
        )
        result = response.json()

        if result.get("errorId") != 0:
            raise Exception(f"Error: {result.get('errorDescription')}")

        task_id = result["taskId"]

        # Esperar el resultado
        while True:
            result = await client.post(
                f"{CAPSOLVER_API}/getTaskResult",
                json={
                    "clientKey": CAPSOLVER_API_KEY,
                    "taskId": task_id
                }
            )
            data = result.json()

            if data.get("status") == "ready":
                return data["solution"]["gRecaptchaResponse"]
            elif data.get("status") == "failed":
                raise Exception(f"Falló: {data.get('errorDescription')}")

            await asyncio.sleep(2)


async def main():
    target_url = "https://example.com/iniciar-sesión"
    recaptcha_site_key = "6LcXXXXXXXXXXXXXXXXXXXXXXXXX"  # Encuentre en el código fuente de la página

    async with AsyncCamoufox(
        humanize=True,
        headless=False,
        os=["windows", "macos"]  # Selección aleatoria de sistema operativo
    ) as browser:
        page = await browser.new_page()
        await page.goto(target_url)

        # Rellenar campos del formulario con pausas humanas
        await page.fill('input[name="nombre_de_usuario"]', "[email protected]")
        await asyncio.sleep(0.5)  # Pausa similar a la humana
        await page.fill('input[name="contraseña"]', "contraseña123")

        # Resolver el CAPTCHA
        print("Resolviendo reCAPTCHA v2...")
        token = await solve_recaptcha_v2(recaptcha_site_key, target_url)
        print(f"Obtuve el token: {token[:50]}...")

        # Inyectar el token en el campo de respuesta de reCAPTCHA
        await page.evaluate(f'''
            document.getElementById('g-recaptcha-response').innerHTML = '{token}';
            document.getElementById('g-recaptcha-response').style.display = 'block';
        ''')

        # Enviar el formulario
        await page.click('button[type="submit"]')
        await page.wait_for_load_state("networkidle")

        print("¡Inicio de sesión exitoso!")


if __name__ == "__main__":
    asyncio.run(main())

Ejemplo 3: Resolver reCAPTCHA v3

reCAPTCHA v3 es basado en puntuación y no requiere interacción del usuario. Debe especificar el parámetro de acción.

python Copy 
import asyncio
from camoufox.async_api import AsyncCamoufox

CAPSOLVER_API_KEY = "SU_CLAVE_DE_API"
CAPSOLVER_API = "https://api.capsolver.com"


async def solve_recaptcha_v3(
    site_key: str,
    page_url: str,
    action: str = "verify",
    min_score: float = 0.7
) -> str:
    """Resolver reCAPTCHA v3 con acción y puntuación mínima especificados."""
    import httpx

    async with httpx.AsyncClient() as client:
        response = await client.post(
            f"{CAPSOLVER_API}/createTask",
            json={
                "clientKey": CAPSOLVER_API_KEY,
                "task": {
                    "type": "ReCaptchaV3TaskProxyLess",
                    "websiteURL": page_url,
                    "websiteKey": site_key,
                    "pageAction": action,
                    "minScore": min_score
                }
            }
        )
        result = response.json()

        if result.get("errorId") != 0:
            raise Exception(f"Error: {result.get('errorDescription')}")

        task_id = result["taskId"]

        while True:
            result = await client.post(
                f"{CAPSOLVER_API}/getTaskResult",
                json={
                    "clientKey": CAPSOLVER_API_KEY,
                    "taskId": task_id
                }
            )
            data = result.json()

            if data.get("status") == "ready":
                return data["solution"]["gRecaptchaResponse"]
            elif data.get("status") == "failed":
                raise Exception(f"Falló: {data.get('errorDescription')}")

            await asyncio.sleep(1)


async def main():
    target_url = "https://example.com/buscar"
    recaptcha_v3_key = "6LcXXXXXXXXXXXXXXXXXXXXXXXXX"

    async with AsyncCamoufox(
        humanize=2.0,  # Máximo 2 segundos de movimientos humanizados
        headless=True,  # Puede ejecutarse en modo sin interfaz para v3
        geoip=True,  # Detectar geolocalización automáticamente desde el proxy
    ) as browser:
        page = await browser.new_page()
        await page.goto(target_url)

        # Resolver reCAPTCHA v3 con acción "buscar"
        print("Resolviendo reCAPTCHA v3...")
        token = await solve_recaptcha_v3(
            recaptcha_v3_key,
            target_url,
            action="buscar",
            min_score=0.9  # Solicitar una alta puntuación
        )

        # Ejecutar la devolución de llamada con el token
        await page.evaluate(f'''
            // Enviar token a través de la devolución de llamada del sitio

grecaptcha.execute('{recaptcha_v3_key}', {action: 'search'})
.then(function(tokenOriginal) {
// Reemplazar con nuestro token resuelto
submitSearch('{token}');
});
''')

Copy 
    print("¡reCAPTCHA v3 evadido!")

if name == "main":
asyncio.run(main())

Copy 
---

## Mejores prácticas

### 1. Rotación de proxies con GeoIP

Utiliza la función GeoIP de Camoufox para que las huellas dactilares coincidan automáticamente con la ubicación de tu proxy:

```python
async with AsyncCamoufox(
    geoip=True,  # Detectar automáticamente desde la IP del proxy
    proxy={
        "server": "http://proxy.example.com:8080",
        "username": "user",
        "password": "pass"
    }
) as browser:
    # La huella dactilar coincidirá con la ubicación geográfica del proxy
    pass

2. Consistencia de las huellas dactilares

Mantén las huellas dactilares consistentes dentro de una sesión pero rotalas entre sesiones:

python Copy 
from browserforge.fingerprints import Screen

# Limitar a tamaños de pantalla comunes
screen = Screen(
    min_width=1280,
    max_width=1920,
    min_height=720,
    max_height=1080
)

async with AsyncCamoufox(
    os="windows",
    screen=screen,
) as browser:
    pass

3. Límites de velocidad

Evita activar límites de velocidad añadiendo retrasos:

python Copy 
import random

async def retrasoHumano():
    """Retraso aleatorio para imitar el comportamiento humano."""
    await asyncio.sleep(random.uniform(1.0, 3.0))

# Usar entre acciones
await page.click('button')
await retrasoHumano()
await page.fill('input', 'texto')

4. Manejo de errores

Siempre implementa un manejo adecuado de errores para la resolución de CAPTCHA:

python Copy 
async def resolverConReintento(payloadTarea: dict, maxReintentos: int = 3) -> dict:
    """Resolver CAPTCHA con lógica de reintento."""
    for intento in range(maxReintentos):
        try:
            return await resolverCAPTCHA(payloadTarea)
        except TimeoutError:
            if intento < maxReintentos - 1:
                print(f"Tiempo de espera agotado, reintentando... ({intento + 1}/{maxReintentos})")
                await asyncio.sleep(5)
            else:
                raise
        except Exception as e:
            if "saldo" in str(e).lower():
                raise  # No reintentar errores de saldo
            if intento < maxReintentos - 1:
                await asyncio.sleep(2)
            else:
                raise

Bonus: ¡Empieza hoy mismo!

¿Listo para potenciar tu automatización web con Camoufox y CapSolver?

Usa el código CAMOUFOX al registrarte en CapSolver para recibir créditos adicionales!

Este bono exclusivo te ayudará a comenzar con la resolución de CAPTCHA de inmediato.

Conclusión

La integración de Camoufox y CapSolver crea una herramienta poderosa para la automatización web:

  • Camoufox maneja la detección de bots con suplantación de huellas dactilares a nivel nativo
  • CapSolver maneja CAPTCHAs con resolución impulsada por inteligencia artificial
  • Juntos permiten automatización fluida que parece completamente humana

Ya sea que estés construyendo scrapers web, sistemas de pruebas automatizadas o pipelines de recolección de datos, esta combinación ofrece la fiabilidad y el sigilo que necesitas.

Preguntas frecuentes

P: ¿Qué tipos de CAPTCHA funcionan mejor con esta integración?

R: CapSolver admite todos los tipos principales de CAPTCHA. Cloudflare Turnstile y reCAPTCHA v2/v3 tienen las tasas de éxito más altas. La integración funciona sin problemas con cualquier CAPTCHA que CapSolver admita.

P: ¿Puedo usar esto en modo headless?

R: ¡Sí! Camoufox admite el modo headless y mantiene sus capacidades de suplantación de huellas dactilares. Para reCAPTCHA v3 y CAPTCHAs basados en tokens, el modo headless funciona perfectamente. Para CAPTCHAs visibles de v2, el modo con interfaz gráfica puede dar mejores resultados.

P: ¿Cómo encuentro la clave del sitio para un CAPTCHA?

R: Búscalo en el código fuente de la página para:

  • Turnstile: atributo data-sitekey o elementos cf-turnstile
  • reCAPTCHA: atributo data-sitekey en el div g-recaptcha

P: ¿Qué hago si la resolución de CAPTCHA falla?

R: Soluciones comunes:

  1. Verifica tu clave de API y tu saldo
  2. Asegúrate de que la clave del sitio sea correcta
  3. Comprueba que la URL de la página coincida con donde aparece el CAPTCHA
  4. Para v3, prueba ajustar el parámetro de acción y el puntaje mínimo
  5. Implementa lógica de reintento con retrasos

P: ¿Camoufox funciona con Selenium?

R: Camoufox está basado en Playwright, no en Selenium. Sin embargo, puedes usar el mismo patrón de integración con cualquier framework de automatización de navegadores.

Aviso de Cumplimiento: La información proporcionada en este blog es solo para fines informativos. CapSolver se compromete a cumplir con todas las leyes y regulaciones aplicables. El uso de la red de CapSolver para actividades ilegales, fraudulentas o abusivas está estrictamente prohibido y será investigado. Nuestras soluciones para la resolución de captcha mejoran la experiencia del usuario mientras garantizan un 100% de cumplimiento al ayudar a resolver las dificultades de captcha durante el rastreo de datos públicos. Fomentamos el uso responsable de nuestros servicios. Para obtener más información, visite nuestros Términos de Servicio y Política de Privacidad.

Máse

Flujo de trabajo de resolución de CAPTCHA de Camoufox y CapSolver
Cómo integrar Camoufox con CapSolver para la resolución de CAPTCHA sin interrupciones

Aprende cómo integrar Camoufox con CapSolver para evitar de manera confiable a gran escala Cloudflare Turnstile y reCAPTCHA.

web scraping
Logo of CapSolver

Aloísio Vítor

16-Dec-2025

.Cómo resolver CAPTCHAs en Python usando Botasaurus y CapSolver (Guía completa)
Cómo resolver CAPTCHAs en Python usando Botasaurus y CapSolver (Guía completa)

Aprende a integrar Botasaurus (marco de scraping web en Python) con la API de CapSolver para resolver automáticamente reCAPTCHA v2/v3 y Turnstile.

web scraping
Logo of CapSolver

Aloísio Vítor

15-Dec-2025

errores de raspado de web
¿Qué son los errores 402, 403, 404 y 429 en el web scraping? Una guía completa

Domine el manejo de errores de scraping web comprendiendo qué son los errores 402, 403, 404 y 429. Aprenda a corregir el error 403 Prohibido, implemente soluciones para el error 429 de limitación de tasas y maneje el código de estado 402 Requerido de pago.

web scraping
Logo of CapSolver

Adélia Cruz

12-Dec-2025

Raspado de web con Python
Web Scraping Con Python: 2026 Mejores Estrategias

Aprende las tácticas top de scraping web en Python para 2026, incluyendo el manejo de contenido dinámico de JavaScript, la gestión de flujos de autenticación, resolver CAPTCHAs, identificar trampas ocultas, simular comportamiento humano, optimizar patrones de solicitud y reducir el uso de recursos en proyectos de scraping a gran escala.

web scraping
Logo of CapSolver

Adélia Cruz

12-Dec-2025

Cómo resolver CAPTCHAs durante el scraping web con Scrapling y CapSolver
Cómo resolver captchas al realizar scraping web con Scrapling y CapSolver

Scrapling + CapSolver permite el scraping automatizado con ReCaptcha v2/v3 y bypass de Cloudflare Turnstile.

web scraping
Logo of CapSolver

Ethan Collins

05-Dec-2025

Scraping de web con Selenium y Python
Raspado de web con Selenium y Python | Resolver Captcha al realizar el raspado de web

En este artículo te familiarizarás con el web scraping usando Selenium y Python, y aprenderás a resolver el Captcha involucrado en el proceso para una extracción de datos eficiente.

web scraping
Logo of CapSolver

Rajinder Singh

04-Dec-2025