Cómo resolver un Captcha en Crawlee con la integración de CapSolver

Cómo resolver Captcha en Crawlee con la integración de CapSolver

Adélia Cruz

Neural Network Developer

24-Dec-2025

TL;DR: Los raspadores de Crawlee suelen encontrar barreras de CAPTCHA. Integrar CapSolver te permite resolver reCAPTCHA, Turnstile y más, para que los flujos de raspado permanezcan estables y automatizados.

Al construir raspadores con Crawlee, encontrar CAPTCHA es casi inevitable, especialmente en sitios modernos con protección contra bots agresiva. Incluso los raspadores configurados correctamente con Playwright o HTTP pueden ser bloqueados una vez que aparezcan desafíos como reCAPTCHA, Turnstile o similares.

Este guía se centra en un enfoque práctico: usar CapSolver para manejar desafíos de CAPTCHA directamente dentro de los flujos de trabajo de Crawlee. En lugar de luchar continuamente contra huellas digitales de navegadores, verás cómo detectar los tipos comunes de CAPTCHA, resolverlos programáticamente y mantener tus raspadores funcionando de forma confiable en escenarios reales de raspado.

¿Qué es Crawlee?

Crawlee es una biblioteca de raspado web y automatización de navegadores para Node.js diseñada para construir raspadores confiables que parezcan humanos y pasen desapercibidos ante las protecciones contra bots modernas. Construida con TypeScript, ofrece tanto simplicidad de alto nivel como personalización de bajo nivel.

Características clave de Crawlee

Interfaz Unificada: API única para el raspado HTTP y de navegador sin cabeza
Disfraz contra bots: Generación automática de huellas digitales del navegador, replicación de huellas digitales TLS y comportamiento humano
Gestión inteligente de colas: Cola de URL persistente con opciones de raspado en anchura y profundidad
Escalabilidad automática: Escalado automático de recursos según la carga del sistema
Rotación de proxies: Rotación de proxies y gestión de sesiones integradas
Soporte múltiple de navegadores: Funciona con Playwright y Puppeteer en Chrome, Firefox y WebKit

Tipos de raspadores

Crawlee ofrece varios tipos de raspadores para diferentes casos de uso:

Tipo de raspador	Descripción
CheerioCrawler	Raspador HTTP ultrarrápido que usa Cheerio para analizar HTML
PlaywrightCrawler	Automatización completa del navegador con Playwright para sitios con JavaScript
PuppeteerCrawler	Automatización completa del navegador con Puppeteer para renderizado de JavaScript
JSDOMCrawler	Raspador HTTP con JSDOM para ejecutar JavaScript sin navegador

¿Qué es CapSolver?

CapSolver es un servicio líder para resolver CAPTCHA que proporciona soluciones basadas en inteligencia artificial para evitar 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 automatizados.

Tipos de CAPTCHA soportados

reCAPTCHA v2 (Imagen & Invisible)
reCAPTCHA v3
Cloudflare Turnstile
AWS WAF
Y muchos más...

¿Por qué integrar CapSolver con Crawlee?

Al construir raspadores de Crawlee que interactúan con sitios protegidos, los desafíos de CAPTCHA pueden detener todo tu pipeline de raspado. Aquí está el por qué la integración es importante:

Raspado sin interrupciones: Los raspadores continúan extrayendo datos sin intervención manual
Operaciones escalables: Manejar múltiples desafíos de CAPTCHA en sesiones de raspado concurrentes
Costo efectivo: Pagar solo por CAPTCHAS resueltos con éxito
Altas tasas de éxito: Alta precisión líder en la industria para todos los tipos de CAPTCHA soportados

Instalación

Primero, instala los paquetes requeridos:

bash Copy

npm install crawlee playwright axios

O con yarn:

bash Copy

yarn add crawlee playwright axios

Creando un servicio de CapSolver para Crawlee

Aquí tienes una clase de servicio de CapSolver reutilizable que se puede usar en tus proyectos de Crawlee:

Servicio básico de CapSolver

typescript Copy

import axios from 'axios';

const CAPSOLVER_API_KEY = 'TU_CLAVE_API_DE_CAPSOLVER';

interface TaskResult {
    status: string;
    solution?: {
        gRecaptchaResponse?: string;
        token?: string;
    };
    errorDescription?: string;
}

