Oct21, 2024

Como usar o libcurl para Web Scraping

Adélia Cruz

Neural Network Developer

Web scraping é uma técnica poderosa para extrair dados de sites, permitindo a automação de tarefas como coletar informações de preços, monitorar atualizações de conteúdo ou coletar conjuntos de dados grandes. Uma das bibliotecas mais populares para realizar web scraping em C++ é libcurl, uma biblioteca de transferência de URL do lado do cliente gratuita e de código aberto. Ela suporta vários protocolos, como HTTP, HTTPS, FTP e outros, tornando-a uma escolha ideal para recuperar conteúdo da web.

Introdução ao libcurl

libcurl é uma poderosa biblioteca C para fazer solicitações HTTP, suportando vários protocolos como HTTP, HTTPS, FTP e muitos outros. É uma ferramenta flexível usada amplamente em aplicações C++ para realizar solicitações web.

Recursos:

Suporte multiprotocolo: HTTP, HTTPS, FTP, FTPS, SMTP e muitos outros.
Suporte assíncrono: Através de CURLM para gerenciar várias solicitações ao mesmo tempo.
Tratamento de erros: Fornece mensagens de erro detalhadas e códigos de status.
Autenticação: Suporta básica, digest, NTLM, Negotiate, etc.
Cookies e sessões: Pode gerenciar cookies e informações de sessão facilmente.

Pré-requisitos

Antes de usar libcurl, você deve:

Instale libcurl em seu sistema.
Inclua o cabeçalho curl/curl.h em seu código C++.

Você pode instalar libcurl no Linux com:

bash Copy

sudo apt-get install libcurl4-openssl-dev

Exemplo básico: Fazendo uma solicitação GET

Aqui está como realizar uma simples solicitação GET usando libcurl em C++:

cpp Copy

#include <iostream>
#include <curl/curl.h>

static size_t WriteCallback(void* contents, size_t size, size_t nmemb, void* userp)
{
    ((std::string*)userp)->append((char*)contents, size * nmemb);
    return size * nmemb;
}

int main() {
    CURL* curl;
    CURLcode res;
    std::string readBuffer;

    curl_global_init(CURL_GLOBAL_DEFAULT);
    curl = curl_easy_init();
    
    if(curl) {
        curl_easy_setopt(curl, CURLOPT_URL, "https://httpbin.org/get");
        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteCallback);
        curl_easy_setopt(curl, CURLOPT_WRITEDATA, &readBuffer);

        res = curl_easy_perform(curl);
        if(res != CURLE_OK) {
            std::cerr << "curl_easy_perform() failed: " << curl_easy_strerror(res) << std::endl;
        } else {
            std::cout << "Response: " << readBuffer << std::endl;
        }

        curl_easy_cleanup(curl);
    }
    curl_global_cleanup();
    
    return 0;
}

Exemplo de Web Scraping: Obtendo dados JSON de uma API

Aqui está um exemplo onde obtemos dados de uma API e imprimimos os resultados:

cpp Copy

#include <iostream>
#include <curl/curl.h>

static size_t WriteCallback(void* contents, size_t size, size_t nmemb, void* userp)
{
    ((std::string*)userp)->append((char*)contents, size * nmemb);
    return size * nmemb;
}

int main() {
    CURL* curl;
    CURLcode res;
    std::string readBuffer;

    curl_global_init(CURL_GLOBAL_DEFAULT);
    curl = curl_easy_init();

    if(curl) {
        curl_easy_setopt(curl, CURLOPT_URL, "https://jsonplaceholder.typicode.com/posts");
        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteCallback);
        curl_easy_setopt(curl, CURLOPT_WRITEDATA, &readBuffer);

        res = curl_easy_perform(curl);
        if(res != CURLE_OK) {
            std::cerr << "curl_easy_perform() failed: " << curl_easy_strerror(res) << std::endl;
        } else {
            std::cout << "Response: " << readBuffer << std::endl;
        }

        curl_easy_cleanup(curl);
    }
    curl_global_cleanup();
    
    return 0;
}

