Cómo resolver Cloudflare en 2025: Resolver Cloudflare Turnstile y desafío usando CapSolver

Cloudflare ofrece medidas de protección robustas, incluyendo el desafío de Cloudflare y el CAPTCHA Turnstile, para proteger los sitios web contra bots maliciosos y raspadores automatizados. Comprender y superar estos desafíos puede ser crucial para quienes necesitan acceso más allá de estas barreras de protección para fines legítimos.

Entendiendo las medidas de seguridad de Cloudflare

Cloudflare utiliza varias técnicas para detectar y mitigar el tráfico no deseado. Entre ellas se encuentran el desafío de Cloudflare, que a menudo implica pruebas de JavaScript o CAPTCHAS, y Turnstile, un CAPTCHA más amigable para el usuario que minimiza la interacción del usuario. Estos sistemas están diseñados para distinguir eficazmente entre usuarios humanos y bots automatizados.

Estrategias para resolver los desafíos de Cloudflare

1. Navegadores automatizados:

   • Herramientas como Selenium o Puppeteer pueden simular interacciones de usuarios reales. Para enmascarar su naturaleza automatizada, se pueden usar complementos como puppeteer-extra-plugin-stealth para pasar el desafío de Cloudflare al emular el comportamiento de un navegador natural.

2. Proxys de alta calidad:

   • Utilizar proxies residenciales que roten direcciones IP puede ayudar a imitar patrones de acceso de usuarios reales, reduciendo así la probabilidad de ser bloqueado por las medidas de seguridad de Cloudflare.

3. Servicios de resolución de CAPTCHA:

   • Para desafíos / CAPTCHAS que requieren resolución

Guía detallada para resolver el desafío de Cloudflare

Primero, echemos un vistazo a cómo se ve el desafío de Cloudflare:

A veces, esta página podría tener Turnstile

Canjea tu código de bonificación de CapSolver

¡No pierdas la oportunidad de optimizar aún más tus operaciones! Usa el código de bonificación CAPN al recargar tu cuenta de CapSolver y recibe un 5% adicional en cada recarga, sin límites. Visita el Panel de CapSolver para canjear tu bonificación ahora!

Si tienes una página similar donde debes esperar hasta que se complete la verificación y generalmente tiene verificaciones adicionales con Turnstile, entonces es un desafío de Cloudflare.
Hay algunos requisitos para resolver este tipo de desafío:

• Token devuelto en la respuesta del método getTaskResult es el valor de la cookie cf_clearance que necesitarás crear.
• Debes usar el mismo user-agent que devuelve el método getTaskResult
• Debes usar la misma IP de proxy utilizada para resolver el desafío
• Debes usar las cookies de la respuesta
• Debes usar los headers de la respuesta
• Usar la versión TLS de Chrome 120

Ejemplo de cómo resolver la interfaz de 5 segundos de Cloudflare con Python

# -*- coding: utf-8 -*-
import time
import requests
import tls_client

API_KEY = ""  # TODO: tu clave de API
page_url = ''  # TODO: tu URL de página 'https://example.com
proxy = ""  # TODO: tu proxy


def call_capsolver():
    data = {
        "clientKey": API_KEY,
        "task": {
            "type": 'AntiCloudflareTask',
            "websiteURL": page_url,
            "proxy": proxy,
        }
    }
    uri = 'https://api.capsolver.com/createTask'
    res = requests.post(uri, json=data)
    resp = res.json()
    task_id = resp.get('taskId')
    if not task_id:
        print("no se obtuvo taskId:", res.text)
        return
    print('creado taskId:', task_id)

    while True:
        time.sleep(1)
        data = {
            "clientKey": API_KEY,
            "taskId": task_id
        }
        response = requests.post('https://api.capsolver.com/getTaskResult', json=data)
        resp = response.json()
        status = resp.get('status', '')
        if status == "ready":
            print("éxito => ", response.text)
            return resp.get('solution')
        if status == "failed" or resp.get("errorId"):
            print("falló! => ", response.text)
            return


def request_site(solution):
    # TODO si quieres usar tls_client
    session = tls_client.Session(
         client_identifier="chrome_120",
        random_tls_extension_order=True
    )
    return session.get(
        page_url,
        headers=solution.get('headers'),
        cookies=solution.get('cookies'),
        proxy=proxy,
        allow_redirects=True,
    )


