Manejar bloqueos de Cloudflare: guía de acceso legítimo

Cómo funciona la detección de nubes

Cloudflare es el servicio antibot más desplegado, protegiendo más del 20% de todos los sitios web. Comprender cómo detecta tráfico automatizado es esencial para cualquier persona que construye herramientas legítimas de raspado. Cloudflare utiliza una tubería de detección multicapa:

1. Anotación de reputación IP: Cloudflare mantiene una base de datos de inteligencia de amenaza global. Los IPs del centro de datos, los rangos de VPN conocidos y las direcciones previamente marcadas reciben mayores puntajes de riesgo.
2. TLS huella dactilar: Cloudflare analiza Mensajes TLS ClientHello para determinar si el cliente de conexión coincide con su identidad reclamada.
3. Huellas del navegador: Sonda de desafíos de JavaScript lienzo, WebGL, propiedades del navegadorY docenas de otras señales.
4. Problemas de JavaScript: Cloudflare sirve JavaScript que debe ejecutar correctamente en un entorno de navegador real.
5. Análisis conductual: Solicitar tiempo, patrones de navegación, movimientos del ratón y señales de interacción se analizan.
6. Modelos de aprendizaje automático: Todas las señales se introducen en modelos ML que se adaptan continuamente a nuevos patrones de automatización.

Para una visión más amplia, vea nuestra Guía integral para sistemas de detección antibots.

Teclados de protección de nubes

Marco ético para acceder a sitios protegidos por la nube

Antes de aplicar cualquier enfoque técnico, establecer límites éticos claros:

• Chequee primero para APIs: Muchos sitios protegidos por Cloudflare ofrecen API oficiales para el acceso a datos. Siempre prefiera esto.
• Respetar robots.txt: Si el sitio se desvía explícitamente raspando caminos específicos, honrar esas directivas.
• Términos de servicio: Entender lo que el sitio permite respecto al acceso automatizado.
• Acceso sólo a datos públicos: Nunca intentes evitar la autenticación o acceder a datos privados.
• Minimizar el impacto del servidor: Utilice tarifas de solicitud razonables y no sobrecargue el servidor de destino.
• Considerar la concesión de licencias de datos: Para casos de uso comercial, explore acuerdos de licencias de datos.

Las técnicas de esta guía están diseñadas para el acceso legítimo a los datos disponibles públicamente. Nunca deben utilizarse para evitar las protecciones de seguridad para el acceso no autorizado, el robo credencial o los ataques de denegación de servicio.

Estrategia 1: Proxies residenciales con IPs limpias

El primer paso más eficaz es asegurar que sus direcciones IP tengan reputación limpia. La puntuación IP de Cloudflare penaliza fuertemente al centro de datos y a los IP VPN.

# Python: Using residential proxies for Cloudflare-protected sites
from curl_cffi import requests as curl_requests
response = curl_requests.get(
    "https://cloudflare-protected-site.com",
    impersonate="chrome",
    proxies={
        "http": "http://USERNAME:PASSWORD@gate.proxyhat.com:8080",
        "https": "http://USERNAME:PASSWORD@gate.proxyhat.com:8080"
    },
    timeout=30
)
if response.status_code == 200:
    print("Access granted")
elif response.status_code == 403:
    print("Blocked — may need additional measures")
elif response.status_code == 503:
    print("Cloudflare challenge page — need browser execution")

Los proxies residenciales de ProxyHat proporcionar IPs clasificadas como auténticas direcciones residenciales en la base de datos de Cloudflare, superando la capa de reputación IP. Vea nuestro comparación de proxies residenciales vs VPNs por qué VPN IPs fallan contra Cloudflare.

Estrategia 2: Huellas de marcadores TLS de Browser-Grade

Controles de Cloudflare JA3/JA4 TLS huellas dactilares para identificar al cliente de conexión. Python requests biblioteca, Go's net/http, y los clientes predeterminados de Node.js todos producen firmas TLS no-browser que Cloudflare banderas.

Estrategia 3: Manejo de desafíos JavaScript

Los desafíos de JavaScript de Cloudflare requieren un entorno de navegador real para resolver. Existen dos enfoques:

Enfoque A: Navegador sin cabeza

// Node.js: Playwright with stealth for Cloudflare challenges
const { chromium } = require('playwright');
async function accessCloudflare(url) {
  const browser = await chromium.launch({
    proxy: {
      server: 'http://gate.proxyhat.com:8080',
      username: 'USERNAME',
      password: 'PASSWORD'
    }
  });
  const context = await browser.newContext({
    locale: 'en-US',
    timezoneId: 'America/New_York',
    viewport: { width: 1920, height: 1080 }
  });
  const page = await context.newPage();
  // Navigate and wait for Cloudflare challenge to resolve
  await page.goto(url, { waitUntil: 'networkidle', timeout: 60000 });
  // Cloudflare challenges typically redirect after completion
  // Wait for the actual content to load
  await page.waitForSelector('body', { timeout: 30000 });
  // Check if we passed the challenge
  const title = await page.title();
  if (title.includes('Just a moment') || title.includes('Attention Required')) {
    // Challenge not yet resolved — wait longer
    await page.waitForNavigation({ waitUntil: 'networkidle', timeout: 30000 });
  }
  const content = await page.content();
  await browser.close();
  return content;
}

Enfoque B: Extracción y Reutilización de cookies

Resolver el desafío una vez en un navegador sin cabeza, extraer las cookies (especialmente cf_clearance), luego reutilizarlos en un cliente HTTP ligero:

// Node.js: Extract Cloudflare cookies for reuse
const { chromium } = require('playwright');
async function extractCfCookies(url) {
  const browser = await chromium.launch({
    proxy: {
      server: 'http://gate.proxyhat.com:8080',
      username: 'USERNAME-session-cf1',
      password: 'PASSWORD'
    }
  });
  const context = await browser.newContext({
    locale: 'en-US',
    timezoneId: 'America/New_York',
  });
  const page = await context.newPage();
  await page.goto(url, { waitUntil: 'networkidle', timeout: 60000 });
  // Wait for challenge resolution
  await page.waitForTimeout(10000);
  // Extract cookies
  const cookies = await context.cookies();
  const cfClearance = cookies.find(c => c.name === 'cf_clearance');
  const userAgent = await page.evaluate(() => navigator.userAgent);
  await browser.close();
  return { cookies, userAgent, cfClearance };
}
// Reuse cookies with got-scraping (same proxy session!)
import { gotScraping } from 'got-scraping';
const { cookies, userAgent } = await extractCfCookies('https://example.com');
const cookieString = cookies.map(c => `${c.name}=${c.value}`).join('; ');
const response = await gotScraping({
  url: 'https://example.com/api/data',
  proxyUrl: 'http://USERNAME-session-cf1:PASSWORD@gate.proxyhat.com:8080',
  headers: {
    'Cookie': cookieString,
    'User-Agent': userAgent,  // Must match the browser that solved the challenge
  }
});

Importante: El cf_clearance cookie está vinculada a la dirección IP y el agente de usuario que resolvió el desafío. Debe utilizar la misma sesión de proxy (PI pegajosa) y el mismo agente de usuario al reutilizarla.

Estrategia 4: Solicitar optimización del patrón

El análisis conductual de Cloudflare marca patrones de solicitud no humanos. Siga estos patrones para el acceso legítimo:

Flujo de navegación realista

# Python: Realistic navigation pattern
from curl_cffi import requests as curl_requests
import time
import random
session = curl_requests.Session(impersonate="chrome")
session.proxies = {
    "http": "http://USERNAME:PASSWORD@gate.proxyhat.com:8080",
    "https": "http://USERNAME:PASSWORD@gate.proxyhat.com:8080"
}
# Step 1: Visit homepage first
home = session.get("https://example.com")
time.sleep(random.uniform(2.0, 4.0))
# Step 2: Navigate to category (with Referer)
category = session.get(
    "https://example.com/products",
    headers={"Referer": "https://example.com"}
)
time.sleep(random.uniform(1.5, 3.5))
# Step 3: Browse items (with proper Referer chain)
for item_url in item_urls[:20]:
    item = session.get(
        item_url,
        headers={"Referer": "https://example.com/products"}
    )
    time.sleep(random.uniform(1.0, 3.0))

Directrices de limitación de la tasa

Estrategia 5: Manejo de respuestas comunes a la nube

# Python: Response handling with retry logic
import time
import random
def cloudflare_resilient_request(session, url, max_retries=3):
    for attempt in range(max_retries):
        try:
            response = session.get(url, timeout=30)
            if response.status_code == 200:
                return response
            if response.status_code == 403:
                # IP flagged — rotate session
                print(f"403 on attempt {attempt + 1} — rotating IP")
                session = create_new_session()
                time.sleep(random.uniform(5, 10))
                continue
            if response.status_code == 429:
                # Rate limited — exponential backoff
                wait = (2 ** attempt) * 5 + random.uniform(0, 5)
                print(f"429 — waiting {wait:.1f}s")
                time.sleep(wait)
                continue
            if response.status_code == 503:
                # JS challenge — need headless browser
                print("503 — JavaScript challenge detected")
                return None  # Escalate to browser-based approach
        except Exception as e:
            print(f"Error: {e}")
            time.sleep(random.uniform(2, 5))
    return None

Enfoque completo de múltiples capas

La estrategia más fiable combina todas las capas:

1. Proxies residenciales: ProxyHat IPs residenciales para la reputación IP limpia.
2. TLS de grado navegador: curl_cffi o navegador sin cabeza para las huellas correctas.
3. Cabeceras consistentes: El encabezado completo se ajusta al navegador reclamado.
4. Tiempo natural: Retrasos aleatorios siguiendo patrones de navegación humanos.
5. Gestión de cookies: Aceptar y mantener las cookies durante las sesiones.
6. Cadenas de referencia: Flujo de navegación adecuado desde la página principal a las páginas de destino.

Para estrategias integrales de reducción de detección, vea nuestra completa guía antidetección. Para la integración proxy en los idiomas de programación, vea nuestras guías Python, Node.js, y Vamos..

Cuando no para rascar

Reconocer situaciones en las que el raspado no es el enfoque adecuado:

• El sitio tiene una API pública: Utilice siempre API oficiales cuando esté disponible.
• Los datos están detrás de la autenticación: El acceso a los datos protegidos por login mediante el raspado es típicamente una violación de ToS.
• El sitio prohíbe explícitamente el desguace: Respetar las prohibiciones claras en el ToS.
• Se dispone de licencias de datos: Para uso comercial, la compra de licencias de datos es a menudo más fiable y legal.
• El contenido está copyrighted: Rastrear contenido copyrighted para la redistribución plantea preocupaciones legales.

Véase Documentación de ProxyHat para pautas de uso responsables y términos de servicio.

Preguntas frecuentes