class CapSolverService {
    private apiKey: string;
    private baseUrl = 'https://api.capsolver.com';

    constructor(apiKey: string = CAPSOLVER_API_KEY) {
        this.apiKey = apiKey;
    }

    async createTask(taskData: object): Promise<string> {
        const response = await axios.post(`${this.baseUrl}/createTask`, {
            clientKey: this.apiKey,
            task: taskData
        });

        if (response.data.errorId !== 0) {
            throw new Error(`Error de CapSolver: ${response.data.errorDescription}`);
        }

        return response.data.taskId;
    }

    async getTaskResult(taskId: string, maxAttempts = 60): Promise<TaskResult> {
        for (let i = 0; i < maxAttempts; i++) {
            await this.sleep(2000);

            const response = await axios.post(`${this.baseUrl}/getTaskResult`, {
                clientKey: this.apiKey,
                taskId
            });

            if (response.data.status === 'ready') {
                return response.data;
            }

            if (response.data.status === 'failed') {
                throw new Error(`Tarea fallida: ${response.data.errorDescription}`);
            }
        }

        throw new Error('Tiempo de espera agotado para la solución del CAPTCHA');
    }

    private sleep(ms: number): Promise<void> {
        return new Promise(resolve => setTimeout(resolve, ms));
    }

    async solveReCaptchaV2(websiteUrl: string, websiteKey: string): Promise<string> {
        const taskId = await this.createTask({
            type: 'ReCaptchaV2TaskProxyLess',
            websiteURL: websiteUrl,
            websiteKey
        });

        const result = await this.getTaskResult(taskId);
        return result.solution?.gRecaptchaResponse || '';
    }

    async solveReCaptchaV3(
        websiteUrl: string,
        websiteKey: string,
        pageAction = 'submit'
    ): Promise<string> {
        const taskId = await this.createTask({
            type: 'ReCaptchaV3TaskProxyLess',
            websiteURL: websiteUrl,
            websiteKey,
            pageAction
        });

        const result = await this.getTaskResult(taskId);
        return result.solution?.gRecaptchaResponse || '';
    }

    async solveTurnstile(websiteUrl: string, websiteKey: string): Promise<string> {
        const taskId = await this.createTask({
            type: 'AntiTurnstileTaskProxyLess',
            websiteURL: websiteUrl,
            websiteKey
        });

        const result = await this.getTaskResult(taskId);
        return result.solution?.token || '';
    }
}

export const capSolver = new CapSolverService();

Resolviendo diferentes tipos de CAPTCHA con Crawlee

reCAPTCHA v2 con PlaywrightCrawler

typescript Copy

import { PlaywrightCrawler, Dataset } from 'crawlee';
import { capSolver } from './capsolver-service';

const RECAPTCHA_SITE_KEY = 'TU_CLAVE_DE_SITIO';

const crawler = new PlaywrightCrawler({
    async requestHandler({ page, request, log }) {
        log.info(`Procesando ${request.url}`);

        // Verificar si la página tiene reCAPTCHA
        const hasRecaptcha = await page.$('.g-recaptcha');

        if (hasRecaptcha) {
            log.info('reCAPTCHA detectado, resolviendo...');

            // Obtener la clave del sitio de la página
            const siteKey = await page.$eval(
                '.g-recaptcha',
                (el) => el.getAttribute('data-sitekey')
            ) || RECAPTCHA_SITE_KEY;

            // Resolver el CAPTCHA
            const token = await capSolver.solveReCaptchaV2(request.url, siteKey);

            // Inyectar el token - el área de texto está oculta, así que usamos JavaScript
            await page.$eval('#g-recaptcha-response', (el: HTMLTextAreaElement, token: string) => {
                el.style.display = 'block';
                el.value = token;
            }, token);

            // Enviar el formulario
            await page.click('button[type="submit"]');
            await page.waitForLoadState('networkidle');

            log.info('reCAPTCHA resuelto con éxito!');
        }

        // Extraer datos después de resolver el CAPTCHA
        const title = await page.title();
        const content = await page.locator('body').innerText();

        await Dataset.pushData({
            title,
            content: content.slice(0, 1000)
        });
    },

    maxRequestsPerCrawl: 50,
    headless: true
});

