Como Integrar o CapSolver com o Puppeteer | Guia Completo 2025

O que é Puppeteer?

Puppeteer é uma biblioteca JavaScript que fornece uma API de alto nível para controlar o Chrome ou o Firefox usando o Protocolo DevTools ou o WebDriver BiDi.

Originalmente projetado para testes de automa??o de navegador, o Puppeteer tornou-se uma das ferramentas mais importantes para web scraping moderno devido às suas poderosas capacidades de manipula??o de páginas web.

No web scraping tradicional, a maior parte do conteúdo da página é estático e pode ser extraído diretamente solicitando o HTML e analisando-o usando express?es regulares ou ferramentas de análise DOM. No entanto, muitos websites modernos usam JavaScript para carregar dados assincronamente — especialmente aqueles construídos com frameworks como Vue e React, que dependem de Aplica??es de Página ?nica (SPA). Nestes casos, o conteúdo só fica disponível depois que o navegador executa o JavaScript.

O Puppeteer resolve esse desafio controlando diretamente um navegador real. Ele pode simular o comportamento real do usuário, como abrir páginas, aguardar o carregamento completo da página, clicar, digitar, rolar e muito mais — tornando-o ideal para raspar conteúdo renderizado na interface.

Por que usar Puppeteer para Web Scraping?

1. Ambiente de Navegador Real

• Renderiza completamente páginas web com tecnologia JavaScript.
• Suporta recursos web modernos como WebSocket, WebWorker e muito mais.
• Ignora as limita??es de sites estáticos em raspadores tradicionais.

2. Intera??es de Usuário Automatizadas

• Simula cliques, envios de formulários, entradas de teclado, eventos de rolagem.
• Adequado para raspar dados de websites que exigem login ou interativos.

3. Controle de Requisi??es de Rede

• Intercepta e modifica requisi??es.
• Bloqueia recursos desnecessários, como anúncios/imagens, para melhorar a eficiência.
• Captura e inspeciona respostas XHR/Fetch API.

4. Gerenciamento Inteligente de Páginas

• Aguarda elementos, solicita??es de rede ou timeouts para um tempo preciso de extra??o de dados.
• Captura páginas em diferentes estágios (por exemplo, DOMContentLoaded).

5. Compatível com a preven??o de bots e bypass de CAPTCHA

• Oferece impress?o digital mais realista do que clientes HTTP brutos.
• Suporta configura??o de proxy, User-Agent personalizado, configura??es de idioma, etc.

Casos de Uso Comuns do Puppeteer

• Raspagem de conteúdo din?mico renderizado por JavaScript
• Intera??o com aplicativos web complexos que exigem login ou navega??o em várias etapas
• Extra??o de dados de sites SPA construídos com Vue, React, Angular
• Gera??o de PDFs, capturas de tela ou relatórios visuais
• Teste de navegador automatizado com recursos de raspagem
• Execu??o no modo sem cabe?a em ambientes de servidor

Passos Básicos para Usar o Puppeteer

Passo 1: Instalar o Puppeteer

Você pode instalar o Puppeteer de duas maneiras:

npm i puppeteer        # Isso irá baixar o Puppeteer junto com uma vers?o compatível do Chromium.
npm i puppeteer-core   # Use isso se você já tiver o Chrome instalado e precisar apenas da biblioteca Puppeteer.

Passo 2: Extrair títulos de blog com Puppeteer

No exemplo abaixo, usamos o Puppeteer para navegar até o blog CapSolver e pegar todos os títulos de postagem de blog <h5> da página

const puppeteer = require('puppeteer');

(async () => {
    const browser = await puppeteer.launch({
        headless: false,
        args: ['--window-size=1920,1080'],
        defaultViewport: null
    });
    const [page] = await browser.pages();

    await page.goto('/blog/All');

    const h5Titles = await page.evaluate(() => {
        const headings = Array.from(document.querySelectorAll('h5'));
        return headings.map(heading => heading.textContent.trim());
    });

    console.log(h5Titles);
    await browser.close();
})();

