Comprendre le cookie cf_clearance de Cloudflare Challenge

Le cookie cf_clearance est le laissez-passer qui prouve à Cloudflare que votre session a franchi un défi. Tant que vous le présentez, vos requêtes traversent le pare-feu sans revoir la page interstitielle ; dès qu'il manque ou expire, vous retombez sur une réponse 403 ou 503. Comprendre comment ce cookie est émis, à quoi il est lié et comment le renouveler est la clé d'une automatisation stable derrière Cloudflare.

Qu'est-ce que le cookie cf_clearance ?

cf_clearance est le cookie que Cloudflare dépose dans le navigateur une fois un défi validé. Il ne contient pas vos données : c'est un jeton opaque, signé côté Cloudflare, qui atteste que le client a passé les vérifications pour ce domaine, pour une durée limitée.

À quoi le cookie est lié

Le piège de la plupart des intégrations : le cookie n'est pas transférable librement. Cloudflare le lie à plusieurs éléments du contexte d'émission.

• Adresse IP — Réutiliser le cookie depuis une autre IP échoue presque toujours ; gardez le même proxy pour la résolution et pour les requêtes.
• User-Agent — L'en-tête User-Agent des requêtes doit être identique à celui utilisé pendant la résolution.
• Empreinte TLS — Certaines configurations lient le cookie au ClientHello TLS.

Règle à retenir : un cookie cf_clearance vaut pour un triplet IP + User-Agent + domaine. Changez l'un des trois, et il en faut un nouveau.

Comment se déroule un défi Cloudflare

Du premier appel jusqu'à l'obtention du cookie, le flux suit toujours les mêmes étapes.

1. L'utilisateur demande une page protégée par Cloudflare
2. Cloudflare évalue les signaux de risque (réputation IP, en-têtes, empreinte TLS)
3. S'il est signalé, Cloudflare renvoie un 403 ou 503 avec une page de défi JavaScript
4. La page de défi exécute des vérifications du navigateur et peut présenter un widget Turnstile
5. En cas de succès, Cloudflare définit cf_clearance et redirige vers l'URL d'origine
6. Les requêtes ultérieures porteuses du cookie passent sans nouveau défi

Un client HTTP simple ne dépasse jamais l'étape 1 : sans exécution du JavaScript de la page interstitielle, aucun cookie n'est émis. D'où la nécessité d'un navigateur complet ou d'un service qui reproduit ces vérifications.

Les trois niveaux de Cloudflare Challenge

Le niveau présenté dépend de la configuration du site et du score de risque de la requête.

CaptchaAI prend en charge les trois niveaux via son solveur Cloudflare Challenge.

Résoudre un Cloudflare Challenge avec CaptchaAI

La logique suit le schéma habituel de l'API CaptchaAI : envoyez la tâche à in.php, récupérez un identifiant, puis interrogez res.php jusqu'au token.

Python

import requests
import time

API_KEY = "YOUR_API_KEY"
TARGET_URL = "https://example.com/protected-page"

# Submit Cloudflare Challenge task
resp = requests.post("https://ocr.captchaai.com/in.php", data={
    "key": API_KEY,
    "method": "turnstile",
    "sitekey": "0x0000000000000000000000",  # may be generic for CF challenge
    "pageurl": TARGET_URL,
    "json": "1",
}).json()

if resp["status"] != 1:
    raise Exception(f"Submit error: {resp['request']}")

task_id = resp["request"]
print(f"Task ID: {task_id}")

# Poll for result
for _ in range(30):
    time.sleep(5)
    result = requests.get("https://ocr.captchaai.com/res.php", params={
        "key": API_KEY, "action": "get", "id": task_id, "json": "1"
    }).json()

    if result["status"] == 1:
        token = result["request"]
        print(f"Token received: {token[:50]}...")
        break
    if result["request"] != "CAPCHA_NOT_READY":
        raise Exception(f"Error: {result['request']}")

JavaScript

const axios = require('axios');

const API_KEY = 'YOUR_API_KEY';
const TARGET_URL = 'https://example.com/protected-page';

const submit = await axios.post('https://ocr.captchaai.com/in.php', null, {
  params: {
    key: API_KEY,
    method: 'turnstile',
    sitekey: '0x0000000000000000000000',
    pageurl: TARGET_URL,
    json: 1,
  }
});
const taskId = submit.data.request;

// Poll
let token = null;
for (let i = 0; i < 30; i++) {
  await new Promise(r => setTimeout(r, 5000));
  const poll = await axios.get('https://ocr.captchaai.com/res.php', {
    params: { key: API_KEY, action: 'get', id: taskId, json: 1 }
  });
  if (poll.data.status === 1) {
    token = poll.data.request;
    break;
  }
}
console.log(`Token: ${token.substring(0, 50)}...`);

Injecter le token et récupérer cf_clearance