Lidando com Proxies com libcurl

Para direcionar suas solicitações por meio de um servidor proxy com libcurl:

cpp Copy

#include <iostream>
#include <curl/curl.h>

static size_t WriteCallback(void* contents, size_t size, size_t nmemb, void* userp)
{
    ((std::string*)userp)->append((char*)contents, size * nmemb);
    return size * nmemb;
}

int main() {
    CURL* curl;
    CURLcode res;
    std::string readBuffer;

    curl_global_init(CURL_GLOBAL_DEFAULT);
    curl = curl_easy_init();

    if(curl) {
        curl_easy_setopt(curl, CURLOPT_URL, "https://httpbin.org/ip");
        curl_easy_setopt(curl, CURLOPT_PROXY, "http://proxyserver:8080");
        curl_easy_setopt(curl, CURLOPT_PROXYUSERPWD, "username:password");
        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteCallback);
        curl_easy_setopt(curl, CURLOPT_WRITEDATA, &readBuffer);

        res = curl_easy_perform(curl);
        if(res != CURLE_OK) {
            std::cerr << "curl_easy_perform() failed: " << curl_easy_strerror(res) << std::endl;
        } else {
            std::cout << "Response: " << readBuffer << std::endl;
        }

        curl_easy_cleanup(curl);
    }
    curl_global_cleanup();
    
    return 0;
}

Lidando com Cookies com libcurl

libcurl pode gerenciar cookies habilitando a opção COOKIEFILE:

cpp Copy

#include <iostream>
#include <curl/curl.h>

static size_t WriteCallback(void* contents, size_t size, size_t nmemb, void* userp)
{
    ((std::string*)userp)->append((char*)contents, size * nmemb);
    return size * nmemb;
}

int main() {
    CURL* curl;
    CURLcode res;
    std::string readBuffer;

    curl_global_init(CURL_GLOBAL_DEFAULT);
    curl = curl_easy_init();

    if(curl) {
        curl_easy_setopt(curl, CURLOPT_URL, "https://httpbin.org/cookies/set?name=value");
        curl_easy_setopt(curl, CURLOPT_COOKIEFILE, "");
        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteCallback);
        curl_easy_setopt(curl, CURLOPT_WRITEDATA, &readBuffer);

        res = curl_easy_perform(curl);
        if(res != CURLE_OK) {
            std::cerr << "curl_easy_perform() failed: " << curl_easy_strerror(res) << std::endl;
        } else {
            std::cout << "Response: " << readBuffer << std::endl;
        }

        curl_easy_cleanup(curl);
    }
    curl_global_cleanup();
    
    return 0;
}

Uso avançado: Cabeçalhos personalizados e solicitações POST

Para enviar cabeçalhos personalizados ou realizar uma solicitação POST com libcurl:

cpp Copy

#include <iostream>
#include <curl/curl.h>

static size_t WriteCallback(void* contents, size_t size, size_t nmemb, void* userp)
{
    ((std::string*)userp)->append((char*)contents, size * nmemb);
    return size * nmemb;
}

int main() {
    CURL* curl;
    CURLcode res;
    std::string readBuffer;
    
    curl_global_init(CURL_GLOBAL_DEFAULT);
    curl = curl_easy_init();

    if(curl) {
        struct curl_slist* headers = nullptr;
        headers = curl_slist_append(headers, "User-Agent: Mozilla/5.0");
        headers = curl_slist_append(headers, "Accept-Language: en-US,en;q=0.5");

        curl_easy_setopt(curl, CURLOPT_URL, "https://httpbin.org/post");
        curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
        curl_easy_setopt(curl, CURLOPT_POSTFIELDS, "username=testuser&password=testpass");
        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteCallback);
        curl_easy_setopt(curl, CURLOPT_WRITEDATA, &readBuffer);

        res = curl_easy_perform(curl);
        if(res != CURLE_OK) {
            std::cerr << "curl_easy_perform() failed: " << curl_easy_strerror(res) << std::endl;
        } else {
            std::cout << "Response: " << readBuffer << std::endl;
        }

        curl_slist_free_all(headers);
        curl_easy_cleanup(curl);
    }
    curl_global_cleanup();

    return 0;
}

