Cómo resolver captcha en EasySpider con la integración de CapSolver

EasySpider es una herramienta poderosa de scraping web visual que permite a cualquier persona diseñar y ejecutar tareas de automatización del navegador sin escribir código. Su interfaz basada en diagramas de flujo intuitivos la hace accesible para no programadores, mientras que aún ofrece capacidades avanzadas para desarrolladores.

CapSolver completa la experiencia de automatización de EasySpider proporcionando una resolución de CAPTCHA sin interrupciones. Aunque EasySpider admite varios esquemas de reconocimiento de CAPTCHA, integrar las soluciones impulsadas por IA de CapSolver garantiza una resolución confiable y rápida de reCAPTCHA, Cloudflare Turnstile y otros desafíos de CAPTCHA.

¿Qué es EasySpider?

EasySpider es una herramienta de rastreador web y automatización del navegador gratuita y de código abierto. A diferencia de las bibliotecas de scraping tradicionales que requieren conocimientos de programación, EasySpider le permite diseñar tareas visualmente señalando y haciendo clic en elementos web.

Filosofía Principal

EasySpider opera bajo tres principios fundamentales:

1. Diseño Primero Visual: Cree flujos de trabajo de automatización complejos a través de una interfaz de diagrama de flujo intuitiva
2. Accesibilidad Sin Código: Diseñe tareas tan fácilmente como usar Excel, sin importar su experiencia en programación
3. Total Extensibilidad: Ejecute código JavaScript, Python y declaraciones de Selenium cuando sea necesario

Características Principales de EasySpider

• Diseñador de Tareas Visual: Interfaz de señal y clic para crear flujos de trabajo de automatización
• Multiplataforma: Disponible para Windows, macOS y Linux
• Modo Sin Cabina: Ejecute tareas sin una ventana de navegador visible
• Ejecución de Código Personalizado: Ejecute código JavaScript y Python dentro de los flujos de trabajo
• Integración con Selenium: Manipulación directa del navegador usando declaraciones de Selenium
• Invocación de API: Llame a sistemas y servicios externos
• Ejecución desde la Línea de Comandos: Ejecute tareas de forma programática a través de CLI
• Tareas Programadas: Automatice la recolección recurrente de datos

Características del Flujo de Trabajo

¿Qué es CapSolver?

CapSolver es un servicio líder de resolución de CAPTCHA que proporciona soluciones impulsadas por IA para superar diversos desafíos de CAPTCHA. Con soporte para múltiples tipos de CAPTCHA y tiempos de respuesta rápidos, CapSolver se integra sin problemas en flujos de automatización.

Tipos de CAPTCHA Soportados

• reCAPTCHA v2 (basado en imágenes e invisible)
• reCAPTCHA v3 & v3 Enterprise
• Cloudflare Turnstile
• Cloudflare 5-second Challenge
• AWS WAF CAPTCHA
• Otros mecanismos de anti-bot y CAPTCHA ampliamente utilizados

¿Por Qué Integrar CapSolver con EasySpider?

Aunque EasySpider ofrece soporte integrado para CAPTCHA, integrar CapSolver ofrece ventajas significativas:

1. Mayor Tasa de Éxito: Las soluciones impulsadas por IA de CapSolver logran tasas de éxito consistentemente altas
2. Resolución Más Rápida: Infraestructura optimizada que entrega tokens rápidamente
3. Mayor Cobertura: Soporte para todos los tipos principales de CAPTCHA
4. Confiabilidad: Servicio de grado empresarial con excelente tiempo de actividad
5. Escalabilidad: Maneje automatización de alto volumen sin cuellos de botella

Instalación

Instalando EasySpider

1. Descargue la última versión desde GitHub Releases
2. Elija la versión adecuada para su plataforma:
   • EasySpider_windows_x64.zip para Windows de 64 bits
   • EasySpider_windows_x86.zip para Windows de 32 bits
   • EasySpider_MacOS.dmg para macOS
   • EasySpider_Linux_x64.tar.gz para Linux
3. Extraiga la carpeta y ejecute EasySpider.exe (Windows) o el ejecutable correspondiente

Nota: Asegúrese de que el puerto 8084 esté disponible para la comunicación entre procesos.

Dependencias de Python para Integración Personalizada

Si planea usar el script de ayuda de CapSolver:

pip install requests

Creando una Utilidad de CapSolver para EasySpider

Aquí hay una clase de utilidad de CapSolver reutilizable diseñada para flujos de trabajo de Python:

Servicio Básico de CapSolver

import requests
import time
from typing import Optional
from dataclasses import dataclass