await crawler.run(['https://example.com/pagina-protegida']);

reCAPTCHA v3 con PlaywrightCrawler

typescript Copy

import { PlaywrightCrawler, Dataset } from 'crawlee';
import { capSolver } from './capsolver-service';

const crawler = new PlaywrightCrawler({
    async requestHandler({ page, request, log }) {
        log.info(`Procesando ${request.url}`);

        // reCAPTCHA v3 es invisible, detectarlo por script
        const recaptchaScript = await page.$('script[src*="recaptcha/api.js?render="]');

        if (recaptchaScript) {
            log.info('reCAPTCHA v3 detectado, resolviendo...');

            // Extraer la clave del sitio del script src
            const scriptSrc = await recaptchaScript.getAttribute('src') || '';
            const siteKeyMatch = scriptSrc.match(/render=([^&]+)/);
            const siteKey = siteKeyMatch ? siteKeyMatch[1] : '';

            if (siteKey) {
                // Resolver reCAPTCHA v3
                const token = await capSolver.solveReCaptchaV3(
                    request.url,
                    siteKey,
                    'submit'
                );

                // Inyectar token en entrada oculta usando JavaScript
                await page.$eval('input[name="g-recaptcha-response"]', (el: HTMLInputElement, token: string) => {
                    el.value = token;
                }, token);

                log.info('Token de reCAPTCHA v3 inyectado!');
            }
        }

        // Continuar con la subida del formulario o extracción de datos
        const title = await page.title();
        const url = page.url();

        await Dataset.pushData({ title, url });
    }
});

await crawler.run(['https://example.com/pagina-protegida-v3']);

Cloudflare Turnstile con PlaywrightCrawler

typescript Copy

import { PlaywrightCrawler, Dataset } from 'crawlee';
import { capSolver } from './capsolver-service';

const crawler = new PlaywrightCrawler({
    async requestHandler({ page, request, log }) {
        log.info(`Procesando ${request.url}`);

        // Verificar si hay un widget de Turnstile
        const hasTurnstile = await page.$('.cf-turnstile');

        if (hasTurnstile) {
            log.info('Cloudflare Turnstile detectado, resolviendo...');

            // Obtener clave del sitio
            const siteKey = await page.$eval(
                '.cf-turnstile',
                (el) => el.getAttribute('data-sitekey')
            );

            if (siteKey) {
                // Resolver Turnstile
                const token = await capSolver.solveTurnstile(request.url, siteKey);

                // Inyectar token usando JavaScript (entrada oculta)
                await page.$eval('input[name="cf-turnstile-response"]', (el: HTMLInputElement, token: string) => {
                    el.value = token;
                }, token);

                // Enviar formulario
                await page.click('button[type="submit"]');
                await page.waitForLoadState('networkidle');

                log.info('Turnstile resuelto con éxito!');
            }
        }

        // Extraer datos
        const title = await page.title();
        const content = await page.locator('body').innerText();

        await Dataset.pushData({
            title,
            content: content.slice(0, 500)
        });
    }
});

await crawler.run(['https://example.com/pagina-protegida-turnstile']);

Integración avanzada: Detección automática de tipo de CAPTCHA

Aquí tienes un raspador avanzado que detecta y resuelve automáticamente diferentes tipos de CAPTCHA:

typescript Copy

import { PlaywrightCrawler, Dataset } from 'crawlee';
import { capSolver } from './capsolver-service';

interface CaptchaInfo {
    type: 'recaptcha-v2' | 'recaptcha-v3' | 'turnstile' | 'none';
    siteKey: string | null;
}

async function detectCaptcha(page: any): Promise<CaptchaInfo> {
    // Verificar reCAPTCHA v2
    const recaptchaV2 = await page.$('.g-recaptcha');
    if (recaptchaV2) {
        const siteKey = await page.$eval('.g-recaptcha', (el: Element) =>
            el.getAttribute('data-sitekey')
        );
        return { type: 'recaptcha-v2', siteKey };
    }

    // Verificar reCAPTCHA v3
    const recaptchaV3Script = await page.$('script[src*="recaptcha/api.js?render="]');
    if (recaptchaV3Script) {
        const scriptSrc = await recaptchaV3Script.getAttribute('src') || '';
        const match = scriptSrc.match(/render=([^&]+)/);
        const siteKey = match ? match[1] : null;
        return { type: 'recaptcha-v3', siteKey };
    }

    // Verificar Turnstile
    const turnstile = await page.$('.cf-turnstile');
    if (turnstile) {
        const siteKey = await page.$eval('.cf-turnstile', (el: Element) =>
            el.getAttribute('data-sitekey')
        );
        return { type: 'turnstile', siteKey };
    }

    return { type: 'none', siteKey: null };
}