Exemplo: Resolvendo ReCaptcha V3 com CapSolver e libcurl (C++)

Neste exemplo, demonstraremos como resolver o ReCaptcha V3 usando CapSolver: com a biblioteca libcurl em C++. A API do CapSolver permite uma fácil interação com tarefas do ReCaptcha e recuperação de soluções.

Antes de começar, certifique-se de ter os seguintes pré-requisitos:

libcurl instalado em seu sistema (instale-o via sudo apt-get install libcurl4-openssl-dev no Linux).
Uma chave de API CapSolver (substitua "SuaChave" no código abaixo pela sua chave real).

Aqui está um guia passo a passo para resolver o ReCaptcha V3 usando o CapSolver:

Passo 1: Criando uma tarefa

O primeiro passo é enviar uma solicitação para a API do CapSolver para criar uma tarefa para resolver o ReCaptcha. A tarefa inclui detalhes como o URL do site, a chave do site (da página de destino) e a ação específica da página.

cpp Copy

#include <iostream>
#include <string>
#include <curl/curl.h>
#include <json/json.h>

const std::string CAPSOLVER_KEY = "SuaChave";
const std::string PAGE_URL = "https://antcpt.com/score_detector";
const std::string PAGE_KEY = "6LcR_okUAAAAAPYrPe-HK_0RULO1aZM15ENyM-Mf";
const std::string PAGE_ACTION = "homepage";

static size_t WriteCallback(void* contents, size_t size, size_t nmemb, void* userp) {
    ((std::string*)userp)->append((char*)contents, size * nmemb);
    return size * nmemb;
}

std::string createTask(const std::string& url, const std::string& key, const std::string& action) {
    CURL* curl;
    CURLcode res;
    std::string readBuffer;

    curl = curl_easy_init();
    if (curl) {
        curl_easy_setopt(curl, CURLOPT_URL, "https://api.capsolver.com/createTask");
        curl_easy_setopt(curl, CURLOPT_POST, 1L);

        // JSON payload para criação de tarefa
        Json::Value payload;
        payload["clientKey"] = CAPSOLVER_KEY;
        payload["task"]["type"] = "ReCaptchaV3TaskProxyLess";
        payload["task"]["websiteURL"] = url;
        payload["task"]["websiteKey"] = key;
        payload["task"]["pageAction"] = action;

        Json::StreamWriterBuilder writer;
        std::string requestData = Json::writeString(writer, payload);

        curl_easy_setopt(curl, CURLOPT_POSTFIELDS, requestData.c_str());

        struct curl_slist* headers = nullptr;
        headers = curl_slist_append(headers, "Content-Type: application/json");
        curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteCallback);
        curl_easy_setopt(curl, CURLOPT_WRITEDATA, &readBuffer);

        res = curl_easy_perform(curl);
        curl_slist_free_all(headers);
        curl_easy_cleanup(curl);
    }
    return readBuffer;
}

Esta função envia uma solicitação POST para a API do CapSolver com os detalhes da tarefa necessários e retorna a resposta, que incluirá um taskId.

Passo 2: Recuperando a solução CAPTCHA

Depois que a tarefa for criada, você precisará consultar a API do CapSolver para obter o resultado da tarefa, que contém o token para ignorar o desafio do ReCaptcha.

cpp Copy