CAPSOLVER_API_KEY = 'SU_API_KEY_DE_CAPSOLVER'

@dataclass
class ResultadoTarea:
    estado: str
    solución: Optional[dict] = None
    descripción_error: Optional[str] = None


class ServicioCapSolver:
    def __init__(self, api_key: str = CAPSOLVER_API_KEY):
        self.api_key = api_key
        self.url_base = 'https://api.capsolver.com'

    def crear_tarea(self, datos_tarea: dict) -> str:
        response = requests.post(
            f'{self.url_base}/crearTarea',
            json={
                'clientKey': self.api_key,
                'tarea': datos_tarea
            }
        )
        datos = response.json()

        if datos.get('errorId', 0) != 0:
            raise Exception(f"Error de CapSolver: {datos.get('errorDescription')}")

        return datos['idTarea']

    def obtener_resultado_tarea(self, id_tarea: str, intentos_maximos: int = 60) -> ResultadoTarea:
        for _ in range(intentos_maximos):
            time.sleep(2)

            response = requests.post(
                f'{self.url_base}/obtenerResultadoTarea',
                json={
                    'clientKey': self.api_key,
                    'taskId': id_tarea
                }
            )
            datos = response.json()

            if datos.get('estado') == 'listo':
                return ResultadoTarea(
                    estado='listo',
                    solución=datos.get('solución')
                )

            if datos.get('estado') == 'fallido':
                raise Exception(f"Tarea fallida: {datos.get('errorDescription')}")

        raise Exception('Tiempo de espera agotado para la solución de CAPTCHA')

    def resolver_recaptcha_v2(self, url_pagina: str, clave_pagina: str) -> str:
        id_tarea = self.crear_tarea({
            'tipo': 'ReCaptchaV2TaskProxyLess',
            'websiteURL': url_pagina,
            'websiteKey': clave_pagina
        })

        resultado = self.obtener_resultado_tarea(id_tarea)
        return resultado.solución.get('gRecaptchaResponse', '') if resultado.solución else ''

    def resolver_turnstile(
        self,
        url_pagina: str,
        clave_pagina: str,
        acción: Optional[str] = None,
        cdata: Optional[str] = None
    ) -> str:
        datos_tarea = {
            'tipo': 'AntiTurnstileTaskProxyLess',
            'websiteURL': url_pagina,
            'websiteKey': clave_pagina
        }

        if acción or cdata:
            metadatos = {}
            if acción:
                metadatos['acción'] = acción
            if cdata:
                metadatos['cdata'] = cdata
            datos_tarea['metadatos'] = metadatos

        id_tarea = self.crear_tarea(datos_tarea)
        resultado = self.obtener_resultado_tarea(id_tarea)
        return resultado.solución.get('token', '') if resultado.solución else ''


# Instancia global
capsolver = ServicioCapSolver()

Métodos de Integración

EasySpider ofrece varios métodos para integrar CapSolver. Elija el que mejor se adapte a su caso de uso.

Método 1: Acción Personalizada con Inyección de JavaScript

EasySpider admite la ejecución de JavaScript personalizado dentro de su flujo de trabajo. Este es el método de integración más directo.

Paso 1: Cree una nueva tarea en EasySpider y navegue a la página protegida por CAPTCHA

Paso 2: Agregue un nodo de "Acción Personalizada" con el siguiente JavaScript:

// Extraiga la clave del sitio del elemento reCAPTCHA
var claveSitio = document.querySelector('.g-recaptcha').getAttribute('data-sitekey');
var urlPagina = window.location.href;

// Almacene para usar en el siguiente paso
window.captchaClaveSitio = claveSitio;
window.captchaUrlPagina = urlPagina;

// Registro para depuración
console.log('Clave del Sitio:', claveSitio);
console.log('URL de la Página:', urlPagina);

Paso 3: Use la función de llamada al sistema externo de EasySpider para invocar un script de Python que resuelva el CAPTCHA y devuelva el token

Paso 4: Agregue otra "Acción Personalizada" para inyectar el token:

// El token será pasado desde el script externo
var token = arguments[0];  // Pasado desde EasySpider

// Haga visible el área de texto de respuesta y establezca el token
document.getElementById('g-recaptcha-response').style.display = 'block';
document.getElementById('g-recaptcha-response').value = token;

// Si hay una función de devolución de llamada, ejecútela
if (typeof ___grecaptcha_cfg !== 'undefined') {
    var clientes = ___grecaptcha_cfg.clientes;
    if (clientes) {
        Object.keys(clientes).forEach(function(clave) {
            var cliente = clientes[clave];
            if (cliente.callback) {
                cliente.callback(token);
            }
        });
    }
}