async function solveCaptcha(
    page: any,
    url: string,
    captchaInfo: CaptchaInfo
): Promise<void> {
    if (!captchaInfo.siteKey || captchaInfo.type === 'none') return;

    let token: string;

    switch (captchaInfo.type) {
        case 'recaptcha-v2':
            token = await capSolver.solveReCaptchaV2(url, captchaInfo.siteKey);
            // Área de texto oculta - usar JavaScript para establecer el valor
            await page.$eval('#g-recaptcha-response', (el: HTMLTextAreaElement, t: string) => {
                el.style.display = 'block';
                el.value = t;
            }, token);
            break;

        case 'recaptcha-v3':
            token = await capSolver.solveReCaptchaV3(url, captchaInfo.siteKey);
            // Entrada oculta - usar JavaScript para establecer el valor
            await page.$eval('input[name="g-recaptcha-response"]', (el: HTMLInputElement, t: string) => {
                el.value = t;
            }, token);
            break;

        case 'turnstile':
            token = await capSolver.solveTurnstile(url, captchaInfo.siteKey);
            // Entrada oculta - usar JavaScript para establecer el valor
            await page.$eval('input[name="cf-turnstile-response"]', (el: HTMLInputElement, t: string) => {
                el.value = t;
            }, token);
            break;
    }
}

const crawler = new PlaywrightCrawler({
    async requestHandler({ page, request, log, enqueueLinks }) {
        log.info(`Procesando ${request.url}`);

        // Detección automática de CAPTCHA
        const captchaInfo = await detectCaptcha(page);

        if (captchaInfo.type !== 'none') {
            log.info(`Detectado ${captchaInfo.type}, resolviendo...`);
            await solveCaptcha(page, request.url, captchaInfo);

            // Enviar formulario si existe
            const submitBtn = await page.$('button[type="submit"], input[type="submit"]');
            if (submitBtn) {
await submitBtn.click();
                await page.waitForLoadState('networkidle');
            }

            log.info('CAPTCHA resuelto correctamente!');
        }

        // Extraer datos
        const title = await page.title();
        const url = page.url();
        const text = await page.locator('body').innerText();

        await Dataset.pushData({
            title,
            url,
            text: text.slice(0, 1000)
        });

        // Continuar con el rastreo
        await enqueueLinks();
    },

    maxRequestsPerCrawl: 100
});

await crawler.run(['https://example.com']);

Cómo enviar tokens de CAPTCHA

Cada tipo de CAPTCHA requiere un método diferente de envío en el contexto del navegador:

reCAPTCHA v2/v3 - Inyección de token

typescript Copy

async function submitRecaptchaToken(page: any, token: string): Promise<void> {
    // El área de texto de respuesta está oculta: use JavaScript para establecer el valor
    await page.$eval('#g-recaptcha-response', (el: HTMLTextAreaElement, token: string) => {
        el.style.display = 'block';
        el.value = token;
    }, token);

    // También establecer el campo oculto si existe (común en implementaciones personalizadas)
    try {
        await page.$eval('input[name="g-recaptcha-response"]', (el: HTMLInputElement, token: string) => {
            el.value = token;
        }, token);
    } catch (e) {
        // El campo podría no existir
    }

    // Enviar el formulario
    await page.click('form button[type="submit"]');
}

Turnstile - Inyección de token

typescript Copy

async function submitTurnstileToken(page: any, token: string): Promise<void> {
    // Establecer token en el campo oculto usando JavaScript
    await page.$eval('input[name="cf-turnstile-response"]', (el: HTMLInputElement, token: string) => {
        el.value = token;
    }, token);

    // Enviar el formulario
    await page.click('form button[type="submit"]');
}

