Cómo usar libcurl para Web Scraping

Blog

All

Blog

All

Cómo usar libcurl para Web Scraping

Aloísio Vítor

Image Processing Expert

22-Oct-2024

El web scraping es una poderosa técnica para extraer datos de sitios web, permitiendo la automatización de tareas como la recopilación de información de precios, el seguimiento de actualizaciones de contenido o la recopilación de grandes conjuntos de datos. Una de las bibliotecas más populares para realizar web scraping en C++ es libcurl, una biblioteca gratuita y de código abierto para transferencias de URL del lado cliente. Soporta múltiples protocolos como HTTP, HTTPS, FTP y más, lo que la convierte en una opción ideal para recuperar contenido web.

Introducción a libcurl

libcurl es una potente biblioteca C para realizar peticiones HTTP, que admite diversos protocolos como HTTP, HTTPS, FTP y muchos más. Es una herramienta flexible que se utiliza ampliamente en aplicaciones C++ para realizar peticiones web.

Características:

Soporte multiprotocolo: HTTP, HTTPS, FTP, FTPS, SMTP y muchos otros.
Soporte asíncrono: A través de CURLM para gestionar múltiples peticiones a la vez.
Manejo de errores: Proporciona mensajes de error detallados y códigos de estado.
Autenticación: Admite básica, digest, NTLM, Negotiate, etc.
Cookies y sesiones: Puede gestionar cookies e información de sesión fácilmente.

Requisitos previos

Antes de utilizar libcurl, debes:

Instalar libcurl en tu sistema.
Incluir el encabezado curl/curl.h en tu código C++.

Puedes instalar libcurl en Linux con:

bash Copy

sudo apt-get install libcurl4-openssl-dev

Ejemplo básico: Realizar una petición GET

Aquí tienes cómo realizar una simple petición GET utilizando libcurl en 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;
}

Ejemplo de web scraping: Obtener datos JSON de una API

Aquí tienes un ejemplo en el que obtenemos datos de una API e imprimimos los 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;
}

Manejar proxys con libcurl

Para enrutar tus peticiones a través de un servidor proxy con 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;
}

Manejar cookies con libcurl

libcurl puede gestionar cookies activando la opción 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 avanzado: Encabezados personalizados y peticiones POST

Para enviar encabezados personalizados o realizar una petición POST con 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;
}

Ejemplo: Resolver ReCaptcha V3 con CapSolver y libcurl (C++)

En este ejemplo, demostraremos cómo resolver ReCaptcha V3 utilizando CapSolver: con la biblioteca libcurl en C++. La API de CapSolver permite una fácil interacción con las tareas de ReCaptcha y la recuperación de soluciones.

Antes de empezar, asegúrate de que tienes los siguientes requisitos previos:

libcurl instalado en tu sistema (instálalo a través de sudo apt-get install libcurl4-openssl-dev en Linux).
Una clave de API de CapSolver (reemplaza "YourKey" en el código siguiente con tu clave real).

Aquí tienes una guía paso a paso para resolver ReCaptcha V3 utilizando CapSolver:

Paso 1: Creando una tarea

El primer paso es enviar una petición a la API de CapSolver para crear una tarea para resolver ReCaptcha. La tarea incluye detalles como la URL del sitio web, la clave del sitio (de la página de destino) y la acción específica de la página.

cpp Copy

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

const std::string CAPSOLVER_KEY = "YourKey";
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 for task creation
        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 función envía una petición POST a la API de CapSolver con los detalles necesarios de la tarea y devuelve la respuesta, que incluirá un taskId.

Paso 2: Recuperando la solución CAPTCHA

Una vez que la tarea se ha creado, tendrás que consultar la API de CapSolver para obtener el resultado de la tarea, que contiene el token para evitar el desafío de 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 to get the task result
        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 función comprueba repetidamente el estado de la tarea hasta que está lista, momento en el que devuelve la solución de ReCaptcha.

Paso 3: Juntándolo todo

Finalmente, aquí tienes cómo puedes integrar ambas funciones en tu código principal:

cpp Copy

int main() {
    std::cout << "Creating CAPTCHA task..." << 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 << "Task ID: " << taskId << std::endl;

        std::cout << "Retrieving CAPTCHA result..." << 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 << "Token Solution: " << token << std::endl;
    } else {
        std::cerr << "Error parsing task response: " << errors << std::endl;
    }

    return 0;
}

Este código:

Crea una tarea de ReCaptcha a través de CapSolver.
Espera a que la tarea se complete.
Recupera la solución del token de ReCaptcha e imprímela.

Código extra

Reclama tu Código Extra para las mejores soluciones de captcha en CapSolver: scrape. Después de canjearlo, obtendrás un 5% de bonificación adicional después de cada recarga, de forma ilimitada.

Conclusión

Con libcurl, puedes manejar fácilmente las peticiones HTTP en aplicaciones C++. Integrándolo con CapSolver, puedes resolver captchas como ReCaptcha V3 y utilizar el resultado en tus peticiones.

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

Cómo empezar con el Web Scraping en R: Una guía completa para 2025

Aprende a extraer datos con R, configura tu entorno, maneja contenido dinámico y sigue las mejores prácticas para la extracción ética de datos.

Aloísio Vítor

26-Nov-2024

Cómo resolver Cloudflare en PHP

Explore cómo resolver eficazmente las defensas de Cloudflare usando PHP. Compararemos dos soluciones: herramientas de automatización como Selenium Stealth y soluciones basadas en API.

Adélia Cruz

26-Nov-2024

Web scraping con Botright y Python en 2024

Web Scraping con Botright y Python en 2025

Aprende a integrar CapSolver con Botright utilizando la extensión de navegador CapSolver para resolver CAPTCHAs de forma eficiente durante el raspado web. Esta guía completa abarca la configuración de Botright, la creación de raspadores básicos y la automatización de la resolución de CAPTCHA para la extracción de datos sin interrupciones.

Anh Tuan

14-Nov-2024

Cómo resolver los desafíos de web scraping con Scrapy y Playwright en 2025

Cómo resolver los desafíos del scraping web con Scrapy y Playwright en 2025

Aprende a superar los desafíos del web scraping en 2025 con Scrapy y Playwright. Esta guía completa explora la integración de Scrapy-Playwright con CapSolver para manejar eficazmente el contenido dinámico y los captchas, asegurando una extracción de datos eficiente y confiable.

Ethan Collins

12-Nov-2024

Resolviendo reCAPTCHA con Reconocimiento de IA en 2025

Explorar cómo la IA está transformando la resolución de reCAPTCHA, las soluciones de CapSolver y el panorama cambiante de la seguridad CAPTCHA en 2025.

reCAPTCHA

Adélia Cruz

11-Nov-2024

Cómo resolver Cloudflare usando Python y Go en 2025

Cómo resolver Cloudflare utilizando Python y Go en 2025

Compartiré información sobre qué es Cloudflare Turnstile, utilizando Python y Go para estas tareas, si Turnstile puede detectar raspadores Python y cómo evitarlo eficazmente utilizando soluciones como CapSolver.

Cloudflare

Aloísio Vítor

05-Nov-2024