Como usar libcurl para Web Scraping

Como usar o libcurl para Web Scraping

Adélia Cruz

Neural Network Developer

22-Oct-2024

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.

Declaração de Conformidade: As informações fornecidas neste blog são apenas para fins informativos. A CapSolver está comprometida em cumprir todas as leis e regulamentos aplicáveis. O uso da rede CapSolver para atividades ilegais, fraudulentas ou abusivas é estritamente proibido e será investigado. Nossas soluções de resolução de captcha melhoram a experiência do usuário enquanto garantem 100% de conformidade ao ajudar a resolver dificuldades de captcha durante a coleta de dados públicos. Incentivamos o uso responsável de nossos serviços. Para mais informações, visite nossos Termos de Serviço e Política de Privacidade.

Mais

Erro do Cloudflare 1006, 1007, 1008 Solução para Resolver | Como Corrigir

Lidando com erros do Cloudflare 1006, 1007 ou 1008? Aprenda soluções práticas para resolver esses bloqueios de acesso e melhorar sua experiência de crawling na web.

Cloudflare

Anh Tuan

05-Dec-2025

Como resolver captchas ao fazer web scraping com Scrapling e CapSolver

Como resolver captchas ao realizar web scraping com o Scrapling e o CapSolver

Scrapling + CapSolver permite raspagem automatizada com ReCaptcha v2/v3 e Cloudflare Turnstile bypass.

web scraping

Aloísio Vítor

05-Dec-2025

Alterar o User-Agent no Selenium | Passos & Boas Práticas

Alterar o Agente de Usuário no Selenium é um passo crucial para muitas tarefas de raspagem da web. Ajuda a disfarçar o script de automação como um navegador regular...

The other captcha

Emma Foster

05-Dec-2025

Como identificar se `action` é necessário para resolver o Cloudflare Turnstile usando a extensão CapSolver

Aprenda a identificar ações para resolução eficaz de captchas cloudflare turnstile. Siga nosso guia passo a passo sobre o uso das ferramentas e técnicas do Capsolver.

Cloudflare

Aloísio Vítor

05-Dec-2025

Descubra o Poder do 9Proxy: Uma Revisão Abrangente

Neste artigo, vamos mostrar a você o que é 9proxy e os serviços que eles oferecem.

Partners

Ethan Collins

04-Dec-2025

Web Scraping com Selenium e Python | Resolvendo Captcha Ao Fazer Web Scraping

Neste artigo, você vai se familiarizar com a raspagem de dados da web usando o Selenium e o Python, e aprender a resolver o Captcha envolvido no processo para uma extração de dados eficiente.

web scraping

Anh Tuan

04-Dec-2025