Ao controlar uma inst?ncia de navegador real, posso esperar que o conteúdo renderizado em JavaScript seja carregado, assim como um usuário regular faria. Isso torna o Puppeteer incrivelmente útil para raspar sites modernos que usam frameworks como Vue ou React.

Como integrar a extens?o CapSolver com o Puppeteer

Um dos recursos poderosos do Puppeteer é seu suporte para carregar extens?es de navegador, o que permite a integra??o com a extens?o de navegador CapSolver para resolver desafios de CAPTCHA. Integra??o passo a passo:

Passo 1. Baixe a extens?o CapSolver

Primeiro, baixe a vers?o mais recente da extens?o CapSolver da página oficial de lan?amentos do GitHub

Após o download, descompacte o arquivo .zip para obter a pasta da extens?o.

Passo 2. Inicie o Puppeteer com a extens?o

Agora que você tem a pasta da extens?o pronta, você pode carregá-la no Puppeteer usando as sinaliza??es --disable-extensions-except e --load-extension ao iniciar o navegador:

const puppeteer = require('puppeteer');

// Substitua isso pelo caminho real para sua extens?o CapSolver descompactada
const extensionPath = 'path/to/capsolver-extension';

(async () => {
    const browser = await puppeteer.launch({
        headless: false,
        args: [
            `--disable-extensions-except=${extensionPath}`,
            `--load-extension=${extensionPath}`,
        ],
    });

    const [page] = await browser.pages();
    await page.goto('/blog/All');

    // Agora você pode usar a funcionalidade da extens?o CapSolver nesta sess?o

    await browser.close();
})();

Resolver reCAPTCHA v2 com a extens?o CapSolver

Tipos de CAPTCHA como reCAPTCHA v2/v3, Cloudflare Turnstile, AWS WAF e Imagetotext s?o amplamente utilizados em milhares de sites. Apesar de sua popularidade, esses CAPTCHAs normalmente possuem estruturas DOM consistentes e detectáveis. ? aí que a Extens?o CapSolver entra em a??o — ela detecta e resolve automaticamente sem a necessidade de intera??o manual.

Vamos tomar o reCAPTCHA v2 como exemplo para demonstrar como usar a extens?o CapSolver no Puppeteer para resolver captchas (Observa??o: A menos que especificado de outra forma, os exemplos a seguir s?o demonstrados no modo de clique: /assets/config.js → reCaptchaMode: 'click').

?? N?o se esque?a de descompactar o arquivo zip da extens?o e configurar sua apiKey em /assets/config.js

const puppeteer = require('puppeteer');

// Passo 1: Obtenha a extens?o do github (https://github.com/capsolver/capsolver-browser-extension/releases)
// Passo 2: Descompacte o arquivo zip da extens?o e configure sua apiKey em /assets/config.js
const extensionPath = 'path/to/CapSolver Browser Extension-v1.16.0';

(async () => {
    const browser = await puppeteer.launch({
        headless: false,
        args: [
            `--disable-extensions-except=${extensionPath}`,
            `--load-extension=${extensionPath}`,
            `--window-size=1920,1080`,
            `--lang=en-US`,
        ],
        defaultViewport: null
    });
    const [page] = await browser.pages();
    await page.goto('https://recaptcha-demo.appspot.com/recaptcha-v2-checkbox.php');
    await page.waitForSelector('form[action="/recaptcha-v2-checkbox.php"]');

    // A extens?o reconhecerá automaticamente o recaptcha e o resolverá.
    // Aguarde o captcha ser resolvido e clique no bot?o de envio.
    await new Promise(resolve => setTimeout(resolve, 15000));
    await page.click('button[type="submit"]');
    await new Promise(resolve => setTimeout(resolve, 5000));
    await browser.close();
})();

?? A extens?o CapSolver também suporta muitas op??es de configura??o úteis. Abaixo est?o alguns exemplos comuns (Observa??o: Todas as configura??es s?o definidas em /assets/config.js)

Op??o de Configura??o: solvedCallback

Como podemos ver, o código anterior espera 15 segundos após entrar na página antes de clicar em enviar. Esse atraso de 15 segundos destina-se a dar à extens?o CapSolver tempo suficiente para resolver automaticamente o reCAPTCHA. No entanto, essa abordagem n?o é muito elegante, pois o tempo real necessário pode ser muito menor que 15 segundos, ou ainda mais em condi??es de rede precárias.