Usar la extensión de CapSolver con Crawlee

Para escenarios donde desee resolver CAPTCHAs automáticamente, puede cargar la extensión de CapSolver:

typescript Copy

import { PlaywrightCrawler } from 'crawlee';
import path from 'path';

const crawler = new PlaywrightCrawler({
    launchContext: {
        launchOptions: {
            // Cargar extensión de CapSolver
            args: [
                `--disable-extensions-except=${path.resolve('./capsolver-extension')}`,
                `--load-extension=${path.resolve('./capsolver-extension')}`
            ],
            headless: false // Las extensiones requieren modo no oculto
        }
    },

    async requestHandler({ page, request, log }) {
        log.info(`Procesando ${request.url}`);

        // La extensión resolverá automáticamente las CAPTCHAs
        // Esperar a que se resuelva la CAPTCHA potencial
        await page.waitForTimeout(5000);

        // Continuar con el scraping
        const title = await page.title();
        const content = await page.locator('body').innerText();

        console.log({ title, content });
    }
});

await crawler.run(['https://example.com/captcha-page']);

Buenas prácticas

1. Manejo de errores con reintentos

typescript Copy

async function solveWithRetry(
    solverFn: () => Promise<string>,
    maxRetries = 3
): Promise<string> {
    for (let attempt = 0; attempt < maxRetries; attempt++) {
        try {
            return await solverFn();
        } catch (error) {
            if (attempt === maxRetries - 1) throw error;

            const delay = Math.pow(2, attempt) * 1000; // Retroalimentación exponencial
            await new Promise(resolve => setTimeout(resolve, delay));
        }
    }
    throw new Error('Se excedió el número máximo de reintentos');
}

// Uso
const token = await solveWithRetry(() =>
    capSolver.solveReCaptchaV2(url, siteKey)
);

2. Gestión de balance

typescript Copy

import axios from 'axios';

async function checkBalance(apiKey: string): Promise<number> {
    const response = await axios.post('https://api.capsolver.com/getBalance', {
        clientKey: apiKey
    });

    return response.data.balance || 0;
}

// Verificar antes de iniciar el crawler
const balance = await checkBalance(CAPSOLVER_API_KEY);
if (balance < 1) {
    console.warn('¡Balance de CapSolver bajo! Por favor recárguelo.');
}

3. Gestión de sesiones para múltiples páginas

typescript Copy

import { PlaywrightCrawler, Dataset } from 'crawlee';
import { capSolver } from './capsolver-service';

// Almacenar en caché los tokens resueltos para combinaciones de dominio/clave similares
const tokenCache = new Map<string, { token: string; timestamp: number }>();
const TOKEN_TTL = 90000; // 90 segundos

async function getCachedToken(
    url: string,
    siteKey: string,
    solverFn: () => Promise<string>
): Promise<string> {
    const cacheKey = `${new URL(url).hostname}:${siteKey}`;
    const cached = tokenCache.get(cacheKey);

    if (cached && Date.now() - cached.timestamp < TOKEN_TTL) {
        return cached.token;
    }

    const token = await solverFn();
    tokenCache.set(cacheKey, { token, timestamp: Date.now() });
    return token;
}

4. Integración con proxies

typescript Copy

import { PlaywrightCrawler, ProxyConfiguration } from 'crawlee';

const proxyConfiguration = new ProxyConfiguration({
    proxyUrls: [
        'http://user:[email protected]:8080',
        'http://user:[email protected]:8080',
        'http://user:[email protected]:8080'
    ]
});

const crawler = new PlaywrightCrawler({
    proxyConfiguration,

    async requestHandler({ page, request, log, proxyInfo }) {
        log.info(`Usando proxy: ${proxyInfo?.url}`);

        // Tu lógica de resolución de CAPTCHA y scraping aquí
    }
});

Ejemplo completo: Scraping de tienda en línea con manejo de CAPTCHA

typescript Copy

import { PlaywrightCrawler, Dataset, ProxyConfiguration } from 'crawlee';
import { capSolver } from './capsolver-service';

interface Product {
    name: string;
    price: string;
    url: string;
    image: string;
}

const proxyConfiguration = new ProxyConfiguration({
    proxyUrls: ['http://user:[email protected]:8080']
});