std::string getTaskResult(const std::string& taskId) {
    CURL* curl;
    CURLcode res;
    std::string readBuffer;

    curl = curl_easy_init();
    if (curl) {
        curl_easy_setopt(curl, CURLOPT_URL, "https://api.capsolver.com/getTaskResult");
        curl_easy_setopt(curl, CURLOPT_POST, 1L);

        // JSON payload para obter o resultado da tarefa
        Json::Value payload;
        payload["clientKey"] = CAPSOLVER_KEY;
        payload["taskId"] = taskId;

        Json::StreamWriterBuilder writer;
        std::string requestData = Json::writeString(writer, payload);

        curl_easy_setopt(curl, CURLOPT_POSTFIELDS, requestData.c_str());

        struct curl_slist* headers = nullptr;
        headers = curl_slist_append(headers, "Content-Type: application/json");
        curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteCallback);
        curl_easy_setopt(curl, CURLOPT_WRITEDATA, &readBuffer);

        do {
            readBuffer.clear();
            res = curl_easy_perform(curl);
            std::this_thread::sleep_for(std::chrono::seconds(5));
        } while (readBuffer.find("\"status\":\"ready\"") == std::string::npos);

        curl_slist_free_all(headers);
        curl_easy_cleanup(curl);
    }
    return readBuffer;
}

Esta função verifica repetidamente o status da tarefa até que esteja pronta, momento em que retorna a solução do ReCaptcha.

Passo 3: Juntando tudo

Finalmente, aqui está como você pode integrar ambas as funções em seu código principal:

cpp Copy

int main() {
    std::cout << "Criando tarefa CAPTCHA..." << std::endl;
    std::string taskResponse = createTask(PAGE_URL, PAGE_KEY, PAGE_ACTION);

    Json::CharReaderBuilder reader;
    Json::Value jsonResponse;
    std::string errors;
    std::istringstream taskStream(taskResponse);
    std::string taskId;

    if (Json::parseFromStream(reader, taskStream, &jsonResponse, &errors)) {
        taskId = jsonResponse["taskId"].asString();
        std::cout << "ID da tarefa: " << taskId << std::endl;

        std::cout << "Recuperando resultado CAPTCHA..." << std::endl;
        std::string resultResponse = getTaskResult(taskId);

        Json::Value resultJson;
        std::istringstream resultStream(resultResponse);
        Json::parseFromStream(reader, resultStream, &resultJson, &errors);

        std::string token = resultJson["solution"]["gRecaptchaResponse"].asString();
        std::cout << "Solução do Token: " << token << std::endl;
    } else {
        std::cerr << "Erro ao analisar a resposta da tarefa: " << errors << std::endl;
    }

    return 0;
}

Este código irá:

Crie uma tarefa ReCaptcha via CapSolver.
Aguarde a tarefa ser concluída.
Recupere a solução de token ReCaptcha e imprima-a.

Código Bônus

Reivindique seu Código Bônus para as melhores soluções de captcha em CapSolver: scrape. Após resgatá-lo, você receberá um bônus extra de 5% após cada recarga, ilimitadas vezes.

Conclusão

Com libcurl, você pode facilmente lidar com solicitações HTTP em aplicações C++. Integrando-o com o CapSolver, você pode resolver captchas como o ReCaptcha V3 e usar o resultado em suas solicitações.

Ver mais

May 21, 2026

Melhores Solucionadores de CAPTCHA No-Code para Automação de IA em 2026

Descubra o CapSolver, o principal solucionador de CAPTCHA sem código para automação de IA em 2026, para simplificar fluxos de trabalho e melhorar a coleta de dados sem programação. Conheça seus principais recursos, benefícios e uso ético.

Adélia Cruz

May 21, 2026

Como os Navegadores Agêntes Resolvem CAPTCHAS: Infraestrutura de Resolução de CAPTCHA com IA

Um guia completo sobre a infraestrutura de resolução de CAPTCHA que impulsiona os navegadores Agentic. Aprenda por que os CAPTCHAs são o principal obstáculo para agentes de IA e como o CapSolver fornece a solução essencial para automação web sem interrupções.