Método 1B: Turnstile (Sin Proxy) con EasySpider

Este es un flujo de trabajo de Turnstile sin proxy usando los nodos visuales de EasySpider. No requiere un proxy.

Paso 1: Cree una nueva tarea y navegue a su página protegida por Turnstile.

Paso 2: Agregue tres nodos de Acción Personalizada (modo de código = JavaScript) para capturar los metadatos de Turnstile:

// Título del nodo: TS_ClaveSitio
return document.querySelector('.cf-turnstile')?.getAttribute('data-sitekey') || '';

// Título del nodo: TS_Acción (opcional)
return document.querySelector('.cf-turnstile')?.getAttribute('data-action') || '';

// Título del nodo: TS_Cdata (opcional)
return document.querySelector('.cf-turnstile')?.getAttribute('data-cdata') || '';

Paso 3: Agregue un nodo de Ejecutar Comando del Sistema para resolver Turnstile con CapSolver:

python captcha_solver.py "{{current_url}}" "Campo[\"TS_ClaveSitio\"]" "turnstile" "Campo[\"TS_Acción\"]" "Campo[\"TS_Cdata\"]"

Nombre este nodo Token para que pueda referenciar su salida como Campo["Token"].

Paso 4: Agregue un nodo de Acción Personalizada (JavaScript) para inyectar el token:

var token = `Campo["Token"]`;
var inputs = document.querySelectorAll('input[name="cf-turnstile-response"], input[name="turnstile-response"]');
inputs.forEach(function(el) {
    el.value = token;
    el.dispatchEvent(new Event('input', { bubbles: true }));
    el.dispatchEvent(new Event('change', { bubbles: true }));
});

Paso 5: Haga clic en el botón de envío del formulario (o use un JS de envío).

Nota: El Turnstile sin proxy funciona en muchos sitios, pero algunos despliegues validan los tokens contra la IP del solucionador. Si eso ocurre, se requiere resolución con proxy.

Método 3: Modificando easyspider_executestage

Para usuarios avanzados, puede extender directamente el motor de ejecución de Python de EasySpider. El script easyspider_executestage.py maneja la ejecución de tareas y puede modificarse para incluir la integración de CapSolver.

Ubicación: {Directorio_EasySpider}/Code/easyspider_executestage.py

Agregue el servicio CapSolver al contexto de ejecución:

# Agregue a las importaciones en la parte superior de easyspider_executestage.py
import requests
import time

# Agregue la clase CapSolver
class ServicioCapSolver:
    # ... (implementación de arriba)
    pass

# Cree una instancia global
capsolver = ServicioCapSolver('SU_API_KEY_DE_CAPSOLVER')

# Ahora capsolver.resolver_recaptcha_v2() está disponible en bloques eval/exec

Luego, en su tarea de EasySpider, use la función "Ejecutar Código de Python":

# En el bloque de ejecución de Python de EasySpider
clave_sitio = driver.find_element_by_class_name('g-recaptcha').get_attribute('data-sitekey')
token = capsolver.resolver_recaptcha_v2(url_actual, clave_sitio)
driver.execute_script(f'''
    document.getElementById('g-recaptcha-response').value = `{token}`;
''')

Mejores Prácticas

1. Manejo de Errores con Reintentos

import time
from functools import wraps
from typing import Callable, TypeVar, Any

T = TypeVar('T')

def reintentar(max_reintentos: int = 3, retroceso_exponencial: bool = True):
    """Decorador para lógica de reintentos con retroceso exponencial."""
    def decorador(func: Callable[..., T]) -> Callable[..., T]:
        @wraps(func)
        def envoltura(*args: Any, **kwargs: Any) -> T:
            último_error = None

            for intento in range(max_reintentos):
                try:
                    return func(*args, **kwargs)
                except Exception as e:
                    último_error = e

                    if intento < max_reintentos - 1:
                        retardo = (2 ** intento) if retroceso_exponencial else 1
                        print(f'Intento {intento + 1} falló, reintentando en {retardo}s...')
                        time.sleep(retardo)

            raise último_error

        return envoltura
    return decorador


@reintentar(max_reintentos=3, retroceso_exponencial=True)
def resolver_con_reintentos(capsolver, url: str, clave_sitio: str) -> str:
    return capsolver.resolver_recaptcha_v2(url, clave_sitio)

2. Gestión de Saldo