const crawler = new PlaywrightCrawler({
    proxyConfiguration,
    maxRequestsPerCrawl: 200,
    maxConcurrency: 5,

    async requestHandler({ page, request, log, enqueueLinks }) {
        log.info(`Rastreando: ${request.url}`);

        // Verificar si hay alguna CAPTCHA
        const hasRecaptcha = await page.$('.g-recaptcha');
        const hasTurnstile = await page.$('.cf-turnstile');

        if (hasRecaptcha) {
            const siteKey = await page.$eval(
                '.g-recaptcha',
                (el) => el.getAttribute('data-sitekey')
            );

            if (siteKey) {
                log.info('Resolviendo reCAPTCHA...');
                const token = await capSolver.solveReCaptchaV2(request.url, siteKey);

                // Inyectar token usando JavaScript (elemento oculto)
                await page.$eval('#g-recaptcha-response', (el: HTMLTextAreaElement, t: string) => {
                    el.style.display = 'block';
                    el.value = t;
                }, token);
                await page.click('button[type="submit"]');
                await page.waitForLoadState('networkidle');
            }
        }

        if (hasTurnstile) {
            const siteKey = await page.$eval(
                '.cf-turnstile',
                (el) => el.getAttribute('data-sitekey')
            );

            if (siteKey) {
                log.info('Resolviendo Turnstile...');
                const token = await capSolver.solveTurnstile(request.url, siteKey);

                // Inyectar token usando JavaScript (elemento oculto)
                await page.$eval('input[name="cf-turnstile-response"]', (el: HTMLInputElement, t: string) => {
                    el.value = t;
                }, token);
                await page.click('button[type="submit"]');
                await page.waitForLoadState('networkidle');
            }
        }

        // Extraer datos de productos usando localizadores de Playwright
        const productCards = await page.locator('.product-card').all();
        const products: Product[] = [];

        for (const card of productCards) {
            products.push({
                name: await card.locator('.product-name').innerText().catch(() => ''),
                price: await card.locator('.product-price').innerText().catch(() => ''),
                url: await card.locator('a').getAttribute('href') || '',
                image: await card.locator('img').getAttribute('src') || ''
            });
        }

        if (products.length > 0) {
            await Dataset.pushData(products);
            log.info(`Extraídos ${products.length} productos`);
        }

        // Enqueue enlaces de paginación y categorías
        await enqueueLinks({
            globs: ['**/products/**', '**/page/**', '**/category/**']
        });
    },

    failedRequestHandler({ request, log }) {
        log.error(`La solicitud falló: ${request.url}`);
    }
});

// Iniciar el rastreo
await crawler.run(['https://example-store.com/products']);

// Exportar resultados
const dataset = await Dataset.open();
await dataset.exportToCSV('products.csv');

console.log('Rastreo completado! Los resultados se guardaron en products.csv');

Conclusión

Integrar CapSolver con Crawlee desbloquea el potencial completo del scraping web para desarrolladores de Node.js. Al combinar la infraestructura robusta de Crawlee para rastreo con las capacidades líderes en resolución de CAPTCHA de CapSolver, puedes construir raspadores confiables que manejen incluso los mecanismos más desafiantes de protección contra bots.

Ya sea que estés construyendo pipelines de extracción de datos, sistemas de monitoreo de precios o herramientas de agregación de contenido, la combinación de Crawlee y CapSolver proporciona la confiabilidad y escalabilidad necesarias para entornos de producción.

¿Listo para comenzar? Regístrate en CapSolver y usa el código de bonificación CRAWLEE para obtener un 6% adicional en cada recarga!

Preguntas frecuentes

¿Qué es Crawlee?

Crawlee es una biblioteca de scraping web y automatización de navegadores para Node.js diseñada para construir rastreadores confiables. Soporta tanto el rastreo basado en HTTP (con Cheerio/JSDOM) como la automatización completa del navegador (con Playwright/Puppeteer), y cuenta con funciones integradas como rotación de proxies, gestión de sesiones y protección contra bots.

¿Cómo se integra CapSolver con Crawlee?

CapSolver se integra con Crawlee a través de una clase de servicio que encapsula la API de CapSolver. Dentro del manejador de solicitudes de tu rastreador, puedes detectar desafíos de CAPTCHA y usar CapSolver para resolverlos, luego inyectar los tokens de vuelta en la página.