Oct21, 2024

Como usar o libcurl para Web Scraping

Adélia Cruz

Neural Network Developer

Introdução ao libcurl

Recursos:

Suporte multiprotocolo: HTTP, HTTPS, FTP, FTPS, SMTP e muitos outros.
Suporte assíncrono: Através de CURLM para gerenciar várias solicitações ao mesmo tempo.
Tratamento de erros: Fornece mensagens de erro detalhadas e códigos de status.
Autenticação: Suporta básica, digest, NTLM, Negotiate, etc.
Cookies e sessões: Pode gerenciar cookies e informações de sessão facilmente.

Pré-requisitos

Antes de usar libcurl, você deve:

Instale libcurl em seu sistema.
Inclua o cabeçalho curl/curl.h em seu código C++.

Você pode instalar libcurl no Linux com:

bash Copy

sudo apt-get install libcurl4-openssl-dev

Exemplo básico: Fazendo uma solicitação GET

Aqui está como realizar uma simples solicitação GET usando libcurl em C++:

cpp Copy

#include <iostream>
#include <curl/curl.h>

static size_t WriteCallback(void* contents, size_t size, size_t nmemb, void* userp)
{
    ((std::string*)userp)->append((char*)contents, size * nmemb);
    return size * nmemb;
}

int main() {
    CURL* curl;
    CURLcode res;
    std::string readBuffer;

    curl_global_init(CURL_GLOBAL_DEFAULT);
    curl = curl_easy_init();
    
    if(curl) {
        curl_easy_setopt(curl, CURLOPT_URL, "https://httpbin.org/get");
        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteCallback);
        curl_easy_setopt(curl, CURLOPT_WRITEDATA, &readBuffer);

        res = curl_easy_perform(curl);
        if(res != CURLE_OK) {
            std::cerr << "curl_easy_perform() failed: " << curl_easy_strerror(res) << std::endl;
        } else {
            std::cout << "Response: " << readBuffer << std::endl;
        }

        curl_easy_cleanup(curl);
    }
    curl_global_cleanup();
    
    return 0;
}

Exemplo de Web Scraping: Obtendo dados JSON de uma API

Aqui está um exemplo onde obtemos dados de uma API e imprimimos os resultados:

cpp Copy

#include <iostream>
#include <curl/curl.h>

static size_t WriteCallback(void* contents, size_t size, size_t nmemb, void* userp)
{
    ((std::string*)userp)->append((char*)contents, size * nmemb);
    return size * nmemb;
}

int main() {
    CURL* curl;
    CURLcode res;
    std::string readBuffer;

    curl_global_init(CURL_GLOBAL_DEFAULT);
    curl = curl_easy_init();

    if(curl) {
        curl_easy_setopt(curl, CURLOPT_URL, "https://jsonplaceholder.typicode.com/posts");
        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteCallback);
        curl_easy_setopt(curl, CURLOPT_WRITEDATA, &readBuffer);

        res = curl_easy_perform(curl);
        if(res != CURLE_OK) {
            std::cerr << "curl_easy_perform() failed: " << curl_easy_strerror(res) << std::endl;
        } else {
            std::cout << "Response: " << readBuffer << std::endl;
        }

        curl_easy_cleanup(curl);
    }
    curl_global_cleanup();
    
    return 0;
}

Lidando com Proxies com libcurl

Para direcionar suas solicitações por meio de um servidor proxy com libcurl:

cpp Copy

#include <iostream>
#include <curl/curl.h>

static size_t WriteCallback(void* contents, size_t size, size_t nmemb, void* userp)
{
    ((std::string*)userp)->append((char*)contents, size * nmemb);
    return size * nmemb;
}

