CAPSOLVER
Blog
All
Como usar libcurl para Web Scraping

Como usar o libcurl para Web Scraping

Logo of CapSolver

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á:

  1. Crie uma tarefa ReCaptcha via CapSolver.
  2. Aguarde a tarefa ser concluída.
  3. 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.

CapSolver Bônus

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

melhor extensão para resolver CAPTCHA 2026
Qual é a melhor extensão para resolver CAPTCHA 2026?

No mundo em constante evolução da segurança online, os desafios CAPTCHA tornaram-se uma barreira comum para os usuários da internet...

Extension
Logo of CapSolver

Sora Fujimoto

12-Dec-2025

Lumiproxy
Lumiproxy: Proxy Premium para Scraping de Web e Coleta de Dados

Neste artigo, mostraremos o que é Lumiproxy e os serviços que eles oferecem.

web scraping
Logo of CapSolver

Ethan Collins

12-Dec-2025

Genlogin
Genlogin: Revolutionar sua experiência de automação da web

Neste artigo, vamos mostrar para você o que é o Genlogin e os serviços que eles oferecem.

Partners
Logo of CapSolver

Rajinder Singh

12-Dec-2025

ProxysIO
Proxys.io: Proxies individuais para qualquer tarefa

Neste artigo, vamos mostrar para você o que é o Proxys.io e os serviços que eles oferecem.

Partners
Logo of CapSolver

Rajinder Singh

12-Dec-2025

Aba Proxy
Tabproxy: Bom custo proxy residencial internacional

Neste artigo, vamos mostrar para você o que é o Tabproxy e os serviços que eles oferecem.

web scraping
Logo of CapSolver

Ethan Collins

12-Dec-2025

erros de raspagem de web
O que são erros 402, 403, 404 e 429 em raspagem de web? Um Guia Completo

Domine o tratamento de erros de raspagem de web entendendo o que são os erros 402, 403, 404 e 429. Aprenda a corrigir o erro 403 Proibido, implementar soluções para o erro de limitação de taxa 429 e tratar o código de status Payment Required emergente 402.

web scraping
Logo of CapSolver

Lucas Mitchell

12-Dec-2025