def verificar_saldo(clave_api: str) -> float:
    response = requests.post(
        'https://api.capsolver.com/getBalance',
        json={'clientKey': clave_api}
    )
    datos = response.json()
    return datos.get('balance', 0)


def main():
    saldo = verificar_saldo(CLAVE_API_CAPSOLVER)

    if saldo < 1:
        print('Advertencia: Saldo bajo de CapSolver! Por favor, recargue.')
    else:
        print(f'Saldo actual: ${saldo:.2f}')

3. Ejecución desde la Línea de Comandos de EasySpider

Ejecute tareas de EasySpider desde la línea de comandos:

# Ejecución básica
python easyspider_executestage.py --id [id_tarea] --read_type local --headless 1

# Con parámetros completos
python easyspider_executestage.py \
    --ids [0] \
    --server_address http://localhost:8074 \
    --config_folder "./" \
    --headless 1 \
    --read_type local

Flujo de Trabajo Completo: Tarea de EasySpider con CapSolver

Así es como se crea un flujo de trabajo completo de EasySpider que incluye la integración con CapSolver:

Paso 1: Diseñe su Tarea en EasySpider

1. Inicie EasySpider y haga clic en "Diseñar Tarea"
2. Ingrese la URL objetivo (por ejemplo, https://www.google.com/recaptcha/api2/demo)
3. Agregue nodos de flujo de trabajo:
   • Abrir Página: Navegue a la URL
   • Acción Personalizada: Ejecute JavaScript para detectar CAPTCHA
   • Llamada al Sistema: Invoca un script de Python con CapSolver
   • Acción Personalizada: Inyecte el token
   • Hacer Clic en Elemento: Envíe el formulario
   • Recopilar Datos: Extraiga los resultados
     Guardarlo como captcha_solver.py en su directorio EasySpider:

#!/usr/bin/env python3
"""
Script de ayuda de CapSolver para EasySpider
Uso: python captcha_solver.py <url> <site_key> <captcha_type> [action] [cdata]
"""

import sys
import requests
import time

CAPSOLVER_API_KEY = 'SU_CLAVE_API_DE_CAPSOLVER'

def solve_captcha(url, site_key, captcha_type='recaptcha_v2', action=None, cdata=None):
    """Resolver CAPTCHA y devolver token."""

    if captcha_type == 'recaptcha_v2':
        task_type = 'ReCaptchaV2TaskProxyLess'
    elif captcha_type == 'turnstile':
        task_type = 'AntiTurnstileTaskProxyLess'
    else:
        raise ValueError(f'Tipo de CAPTCHA desconocido: {captcha_type}')

    # Crear tarea
    task = {
        'type': task_type,
        'websiteURL': url,
        'websiteKey': site_key
    }
    if captcha_type == 'turnstile' and (action or cdata):
        metadata = {}
        if action:
            metadata['action'] = action
        if cdata:
            metadata['cdata'] = cdata
        task['metadata'] = metadata

    response = requests.post(
        'https://api.capsolver.com/createTask',
        json={
            'clientKey': CAPSOLVER_API_KEY,
            'task': task
        }
    )
    data = response.json()

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

    task_id = data['taskId']

    # Consultar resultados
    for _ in range(60):
        time.sleep(2)

        response = requests.post(
            'https://api.capsolver.com/getTaskResult',
            json={
                'clientKey': CAPSOLVER_API_KEY,
                'taskId': task_id
            }
        )
        data = response.json()

        if data.get('status') == 'ready':
            solution = data.get('solution', {})
            return solution.get('gRecaptchaResponse') or solution.get('token')

        if data.get('status') == 'failed':
            raise Exception(f"Falló: {data.get('errorDescription')}")

    raise Exception('Tiempo de espera agotado')


if __name__ == '__main__':
    if len(sys.argv) < 3:
        print('Uso: python captcha_solver.py <url> <site_key> [captcha_type] [action] [cdata]')
        sys.exit(1)

    url = sys.argv[1]
    site_key = sys.argv[2]
    captcha_type = sys.argv[3] if len(sys.argv) > 3 else 'recaptcha_v2'
    action = sys.argv[4] if len(sys.argv) > 4 else None
    cdata = sys.argv[5] if len(sys.argv) > 5 else None

    try:
        token = solve_captcha(url, site_key, captcha_type, action, cdata)
        print(token)  # Salida del token para que EasySpider lo capture
    except Exception as e:
        print(f'ERROR: {e}', file=sys.stderr)
        sys.exit(1)

Paso 3: Configurar EasySpider para usar el script

En su flujo de trabajo de EasySpider, agregue un nodo "Ejecutar comando del sistema":

python captcha_solver.py "{{current_url}}" "{{site_key}}" "recaptcha_v2"

Para Turnstile (sin proxy):

python captcha_solver.py "{{current_url}}" "{{site_key}}" "turnstile" "{{action}}" "{{cdata}}"

La salida (token) se puede capturar y usar en pasos posteriores de inyección de JavaScript.

Conclusión

La integración de CapSolver con EasySpider crea una combinación poderosa para la automatización web visual. La interfaz de flujo de trabajo intuitiva de EasySpider hace que el diseño de tareas sea accesible para todos, mientras que CapSolver maneja los desafíos de CAPTCHA que de otro modo bloquearían su automatización.

Ventajas clave de esta integración:

• Visual + Potente: Diseñe tareas visualmente mientras maneja CAPTCHAS complejos
• Múltiples métodos de integración: Inyección de JavaScript, scripts de Python o modificación directa
• Todos los tipos de CAPTCHA: reCAPTCHA v2, v3, Cloudflare Turnstile, desafíos y más
• Listo para producción: Manejo de errores, reintentos y gestión de saldo incluidos
• Multiplataforma: Funciona en Windows, macOS y Linux

Ya sea que esté construyendo pipelines de extracción de datos, sistemas de monitoreo o marcos de prueba automatizada, la combinación EasySpider + CapSolver proporciona la experiencia de diseño visual y la capacidad de resolver CAPTCHAS necesarias para la automatización web moderna.

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

Preguntas frecuentes

¿Qué es EasySpider?

EasySpider es una herramienta gratuita y de código abierto para scraping web y automatización del navegador. Permite a los usuarios diseñar tareas de automatización a través de una interfaz de diagrama de flujo gráfica sin escribir código, mientras también admite código JavaScript, Python y declaraciones de Selenium para casos avanzados.

¿Cómo se integra CapSolver con EasySpider?

CapSolver se integra con EasySpider mediante varios métodos: inyección de JavaScript dentro del flujo de trabajo de EasySpider, scripts de Python externos llamados a través de comandos del sistema, o modificación directa del motor de ejecución de Python de EasySpider. Todos los métodos utilizan la API de CapSolver para resolver CAPTCHAS e inyectar tokens en la página.

¿EasySpider resuelve CAPTCHAS por sí mismo?

EasySpider tiene soporte integrado para algunos esquemas de reconocimiento de CAPTCHA y capacidades de OCR. Sin embargo, integrarse con CapSolver proporciona tasas de éxito más altas, tiempos de resolución más rápidos y mayor cobertura de tipos de CAPTCHA para flujos de trabajo de automatización de producción.

¿Qué tipos de CAPTCHAS puede resolver CapSolver?

CapSolver admite una amplia gama de tipos de CAPTCHA, incluyendo reCAPTCHA v2, reCAPTCHA v3, Cloudflare Turnstile, AWS WAF, GeeTest v3/v4 y muchos más.

¿Cuánto cuesta CapSolver?

CapSolver ofrece precios competitivos basados en el tipo y volumen de CAPTCHAS resueltos. Visite capsolver.com para obtener detalles de precios actuales. Use el código EASYSPIDER para obtener un 5% de bonificación en su primer recarga.

¿Es gratuito EasySpider?

Sí, EasySpider es completamente gratuito y de código abierto bajo la licencia AGPL-3.0. El software permite el uso comercial gratuito y la modificación. Las implementaciones de servicios de red deben proporcionar acceso al código fuente a los usuarios.

¿Cómo encuentro la clave de sitio de CAPTCHA?

La clave de sitio generalmente se encuentra en la fuente HTML de la página:

• reCAPTCHA: atributo data-sitekey en el elemento .g-recaptcha
• Turnstile: atributo data-sitekey en el elemento .cf-turnstile

¿Puedo ejecutar tareas de EasySpider desde la línea de comandos?

Sí, EasySpider admite la ejecución desde la línea de comandos a través de easyspider_executestage.py. Esto permite la integración con otros sistemas, la ejecución de tareas programadas y la automatización en modo sin cabeza.

¿Qué plataformas admite EasySpider?

EasySpider está disponible para Windows (x64/x86), macOS y Linux. Descargue la versión correspondiente desde la página de lanzamientos de GitHub.

¿Puedo usar EasySpider con proxies?

Sí, EasySpider admite la configuración de IP de proxy y el cambio de túneles. Puede configurar proxies en la configuración de la tarea o a través de las opciones de inicio del navegador de EasySpider.