int main() {
    CURL* curl;
    CURLcode res;
    std::string readBuffer;

    curl_global_init(CURL_GLOBAL_DEFAULT);
    curl = curl_easy_init();

    if(curl) {
        curl_easy_setopt(curl, CURLOPT_URL, "https://httpbin.org/ip");
        curl_easy_setopt(curl, CURLOPT_PROXY, "http://proxyserver:8080");
        curl_easy_setopt(curl, CURLOPT_PROXYUSERPWD, "username:password");
        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteCallback);
        curl_easy_setopt(curl, CURLOPT_WRITEDATA, &readBuffer);

        res = curl_easy_perform(curl);
        if(res != CURLE_OK) {
            std::cerr << "curl_easy_perform() failed: " << curl_easy_strerror(res) << std::endl;
        } else {
            std::cout << "Response: " << readBuffer << std::endl;
        }

        curl_easy_cleanup(curl);
    }
    curl_global_cleanup();
    
    return 0;
}

Lidando com Cookies com libcurl

libcurl pode gerenciar cookies habilitando a opção COOKIEFILE:

cpp Copy

#include <iostream>
#include <curl/curl.h>

static size_t WriteCallback(void* contents, size_t size, size_t nmemb, void* userp)
{
    ((std::string*)userp)->append((char*)contents, size * nmemb);
    return size * nmemb;
}

int main() {
    CURL* curl;
    CURLcode res;
    std::string readBuffer;

    curl_global_init(CURL_GLOBAL_DEFAULT);
    curl = curl_easy_init();

    if(curl) {
        curl_easy_setopt(curl, CURLOPT_URL, "https://httpbin.org/cookies/set?name=value");
        curl_easy_setopt(curl, CURLOPT_COOKIEFILE, "");
        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteCallback);
        curl_easy_setopt(curl, CURLOPT_WRITEDATA, &readBuffer);

        res = curl_easy_perform(curl);
        if(res != CURLE_OK) {
            std::cerr << "curl_easy_perform() failed: " << curl_easy_strerror(res) << std::endl;
        } else {
            std::cout << "Response: " << readBuffer << std::endl;
        }

        curl_easy_cleanup(curl);
    }
    curl_global_cleanup();
    
    return 0;
}

Uso avançado: Cabeçalhos personalizados e solicitações POST

Para enviar cabeçalhos personalizados ou realizar uma solicitação POST com libcurl:

cpp Copy

#include <iostream>
#include <curl/curl.h>

static size_t WriteCallback(void* contents, size_t size, size_t nmemb, void* userp)
{
    ((std::string*)userp)->append((char*)contents, size * nmemb);
    return size * nmemb;
}

int main() {
    CURL* curl;
    CURLcode res;
    std::string readBuffer;
    
    curl_global_init(CURL_GLOBAL_DEFAULT);
    curl = curl_easy_init();

    if(curl) {
        struct curl_slist* headers = nullptr;
        headers = curl_slist_append(headers, "User-Agent: Mozilla/5.0");
        headers = curl_slist_append(headers, "Accept-Language: en-US,en;q=0.5");

        curl_easy_setopt(curl, CURLOPT_URL, "https://httpbin.org/post");
        curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
        curl_easy_setopt(curl, CURLOPT_POSTFIELDS, "username=testuser&password=testpass");
        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteCallback);
        curl_easy_setopt(curl, CURLOPT_WRITEDATA, &readBuffer);

        res = curl_easy_perform(curl);
        if(res != CURLE_OK) {
            std::cerr << "curl_easy_perform() failed: " << curl_easy_strerror(res) << std::endl;
        } else {
            std::cout << "Response: " << readBuffer << std::endl;
        }

        curl_slist_free_all(headers);
        curl_easy_cleanup(curl);
    }
    curl_global_cleanup();

    return 0;
}

Exemplo: Resolvendo ReCaptcha V3 com CapSolver e libcurl (C++)

Antes de começar, certifique-se de ter os seguintes pré-requisitos:

libcurl instalado em seu sistema (instale-o via sudo apt-get install libcurl4-openssl-dev no Linux).
Uma chave de API CapSolver (substitua "SuaChave" no código abaixo pela sua chave real).

Aqui está um guia passo a passo para resolver o ReCaptcha V3 usando o CapSolver:

Passo 1: Criando uma tarefa

cpp Copy

#include <iostream>
#include <string>
#include <curl/curl.h>
#include <json/json.h>

const std::string CAPSOLVER_KEY = "SuaChave";
const std::string PAGE_URL = "https://antcpt.com/score_detector";
const std::string PAGE_KEY = "6LcR_okUAAAAAPYrPe-HK_0RULO1aZM15ENyM-Mf";
const std::string PAGE_ACTION = "homepage";

static size_t WriteCallback(void* contents, size_t size, size_t nmemb, void* userp) {
    ((std::string*)userp)->append((char*)contents, size * nmemb);
    return size * nmemb;
}

std::string createTask(const std::string& url, const std::string& key, const std::string& action) {
    CURL* curl;
    CURLcode res;
    std::string readBuffer;

    curl = curl_easy_init();
    if (curl) {
        curl_easy_setopt(curl, CURLOPT_URL, "https://api.capsolver.com/createTask");
        curl_easy_setopt(curl, CURLOPT_POST, 1L);

        // JSON payload para criação de tarefa
        Json::Value payload;
        payload["clientKey"] = CAPSOLVER_KEY;
        payload["task"]["type"] = "ReCaptchaV3TaskProxyLess";
        payload["task"]["websiteURL"] = url;
        payload["task"]["websiteKey"] = key;
        payload["task"]["pageAction"] = action;

        Json::StreamWriterBuilder writer;
        std::string requestData = Json::writeString(writer, payload);

        curl_easy_setopt(curl, CURLOPT_POSTFIELDS, requestData.c_str());

        struct curl_slist* headers = nullptr;
        headers = curl_slist_append(headers, "Content-Type: application/json");
        curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteCallback);
        curl_easy_setopt(curl, CURLOPT_WRITEDATA, &readBuffer);

        res = curl_easy_perform(curl);
        curl_slist_free_all(headers);
        curl_easy_cleanup(curl);
    }
    return readBuffer;
}

Esta função envia uma solicitação POST para a API do CapSolver com os detalhes da tarefa necessários e retorna a resposta, que incluirá um taskId.

Passo 2: Recuperando a solução CAPTCHA

Depois que a tarefa for criada, você precisará consultar a API do CapSolver para obter o resultado da tarefa, que contém o token para ignorar o desafio do ReCaptcha.

cpp Copy

std::string getTaskResult(const std::string& taskId) {
    CURL* curl;
    CURLcode res;
    std::string readBuffer;

    curl = curl_easy_init();
    if (curl) {
        curl_easy_setopt(curl, CURLOPT_URL, "https://api.capsolver.com/getTaskResult");
        curl_easy_setopt(curl, CURLOPT_POST, 1L);

        // JSON payload para obter o resultado da tarefa
        Json::Value payload;
        payload["clientKey"] = CAPSOLVER_KEY;
        payload["taskId"] = taskId;

        Json::StreamWriterBuilder writer;
        std::string requestData = Json::writeString(writer, payload);

        curl_easy_setopt(curl, CURLOPT_POSTFIELDS, requestData.c_str());

        struct curl_slist* headers = nullptr;
        headers = curl_slist_append(headers, "Content-Type: application/json");
        curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteCallback);
        curl_easy_setopt(curl, CURLOPT_WRITEDATA, &readBuffer);

        do {
            readBuffer.clear();
            res = curl_easy_perform(curl);
            std::this_thread::sleep_for(std::chrono::seconds(5));
        } while (readBuffer.find("\"status\":\"ready\"") == std::string::npos);

        curl_slist_free_all(headers);
        curl_easy_cleanup(curl);
    }
    return readBuffer;
}