def main():
    # primer pedido:
    res = request_site({})
    print('1. código de estado de la respuesta:', res.status_code)
    if res.status_code != 403:
        print("tu proxy es bueno y no recibiste el desafío de Cloudflare")
        return
    elif 'window._cf_chl_opt' not in res.text:
        print('==== proxy bloqueado ==== ')
        return

    # llamar a CapSolver:
    solution = call_capsolver()
    if not solution:
        return

    # segundo pedido (verificar solución):
    res = request_site(solution)
    print('2. código de estado de la respuesta:', res.status_code)
    if res.status_code == 200:
        ##print("2. texto de la respuesta:\n", res.text)
        print("éxito al pasar el desafío de Cloudflare")


if __name__ == '__main__':
    main()

Guía detallada para resolver el CAPTCHA de Turnstile de Cloudflare

Cloudflare ofrece 3 tipos de CAPTCHA de Turnstile de Cloudflare

• Desafío gestionado
  

• Desafío no interactivo
  

• Desafío invisible
  no visible, puedes revisar en la red / scripts cargados y ver si se utiliza Turnstile

El CAPTCHA de Turnstile es el reemplazo de los desafíos tradicionales de CAPTCHA de Cloudflare, enfocándose en la experiencia del usuario y la seguridad. Así es como puedes abordar su resolución:

1. Entender el desafío:

   • El CAPTCHA de Turnstile no siempre aparece visible; a veces, opera en segundo plano, analizando las interacciones del usuario para verificar su autenticidad.

2. Integración de APIs de resolución de CAPTCHA:

   • Algunos servicios de resolución de CAPTCHA han comenzado a ofrecer soluciones para Turnstile analizando el tráfico de red y los patrones de interacción. Utiliza estas APIs para enviar desafíos de Turnstile para su resolución.

3. Mantener la consistencia del navegador:

   • Asegúrate de que tus soluciones automatizadas mantengan firmas de navegador consistentes, ya que Turnstile puede analizarlas para detectar automatización.

4. Adaptarse a desafíos de JavaScript:

   • Cloudflare puede implementar cálculos de JavaScript para probar el entorno del navegador. Herramientas como Puppeteer se pueden programar para resolver estos desafíos dinámicamente ejecutando código JavaScript como lo haría un navegador regular.

Ejemplo de cómo resolver el CAPTCHA de Turnstile de Cloudflare con Python

import time
from curl_cffi import requests

CAPSOLVER_API_KEY = "Tu clave de API de CAPSOLVER.COM"
PAGE_URL = ""
WEBSITE_KEY = ""

def solvecf(metadata_action=None, metadata_cdata=None):
    url = "https://api.capsolver.com/createTask"
    task = {
        "type": "AntiTurnstileTaskProxyLess",
        "websiteURL": PAGE_URL,
        "websiteKey": WEBSITE_KEY,
    }
    if metadata_action or metadata_cdata:
        task["metadata"] = {}
        if metadata_action:
            task["metadata"]["action"] = metadata_action
        if metadata_cdata:
            task["metadata"]["cdata"] = metadata_cdata
    data = {
        "clientKey": CAPSOLVER_API_KEY,
        "task": task
    }
    response_data = requests.post(url, json=data).json()
    print(response_data)
    return response_data['taskId']


def solutionGet(taskId):
    url = "https://api.capsolver.com/getTaskResult"
    status = ""
    while status != "ready":
        data = {"clientKey": CAPSOLVER_API_KEY, "taskId": taskId}
        response_data = requests.post(url, json=data).json()
        print(response_data)
        status = response_data.get('status', '')
        print(status)
        if status == "ready":
            return response_data['solution']

        time.sleep(2)


def main():
    start_time = time.time()
    
    taskId = solvecf()
    solution = solutionGet(taskId)
    if solution:
        user_agent = solution['userAgent']
        token = solution['token']

    print("User_Agent:", user_agent)
    print("CAPTCHA de Turnstile resuelto, token:", token)

    end_time = time.time()
    elapsed_time = end_time - start_time
    print(f"Tiempo para resolver el CAPTCHA: {elapsed_time} segundos")

if __name__ == "__main__":
    main()

Ejemplo de cómo resolver el CAPTCHA de Turnstile de Cloudflare con Nodejs

const axios = require('axios');

const CAPSOLVER_API_KEY = "";
const PAGE_URL = "";
const WEBSITE_KEY = "";