¿Qué tipos de CAPTCHA puede resolver CapSolver?

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

¿Cuánto cuesta CapSolver?

CapSolver ofrece precios competitivos según el tipo y volumen de CAPTCHA resueltos. Visita capsolver.com para ver los detalles de precios actuales. Usa el código CRAWLEE para obtener un 6% de bonificación en tu primer recarga.

¿Puedo usar CapSolver con otros frameworks de Node.js?

Sí. CapSolver proporciona una API REST que puede integrarse con cualquier framework de Node.js, incluyendo Express, Puppeteer standalone, Selenium, entre otros.

¿Crawlee es gratuito?

Sí, Crawlee es de código abierto y se distribuye bajo la licencia Apache 2.0. El framework es gratuito, aunque podrías incurrir en costos por servicios de proxies y servicios de resolución de CAPTCHA como CapSolver.

¿Cómo encuentro la clave de CAPTCHA?

La clave de CAPTCHA generalmente se encuentra en el código fuente de la página. Busca:

reCAPTCHA: atributo data-sitekey en el elemento .g-recaptcha
Turnstile: atributo data-sitekey en el elemento .cf-turnstile
O revisa las solicitudes de red para encontrar la clave en llamadas a API

¿Qué tipo de rastreador de Crawlee debo usar?

CheerioCrawler: Ideal para scraping HTML rápido y simple sin JavaScript
PlaywrightCrawler: Ideal para sitios con mucho JavaScript y resolución de CAPTCHA (recomendado para integración con CapSolver)
PuppeteerCrawler: Alternativa a Playwright con capacidades similares
JSDOMCrawler: Buena opción intermedia con soporte básico para JavaScript

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

Maestro MCP: Potencia la inteligencia artificial en 2026

El Protocolo de Contexto de Modelo (MCP) es el futuro de la integración de IA. Aprende cómo el MCP estandariza la comunicación entre herramientas de IA, impulsa la automatización empresarial y mejora la inteligencia de la IA en 2026.

web scraping

Aloísio Vítor

24-Dec-2025

Mejores Servicios de la Empresa de Proxy - Capsolver

Mejores Servicios de Empresa de Proxy: Deberías Saber

Este blog ofrece una vista detallada de cinco proveedores destacados de servicios de proxy: ProxyScrape.com, Proxies.gg, Asocks.com, MetaProxies, RushProxy y Ake.net. Cada sección del blog se enfoca en las ofertas únicas, características, precios y beneficios de los servicios individuales, destacando sus fortalezas y especialidades. Desde proxies residenciales y móviles hasta opciones de centros de datos, el blog ofrece una visión general completa del amplio panorama de proxies. Ya sea que sea una empresa que busca herramientas de análisis de mercado, un individuo que busca privacidad en línea o un desarrollador que necesita soluciones de raspado web, este blog sirve como una guía valiosa para comprender y elegir el servicio de proxy adecuado para sus necesidades.

web scraping

Ethan Collins

24-Dec-2025

Resolver Captcha en Crawlee con CapSolver

Cómo resolver Captcha en Crawlee con la integración de CapSolver

Una guía práctica para resolver reCAPTCHA y Turnstile en Crawlee usando CapSolver para scraping estable en Node.js.

web scraping

Adélia Cruz

24-Dec-2025

Herramientas de scraping de web - Explicado

Herramientas de raspado de web - Explicado

Descubre las mejores herramientas de scraping web para una extracción eficiente de datos de sitios web, adecuadas tanto para programadores como para no programadores, en nuestro guía completa.

web scraping

Rajinder Singh

23-Dec-2025

Resolver Captcha en CrewAI con CapSolver

Cómo resolver Captcha en CrewAI con integración de CapSolver

La integración de CrewAI con CapSolver habilita un manejo fluido de CAPTCHA para reCAPTCHA, Cloudflare Turnstile, AWS WAF y más, mejorando las tareas web automatizadas.

web scraping

Adélia Cruz

23-Dec-2025

Cómo resolver MTCaptcha con Python

En este artículo, te mostraremos cómo resolver MTCaptcha con Python

web scraping

Adélia Cruz

18-Dec-2025