O solvedCallback foi projetado para resolver esse problema. Ele aciona um callback assim que o CAPTCHA for resolvido, notificando você de que a verifica??o está concluída. Você pode encontrar a op??o solvedCallback em /assets/config.js e definir um nome de fun??o personalizado — por padr?o, é captchaSolvedCallback. Em seguida, use o método page.exposeFunction para expor a fun??o no contexto do navegador.

Vamos otimizar o código anterior usando essa abordagem.

const puppeteer = require('puppeteer');

// Passo 1: Obtenha a extens?o do github (https://github.com/capsolver/capsolver-browser-extension/releases)
// Passo 2: Descompacte o arquivo zip da extens?o e configure sua apiKey em /assets/config.js
const extensionPath = 'path/to/CapSolver Browser Extension-v1.16.0';

(async () => {
    const browser = await puppeteer.launch({
        headless: false,
        args: [
            `--disable-extensions-except=${extensionPath}`,
            `--load-extension=${extensionPath}`,
            `--window-size=1920,1080`,
            `--lang=en-US`,
        ],
        defaultViewport: null
    });
    const [page] = await browser.pages();
    await page.goto('https://recaptcha-demo.appspot.com/recaptcha-v2-checkbox.php');
    await page.waitForSelector('form[action="/recaptcha-v2-checkbox.php"]');

    // A extens?o reconhecerá automaticamente o reCAPTCHA e o resolverá.
    // Use solvedCallback para prosseguir somente após o CAPTCHA ser resolvido.
    await page.exposeFunction('captchaSolvedCallback', async () => {
        console.log('Captcha resolvido!');

        // Determine se a verifica??o ainda é necessária.
        const iframe = await page.$('iframe[src*="recaptcha"]');
        if (iframe) {
            const frame = await iframe.contentFrame();
            const finished = await frame.evaluate(() => {
                const element = document.querySelector('.recaptcha-checkbox-border');
                return element && window.getComputedStyle(element).display === 'none';
            });

            if (finished) {
                console.log('Verifica??o concluída!');
                await page.click('button[type="submit"]');
                await new Promise(resolve => setTimeout(resolve, 3000));
                await browser.close();
            } else {
                console.log('Necessário verificar novamente...');
            }
        }
    });
})();

Para o reCAPTCHA v2, às vezes pode pedir que você clique em várias rodadas de imagens. ? por isso que, após cada tentativa de verifica??o, precisamos verificar se a caixa de sele??o "N?o sou um rob?" ainda existe. Se a caixa de sele??o n?o estiver mais presente (ou seja, se tiver se transformado em um ??), consideramos a verifica??o concluída.

Op??o de Configura??o: manualSolving

Nos exemplos anteriores, o processo de resolu??o do CAPTCHA come?a assim que a página carrega. No entanto, em alguns casos, você pode precisar executar outras a??es primeiro — como inserir um nome de usuário e senha — antes de acionar a resolu??o do CAPTCHA. Resolver o CAPTCHA muito cedo pode levar à expira??o do token.

manualSolving foi projetado para resolver esse problema. Quando ativado, ele permite que você acione manualmente o processo de resolu??o do CAPTCHA. Para ativá-lo, defina o seguinte em /assets/config.js:

manualSolving: true

Assim que isso estiver ativado, você pode acionar a resolu??o do CAPTCHA de duas maneiras:

1. Simule clicando no bot?o da extens?o CapSolver usando o Puppeteer;

2. Execute o código a seguir para enviar uma mensagem que aciona a resolu??o do CAPTCHA:

   js Copy

   window.postMessage({ type: 'capsolverSolve' });

?? Observa??o: Este recurso só é compatível com vers?es de extens?o superiores à v1.16.0!

Aqui está um exemplo completo que demonstra ambos os métodos:

const puppeteer = require('puppeteer');