async function solvecf(metadata_action = null, metadata_cdata = null) {
    const url = "https://api.capsolver.com/createTask";
    const task = {
        type: "AntiTurnstileTaskProxyLess",
        websiteURL: PAGE_URL,
        websiteKey: WEBSITE_KEY,
    };
    if (metadata_action || metadata_cdata) {
        task.metadata = {};
        if (metadata_action) {
            task.metadata.action = metadata_action;
        }
        if (metadata_cdata) {
            task.metadata.cdata = metadata_cdata;
        }
    }
    const data = {
        clientKey: CAPSOLVER_API_KEY,
        task: task
    };
    const response = await axios.post(url, data);
    console.log(response.data);
    return response.data.taskId;
}

async function solutionGet(taskId) {
    const url = "https://api.capsolver.com/getTaskResult";
    let status = "";
    while (status !== "ready") {
        const data = { clientKey: CAPSOLVER_API_KEY, taskId: taskId };
        const response = await axios.post(url, data);
        console.log(response.data);
        status = response.data.status;
        console.log(status);
        if (status === "ready") {
            return response.data.solution;
        }
        await new Promise(resolve => setTimeout(resolve, 2000));
    }
}

async function main() {
    const start_time = Date.now();
    
    const taskId = await solvecf();
    const solution = await solutionGet(taskId);
    if (solution) {
        const user_agent = solution.userAgent;
        const token = solution.token;

        console.log("User_Agent:", user_agent);
        console.log("CAPTCHA de Turnstile resuelto, token:", token);
    }

    const end_time = Date.now();
    const elapsed_time = (end_time - start_time) / 1000;
    console.log(`Tiempo para resolver el CAPTCHA: ${elapsed_time} segundos`);
}

main().catch(console.error);

Conclusión

Las medidas de seguridad de Cloudflare, incluyendo el desafío y el CAPTCHA Turnstile, están diseñadas para proteger los sitios web contra el acceso automatizado, minimizando al mismo tiempo la fricción para los usuarios legítimos. Para desarrolladores, testers o empresas que requieren acceso automatizado para fines legítimos, entender estos desafíos y usar soluciones robustas es clave.

Combinando proxies de alta calidad, automatización de navegadores con técnicas de stealth y servicios dedicados de resolución de CAPTCHA como CapSolver , puedes evitar confiablemente las protecciones de Cloudflare. Los ejemplos de Python y Node.js proporcionados demuestran cómo integrar CapSolver para manejar tanto los desafíos tradicionales de Cloudflare como los CAPTCHAS de Turnstile de manera eficiente.

Con una implementación adecuada, los flujos de automatización pueden lograr altas tasas de éxito manteniendo la conformidad y minimizando la detección.

Preguntas frecuentes

P1: ¿Cuál es la diferencia entre el desafío de Cloudflare y el CAPTCHA Turnstile?
R1: El desafío de Cloudflare a menudo implica comprobaciones de JavaScript o CAPTCHAS visibles para verificar a los humanos. Turnstile es el nuevo CAPTCHA amigable para el usuario de Cloudflare que puede funcionar en segundo plano, reduciendo la interacción del usuario mientras aún verifica la autenticidad.

P2: ¿Puede resolverse el CAPTCHA Turnstile de forma programática?
R2: Sí. Servicios como CapSolver analizan el tráfico de red e interacciones del usuario para resolver desafíos de Turnstile, ya sea en formas visibles o invisibles.

P3: ¿Necesito rotar proxies al resolver CAPTCHAS de Cloudflare?
R3: Se recomienda altamente utilizar proxies residenciales o de alta calidad con rotación. Cloudflare rastrea el comportamiento de las IP, por lo que el uso consistente de IP reduce el riesgo de bloqueos.

P4: ¿Puedo usar la misma sesión de navegador para múltiples desafíos?
R4: Es mejor mantener la consistencia del navegador por sesión, usando el mismo user-agent, cookies, headers y versión TLS, ya que las discrepancias pueden activar la seguridad de Cloudflare.

P5: ¿Cuán rápido puede resolver CapSolver el CAPTCHA de Turnstile de Cloudflare?
R5: CapSolver suele resolver la mayoría de los desafíos de Cloudflare en unos segundos (a menudo ~5s), dependiendo de las condiciones de red, calidad del proxy y complejidad de la tarea.

P6: ¿Hay bibliotecas oficiales/ejemplos para integrar CapSolver?
R6: Sí, CapSolver proporciona ejemplos oficiales para Python y Node.js, como se muestra en el artículo, cubriendo tanto el desafío de Cloudflare como el CAPTCHA de Turnstile.