Le token seul ne suffit pas : c'est la page de défi qui, une fois le token validé, obtient cf_clearance. Injectez le token dans le champ cf-turnstile-response, déclenchez la soumission, puis lisez les cookies.

Injecter le token avec Selenium

# With Selenium
from selenium import webdriver

driver = webdriver.Chrome()
driver.get(TARGET_URL)  # Load the challenge page

# Inject token into Turnstile response field
driver.execute_script("""
    const input = document.querySelector('input[name="cf-turnstile-response"]');
    if (input) input.value = arguments[0];

    // Trigger form submit or callback
    const form = document.querySelector('form');
    if (form) form.submit();
""", token)

# Wait for redirect and extract cookies
import time
time.sleep(3)
cookies = driver.get_cookies()
cf_clearance = next(
    (c for c in cookies if c['name'] == 'cf_clearance'), None
)
if cf_clearance:
    print(f"cf_clearance: {cf_clearance['value'][:30]}...")

Réutiliser le cookie dans vos requêtes

Une fois le cookie en main, abandonnez le navigateur et repassez sur un simple client HTTP — à condition de garder le même User-Agent et le même proxy que pendant la résolution.

session = requests.Session()
session.cookies.set("cf_clearance", cf_clearance["value"], domain=".example.com")
session.headers.update({
    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"
})

# Now access protected pages
resp = session.get("https://example.com/api/data")
print(resp.status_code)  # 200

Gérer l'expiration et le renouvellement du cookie

Anticiper l'expiration

Un cookie cf_clearance n'est jamais permanent. Plutôt que d'attendre le premier 403, vérifiez sa validité avant chaque cycle et relancez une résolution en amont de l'expiration.

import datetime

def is_cookie_valid(cookie):
    if not cookie:
        return False
    expiry = cookie.get("expiry", 0)
    return datetime.datetime.now().timestamp() < expiry - 60  # 60s buffer

def get_or_refresh_clearance(driver, target_url, solve_func):
    cookies = driver.get_cookies()
    cf = next((c for c in cookies if c["name"] == "cf_clearance"), None)
    if is_cookie_valid(cf):
        return cf["value"]

    # Re-solve
    token = solve_func(target_url)
    # ... inject and extract new cookie

La marge de 60 secondes évite le cas courant du cookie « valide » à la vérification, mais expiré quand la requête part.

Exemple concret : collecte conforme derrière Cloudflare

Prenons une équipe de scraping francophone qui agrège des annonces publiques derrière Cloudflare, avec des workers sur OVHcloud à Gravelines. Le piège classique : le pool de proxys tourne à chaque requête, si bien que le cookie obtenu derrière une IP est présenté depuis une autre — d'où des 403 en cascade.

La correction : épinglez chaque cookie cf_clearance à un proxy et n'envoyez les requêtes de cette session que par ce proxy jusqu'à expiration. Côté conformité, restez dans l'esprit du RGPD — minimisez les données personnelles collectées et vérifiez vos obligations avant la mise en production.

Dépannage

FAQ

CaptchaAI prend-il en charge les trois niveaux de Cloudflare Challenge ?

Oui. Le solveur Cloudflare Challenge couvre le JS Challenge, le défi géré et le défi interactif. Vous envoyez la même tâche turnstile quel que soit le niveau affiché.

Pourquoi mon cookie cf_clearance est-il rejeté alors que la résolution a réussi ?

Presque toujours à cause d'une incohérence de contexte : l'IP ou le User-Agent des requêtes ne correspond pas à ceux de la résolution. Réutilisez le même proxy et le même User-Agent, et vérifiez que le domaine du cookie couvre l'URL cible.

Un simple client HTTP suffit-il, ou faut-il un navigateur complet ?

Il faut un navigateur (ou un service équivalent) pour franchir le défi, car la page interstitielle exécute du JavaScript. Une fois cf_clearance obtenu, basculez sur un client HTTP léger comme requests.

Combien coûte la résolution des Cloudflare Challenge ?

La facturation CaptchaAI se fait au thread concurrent, pas au défi résolu. L'offre BASIC ($15/mois, 5 threads) inclut des résolutions illimitées par thread ; augmentez le nombre de threads pour traiter plus de pages en parallèle.

Faut-il un proxy résidentiel pour garder le cookie valide ?

Pas nécessairement : ce qui compte, c'est la stabilité de l'IP, pas son type. Un proxy datacenter stable convient tant que la même IP sert à la résolution et aux requêtes ; le résidentiel aide surtout si la cible bloque les plages datacenter.

Résolvez vos pages Cloudflare Challenge avec CaptchaAI

Obtenez votre clé API sur captchaai.com et intégrez la résolution du cookie cf_clearance à votre pipeline.

Guides associés

• Extraire le sitekey de Cloudflare Turnstile
• Turnstile, hCaptcha et reCAPTCHA comparés
• Optimiser vos cookies pour de meilleurs taux de résolution