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

Error de Cloudflare 1006, 1007, 1008 Solución para resolver | Cómo arreglarlo

¿Tienes problemas con errores de Cloudflare 1006, 1007 o 1008? Aprende soluciones prácticas para resolver estos rechazos de acceso y mejorar tu experiencia de rastreo web.

Cloudflare

Ethan Collins

05-Dec-2025

AI-LLM: La solución del futuro para el control de riesgos, el reconocimiento de imágenes y la resolución de CAPTCHA

IA-MLLE: La Solución del Futuro para el Control de Riesgos, Reconocimiento de Imágenes y Resolución de CAPTCHA

Una exploración profunda de cómo los LLMs reconfiguran la resolución de CAPTCHA gráficos, combinando el razonamiento de cero shots con la precisión de redes neuronales convolucionales para el control de riesgos moderno.

Adélia Cruz

05-Dec-2025

Cómo resolver CAPTCHAs durante el scraping web con Scrapling y CapSolver

Cómo resolver captchas al realizar scraping web con Scrapling y CapSolver

Scrapling + CapSolver permite el scraping automatizado con ReCaptcha v2/v3 y bypass de Cloudflare Turnstile.

web scraping

Ethan Collins

05-Dec-2025

Cambiar el Agente de Usuario en Selenium | Pasos y Mejores Prácticas

Cambiar el Agente de Usuario en Selenium es un paso crucial para muchas tareas de scraping web. Ayuda a disfrazar el script de automatización como un navegador regular...

The other captcha

Adélia Cruz

05-Dec-2025

Cómo identificar si la `action` es requerida para resolver Cloudflare Turnstile usando la extensión CapSolver

Cómo identificar si `action` es necesario para resolver Cloudflare Turnstile usando la extensión de CapSolver

Aprende a identificar la acción para resolver eficazmente el captcha de Cloudflare Turnstile. Sigue nuestra guía paso a paso sobre cómo usar las herramientas y técnicas de Capsolver.

Cloudflare

Adélia Cruz

05-Dec-2025

Descubre el Poder de 9Proxy: Una Revisión Completa

En este artículo, te mostraremos qué es 9proxy y los servicios que ofrecen.

Partners

Emma Foster

04-Dec-2025