// Passo 1: Obtenha a extens?o do GitHub (https://github.com/capsolver/capsolver-browser-extension/releases)
// Passo 2: Descompacte o arquivo zip da extens?o e configure sua apiKey em /assets/config.js
const extensionPath = 'path/to/CapSolver Browser Extension-v1.16.0';

(async () => {
    const browser = await puppeteer.launch({
        headless: false,
        args: [
            `--disable-extensions-except=${extensionPath}`,
            `--load-extension=${extensionPath}`,
            `--window-size=1920,1080`,
            `--lang=en-US`,
        ],
        defaultViewport: null
    });
    const [page] = await browser.pages();
    await page.goto('https://recaptcha-demo.appspot.com/recaptcha-v2-checkbox.php');
    await page.waitForSelector('form[action="/recaptcha-v2-checkbox.php"]');

    // Simule a entrada do usuário
    await page.evaluate(() => {
        const inputA = document.querySelector('input[name="ex-a"]');
        inputA.value = 'username';
        const inputB = document.querySelector('input[name="ex-b"]');
        inputB.value = 'password';
    });

    // Simule outras opera??es
    for (let i = 1; i <= 5; i++) {
        await new Promise(resolve => setTimeout(resolve, 1000));
        console.log(`Esperou ${i} segundos...`);
    }

    // Acionar a resolu??o do CAPTCHA (requer manualSolving: true em config.js)
    console.log('Iniciando a resolu??o do CAPTCHA...');

    // Método 1: Simule clicando no bot?o CapSolver
    await page.evaluate(() => {
        document.querySelector('#capsolver-solver-tip-button').click()
    });

    // Método 2: Acionar usando postMessage
    // await page.evaluate(() => {
    //     window.postMessage({ type: 'capsolverSolve' });
    // });

    // Aguarde o CAPTCHA ser resolvido e clique no bot?o de envio
    await page.exposeFunction('captchaSolvedCallback', async () => {
        console.log('Captcha resolvido!');

        const iframe = await page.$('iframe[src*="recaptcha"]');
        if (iframe) {
            const frame = await iframe.contentFrame();
            const finished = await frame.evaluate(() => {
                const element = document.querySelector('.recaptcha-checkbox-border');
                return element && window.getComputedStyle(element).display === 'none';
            });

            if (finished) {
                console.log('Verifica??o concluída!');
                await page.click('button[type="submit"]');
                await new Promise(resolve => setTimeout(resolve, 3000));
                await browser.close();
            } else {
                console.log('Necessário verificar novamente...');
            }
        }
    });
})();

Op??o de Configura??o: reCaptchaMode

A op??o reCaptchaMode inclui dois modos: click e token.

• O modo click simula intera??o semelhante à humana clicando nas imagens.
• O modo token ignora o processo de clique e envia diretamente a tarefa reCAPTCHA para o backend do CapSolver via API, retornando o token instantaneamente.

Se você notar que o modo clique requer várias rodadas de cliques na imagem, provavelmente indica que a qualidade do seu ambiente local é ruim. Nesses casos, recomendamos o uso do modo token para melhor desempenho.

Modo Clique	Modo Token

Op??o de Configura??o: showSolveButton

Quando showSolveButton está definido como false (o padr?o é true), o bot?o CapSolver n?o será mais exibido na página. No entanto, isso n?o afetará a funcionalidade normal de resolu??o de CAPTCHA.

Op??o de Configura??o: useProxy

Após definir useProxy: true e especificar proxyType, hostOrIp, port, proxyLogin e proxyPassword, usaremos seu proxy para resolver o captcha. Quando você precisa usar seu próprio proxy? Geralmente, há duas situa??es:

1. Seu proxy é de melhor qualidade (por exemplo, o token reCAPTCHA gerado usando seu proxy tem uma pontua??o mais alta) e é mais rápido;
2. Em alguns casos, o IP usado para resolver o captcha precisa ser consistente com o IP que você usa para acessar o token.

As op??es acima s?o algumas op??es de configura??o comuns. Outras op??es podem ser definidas de acordo com suas necessidades reais. Se você tiver alguma dúvida, entre em contato com nosso suporte ao cliente.

Resolver CAPTCHA ImageToText com a extens?o CapSolver