Esta função verifica repetidamente o status da tarefa até que esteja pronta, momento em que retorna a solução do ReCaptcha.

Passo 3: Juntando tudo

Finalmente, aqui está como você pode integrar ambas as funções em seu código principal:

cpp Copy

int main() {
    std::cout << "Criando tarefa CAPTCHA..." << std::endl;
    std::string taskResponse = createTask(PAGE_URL, PAGE_KEY, PAGE_ACTION);

    Json::CharReaderBuilder reader;
    Json::Value jsonResponse;
    std::string errors;
    std::istringstream taskStream(taskResponse);
    std::string taskId;

    if (Json::parseFromStream(reader, taskStream, &jsonResponse, &errors)) {
        taskId = jsonResponse["taskId"].asString();
        std::cout << "ID da tarefa: " << taskId << std::endl;

        std::cout << "Recuperando resultado CAPTCHA..." << std::endl;
        std::string resultResponse = getTaskResult(taskId);

        Json::Value resultJson;
        std::istringstream resultStream(resultResponse);
        Json::parseFromStream(reader, resultStream, &resultJson, &errors);

        std::string token = resultJson["solution"]["gRecaptchaResponse"].asString();
        std::cout << "Solução do Token: " << token << std::endl;
    } else {
        std::cerr << "Erro ao analisar a resposta da tarefa: " << errors << std::endl;
    }

    return 0;
}

Este código irá:

Crie uma tarefa ReCaptcha via CapSolver.
Aguarde a tarefa ser concluída.
Recupere a solução de token ReCaptcha e imprima-a.

Código Bônus

Reivindique seu Código Bônus para as melhores soluções de captcha em CapSolver: scrape. Após resgatá-lo, você receberá um bônus extra de 5% após cada recarga, ilimitadas vezes.

Conclusão

Ver mais

May 21, 2026

Melhores Solucionadores de CAPTCHA No-Code para Automação de IA em 2026

Adélia Cruz

May 21, 2026

Como usar o libcurl para Web Scraping

Introdução ao libcurl

Pré-requisitos

Exemplo básico: Fazendo uma solicitação GET

Exemplo de Web Scraping: Obtendo dados JSON de uma API

Lidando com Proxies com libcurl

Lidando com Cookies com libcurl

Uso avançado: Cabeçalhos personalizados e solicitações POST

Exemplo: Resolvendo ReCaptcha V3 com CapSolver e libcurl (C++)

Passo 1: Criando uma tarefa

Passo 2: Recuperando a solução CAPTCHA

Passo 3: Juntando tudo

Código Bônus

Conclusão

Ver mais

Melhores Solucionadores de CAPTCHA No-Code para Automação de IA em 2026

Como os Navegadores Agêntes Resolvem CAPTCHAS: Infraestrutura de Resolução de CAPTCHA com IA

Como usar o libcurl para Web Scraping

Introdução ao libcurl

Pré-requisitos

Exemplo básico: Fazendo uma solicitação GET

Exemplo de Web Scraping: Obtendo dados JSON de uma API

Lidando com Proxies com libcurl

Lidando com Cookies com libcurl

Uso avançado: Cabeçalhos personalizados e solicitações POST

Exemplo: Resolvendo ReCaptcha V3 com CapSolver e libcurl (C++)

Passo 1: Criando uma tarefa

Passo 2: Recuperando a solução CAPTCHA

Passo 3: Juntando tudo

Código Bônus

Conclusão

Ver mais

Melhores Solucionadores de CAPTCHA No-Code para Automação de IA em 2026

Como os Navegadores Agêntes Resolvem CAPTCHAS: Infraestrutura de Resolução de CAPTCHA com IA

Navegador Autônomo: Quando o Navegador Começa a Trabalhar Proativamente para Você

Como Implementar uma API de Resolução de CAPTCHA em JavaScript