Ao contrário de captchas de terceiros, como reCAPTCHA, Cloudflare Turnstile, AWS WAF, existe outro tipo de captcha que requer que reconhe?amos letras e números de imagens, o que chamamos de ImageToText. Eles s?o assim:

Os captchas ImageToText s?o implementados pelos próprios administradores do site. Esses captchas aparecem em posi??es diferentes em vários sites e páginas, portanto, a extens?o CapSolver n?o consegue identificar automaticamente quais imagens s?o captchas. Portanto, você precisa informar à extens?o CapSolver no seu código fazendo o seguinte:

1. Adicione um atributo capsolver-image-to-text-source com o valor 0 no elemento de imagem do captcha;
2. Adicione um atributo capsolver-image-to-text-result com o valor 0 no elemento onde o resultado é enviado.

Tanto capsolver-image-to-text-source quanto capsolver-image-to-text-result podem ser configurados em /assets/config.js como textCaptchaSourceAttribute e textCaptchaResultAttribute, respectivamente.

Vamos usar https://captcha.com/demos/features/captcha-demo.aspx como exemplo para demonstrar como resolver captchas ImageToText no Puppeteer.

Primeiro, verificamos o código-fonte da página da web e localizamos o elemento de imagem do captcha com o id demoCaptcha_CaptchaImage e o elemento da caixa de entrada de resultado com o id captchaCode, como mostrado na figura abaixo:

Ent?o, no código, podemos usar o método setAttribute para adicionar os elementos de localiza??o:

const puppeteer = require('puppeteer');

// Passo 1: Obtenha a extens?o do github (https://github.com/capsolver/capsolver-browser-extension/releases)
// Passo 2: Descompacte o arquivo zip da extens?o e configure sua apiKey em /assets/config.js
const extensionPath = 'path/to/CapSolver Browser Extension-v1.16.0';

(async () => {
    const browser = await puppeteer.launch({
        headless: false,
        args: [
            `--disable-extensions-except=${extensionPath}`,
            `--load-extension=${extensionPath}`,
            `--window-size=1920,1080`,
            `--lang=en-US`,
        ],
        defaultViewport: null
    });
    const [page] = await browser.pages();
    await page.goto('https://captcha.com/demos/features/captcha-demo.aspx');
    await page.waitForSelector('#demoCaptcha_CaptchaImage')

    // Informe à extens?o CapSolver onde a imagem do captcha está localizada na página da web.
    await page.evaluate(() => {
        const imgElement = document.querySelector('#demoCaptcha_CaptchaImage');
        if (imgElement) {
            imgElement.setAttribute('capsolver-image-to-text-source', '0');
        }
    });

    // Informe à extens?o CapSolver onde o resultado do reconhecimento do captcha deve ser preenchido na página da web.
    await page.evaluate(() => {
        const resultElement = document.querySelector('#captchaCode');
        if (resultElement) {
            resultElement.setAttribute('capsolver-image-to-text-result', '0');
        }
    });

    // Aguarde o captcha ser resolvido e clique no bot?o de valida??o.
    await page.exposeFunction('captchaSolvedCallback', async () => {
        console.log('Captcha resolvido!');
        await new Promise(resolve => setTimeout(resolve, 3000));
        await page.click('#validateCaptchaButton');
        await new Promise(resolve => setTimeout(resolve, 3000));
        await browser.close();
    });
})();

Efeito alcan?ado:

Como integrar a API CapSolver com o Puppeteer

Usar a extens?o CapSolver é conveniente e rápido, mas se você é um desenvolvedor experiente, recomendamos usar a integra??o da API. Em compara??o com a extens?o, a integra??o da API tem as seguintes vantagens:

1. Você pode personalizar mais par?metros, fornecendo dados mais precisos que podem cobrir quase todos os cenários de captcha.
2. Permite um controle mais flexível sobre quando resolver o captcha.
3. Fornece mensagens de erro mais detalhadas, ajudando os desenvolvedores a otimizar de acordo.

Antes de demonstrarmos o código, você precisa entender como nossa API funciona, que envolve principalmente duas etapas:

• Passo 1: https://api.capsolver.com/createTask — Criar uma tarefa
• Passo 2: https://api.capsolver.com/getTaskResult — Obter o resultado da tarefa

Criar uma tarefa geralmente requer o envio de dados JSON para o CapSolver. Os dados JSON incluem seu clientKey, websiteURL, websiteKey e outras informa??es. Diferentes tipos de captcha e sites exigem dados diferentes. Para informa??es detalhadas, consulte nossa documenta??o

Resolver reCAPTCHA v2 com a API CapSolver

Antes de resolver o reCAPTCHA v2, consulte a documenta??o: ReCaptchaV2. A documenta??o explica detalhadamente quais dados JSON você deve enviar para o CapSolver. Além disso, você pode usar a extens?o CapSolver para obter rapidamente os dados JSON

Tomando https://recaptcha-demo.appspot.com/recaptcha-v2-checkbox.php como exemplo, os dados JSON necessários s?o:

{
    "type": "ReCaptchaV2TaskProxyLess",
    "websiteKey": "6LfW6wATAAAAAHLqO2pb8bDBahxlMxNdo9g947u9",
    "websiteURL": "https://recaptcha-demo.appspot.com/recaptcha-v2-checkbox.php"
}

Também fornecemos um exemplo JS de como usar a API em nossa documenta??o para sua referência:

Integrando no Puppeteer:

const puppeteer = require('puppeteer');
const axios = require('axios');

// Substitua pela sua chave de API
const api_key = 'YOUR_API_KEY';
const captcha_type = 'ReCaptchaV2TaskProxyLess';
const site_key = '6LfW6wATAAAAAHLqO2pb8bDBahxlMxNdo9g947u9';
const site_url = 'https://recaptcha-demo.appspot.com/recaptcha-v2-checkbox.php';

async function capSolver() {
    const payload = {
        clientKey: api_key,
        task: {
            type: captcha_type,
            websiteKey: site_key,
            websiteURL: site_url
        }
    };

    try {
        const res = await axios.post('https://api.capsolver.com/createTask', payload);
        const task_id = res.data.taskId;
        if (!task_id) {
            console.log('Falha ao criar tarefa:', res.data);
            return;
        }
        console.log('Obteve taskId:', task_id);

        while (true) {
            await new Promise(resolve => setTimeout(resolve, 1000)); // Atraso de 1 segundo

            const getResultPayload = { clientKey: api_key, taskId: task_id };
            const resp = await axios.post('https://api.capsolver.com/getTaskResult', getResultPayload);
            const status = resp.data.status;

            if (status === 'ready') {
                return resp.data.solution.gRecaptchaResponse;
            }
            if (status === 'failed' || resp.data.errorId) {
                console.log('Resolu??o falhou! resposta:', resp.data);
                return;
            }
        }
    } catch (error) {
        console.error('Erro:', error);
    }
}

(async () => {
    const browser = await puppeteer.launch({
        headless: false,
        args: [
            '--window-size=1920,1080',
            '--lang=en-US',
        ],
        defaultViewport: null
    });
    const [page] = await browser.pages();
    await page.goto('https://recaptcha-demo.appspot.com/recaptcha-v2-checkbox.php');
    await page.waitForSelector('form[action="/recaptcha-v2-checkbox.php"]');

    const token = await capSolver();
    console.log("Token:", token);

    // Define o valor do token
    await page.evaluate((token) => {
        const textarea = document.getElementById('g-recaptcha-response');
        if (textarea) {
            textarea.value = token;
        }
    }, token);

    await page.click('button[type="submit"]');
    await new Promise(resolve => setTimeout(resolve, 5000));
    await browser.close();
})();

Resolver ImageToText com a API CapSolver

Tomando https://captcha.com/demos/features/captcha-demo.aspx como exemplo, localizamos o elemento de imagem do captcha com o id demoCaptcha_CaptchaImage e o elemento de entrada de resultado com o id captchaCode, como mostrado na imagem abaixo:

Para a ImageToTextTask, precisamos enviar o valor base64 da imagem do captcha para o CapSolver. O código de exemplo é o seguinte:

const puppeteer = require('puppeteer');
const axios = require('axios');

// Substitua pela sua chave de API
const api_key = 'YOUR_API_KEY';
const captcha_type = 'ImageToTextTask';
const site_url = 'https://captcha.com/demos/features/captcha-demo.aspx';

async function capSolver(base64Image) {
    const payload = {
        clientKey: api_key,
        task: {
            type: captcha_type,
            websiteURL: site_url,
            body: base64Image,
        }
    };

    try {
        const res = await axios.post('https://api.capsolver.com/createTask', payload);

        const status = res.data.status;
        if (status === 'ready') {
            return res.data.solution.text;
        }
        if (status === 'failed' || res.data.errorId) {
            console.log('Resolu??o falhou! resposta:', res.data);
            return "";
        }
    } catch (error) {
        console.error('Erro:', error);
    }
}

(async () => {
    const browser = await puppeteer.launch({
        headless: false,
        args: [
            '--window-size=1920,1080',
            '--lang=en-US',
        ],
        defaultViewport: null
    });
    const [page] = await browser.pages();
    await page.goto('https://captcha.com/demos/features/captcha-demo.aspx');
    await page.waitForSelector('#demoCaptcha_CaptchaImage');

    // Obtenha o valor base64 da imagem do captcha
    const captchaImage = await page.evaluate(() => {
        const img = document.querySelector('img[id="demoCaptcha_CaptchaImage"]');
        return img ? img.getAttribute('src') : null;
    });
    const base64Image = captchaImage.split(',')[1];

    const text = await capSolver(base64Image);
    console.log("Texto:", text);

    // Define o valor do texto reconhecido
    await page.evaluate((text) => {
        document.getElementById('captchaCode').value = text;
    }, text);

    await page.click('#validateCaptchaButton');
    await new Promise(resolve => setTimeout(resolve, 5000));
    await browser.close();
})();

Além disso, para alguns tipos especiais de ImageToText, você pode especificar modelos diferentes para melhorar a precis?o. Para detalhes, consulte nossa documenta??o:
https://docs.capsolver.com/en/guide/recognition/ImageToTextTask/

Referências ?teis & Notas Finais

Para ajudá-lo a aproveitar ao máximo o CapSolver, aqui est?o alguns recursos essenciais:

Referências ?teis

• Documenta??o CapSolver
• Lan?amentos do GitHub da extens?o CapSolver
• Extens?o CapSolver na Chrome Web Store
• Extens?o CapSolver em complementos do Firefox
• Resolutor de Pontua??o Semelhante à Humana para reCAPTCHA v3

Vídeos de demonstra??o com a extens?o CapSolver:

• Resolver reCAPTCHA v3 com a extens?o CapSolver Chrome
• Resolver reCAPTCHA v2 com a extens?o CapSolver Chrome
• Resolver reCAPTCHA com Puppeteer e extens?o CapSolver
• Resolver ImageToText com Puppeteer e extens?o CapSolver

Aqui est?o algumas op??es de configura??o poderosas que você pode aproveitar para uma resolu??o de captcha ainda melhor:

| textCaptchaResultAttribute | Atributo personalizado para marcar campos de entrada onde os resultados do captcha v?o |

Adicionalmente, a CapSolver oferece um Programa de Compartilhamento de Receita para Desenvolvedores, permitindo que desenvolvedores e parceiros ganhem comiss?es integrando ou promovendo solu??es CapSolver. ? uma ótima maneira de monetizar seu trabalho enquanto ajuda outros a resolver captchas eficientemente. Para detalhes completos, confira:
Plano para Desenvolvedores CapSolver

Ao integrar a API da CapSolver com o Puppeteer como demonstrado, você obtém controle total, flexibilidade e feedback detalhado de erros — perfeito para desenvolvedores que procuram uma solu??o robusta e escalável além de extens?es de navegador.

Para mais detalhes e uso avan?ado, certifique-se de verificar a documenta??o oficial e os tutoriais vinculados acima.

Obrigado por escolher CapSolver! Se você tiver alguma dúvida ou precisar de suporte, nossa equipe está sempre pronta para ajudar.