CAPTCHA DataDome
et CapMonster Cloud

Solution CAPTCHA, intégration sur le site et tests.

Tarifs de la solution DataDome CAPTCHA

CAPTCHA	Prix (USD)	Succès
DataDome 97%	$ 2.20 1000 jetons	97%

Vous avez hérité d’un site doté d’une captcha ou d’une autre couche de protection mais sans accès au code source ? Il est alors naturel de se demander quelle solution est installée, si elle est correctement configurée et comment la tester.

Dans cet article, nous avons essayé de répondre à toutes les questions essentielles. Pour commencer à résoudre le problème, il faut d’abord déterminer quel système de protection est utilisé. Pour cela, vous pouvez consulter la liste des captchas et systèmes de protection antibot les plus populaires, qui présente des exemples visuels et des caractéristiques clés permettant d’identifier rapidement avec quoi vous avez affaire.

Si vous constatez que votre site utilise DataDome CAPTCHA, l’étape suivante consiste à étudier plus en détail ses propriétés et son fonctionnement. Dans cet article, vous pouvez également consulter le guide d’intégration de DataDome CAPTCHA afin de comprendre pleinement la façon dont il fonctionne sur votre site. Cela vous permettra non seulement de mieux connaître la protection en place, mais aussi de planifier correctement sa maintenance.

Qu'est-ce que DataDome

DataDome est un système de protection contre les bots et les attaques automatisées qui analyse le comportement des visiteurs et les paramètres réseau pour distinguer les utilisateurs réels du trafic malveillant et assurer le fonctionnement stable d’un site ou d’une application.

Exemples de DataDome CAPTCHA

Analyse comportementale

Évaluation des actions de l’utilisateur (clics, défilement, vitesse d’interaction).

Vérification JavaScript

Vérification cachée du navigateur et de son environnement.

Vérification réseau

Analyse des adresses IP, en-têtes, proxies et réseaux de bots connus.

Challenge

Affichage du CAPTCHA (généralement un slider « Faites glisser vers la droite pour résoudre le puzzle ») si le système doute.

Comment résoudre le CAPTCHA DataDome via CapMonster Cloud

Lors du test de la protection DataDome, il est important de s'assurer qu'elle est correctement intégrée et réagit au trafic suspect. Pour une vérification manuelle, ouvrez une page protégée par DataDome et assurez-vous que le système est actif.

Essayez d’effectuer une requête simulant un comportement suspect (par exemple, rafraîchissements de page trop fréquents ou envoi de formulaire sans données valides) — DataDome devrait bloquer l'accès ou afficher une page de protection.

Pour les tests automatisés et la résolution de CAPTCHA, vous pouvez utiliser des services spécialisés tels que CapMonster Cloud — un outil qui accepte les paramètres du CAPTCHA, les traite sur ses serveurs et renvoie une solution prête. Cette solution (token ou cookie) peut être insérée dans un formulaire ou un navigateur pour passer la vérification sans intervention de l’utilisateur.

Travailler avec CapMonster Cloud via l’API comprend généralement les étapes suivantes :

Création de la tâche

À cette étape, vous fournissez votre clé API, le type de CAPTCHA et ses paramètres. Le service retourne un taskId unique pour récupérer le résultat ultérieurement.

Envoyer une requête API

Dans la requête pour résoudre DataDome, vous devez indiquer les paramètres suivants :

type - CustomTask

class - DataDome

websiteURL - l'adresse de la page principale où le CAPTCHA est résolu.

captchaUrl (dans metadata) - "captchaUrl" — le lien vers le CAPTCHA. Généralement sous ce format : "https://geo.captcha-delivery.com/captcha/?initialCid=..."

datadomeCookie (dans metadata) - Vos cookies DataDome. Ils peuvent être obtenus sur la page via document.cookie (si les cookies n’ont pas le flag HttpOnly), dans l’en-tête de requête Set-Cookie : "datadome=...", ou directement depuis le code HTML de la page initialCid.

userAgent - User-Agent du navigateur. Fournissez seulement le UA actuel depuis Windows.

De plus, pour cette tâche, vous devez utiliser vos proxies :

proxyType :

http - proxy HTTP/HTTPS standard ;
https - essayez ceci si 'http' ne fonctionne pas (nécessaire pour certains proxies personnalisés) ;
socks4 - proxy SOCKS4 ;
socks5 - proxy SOCKS5.

proxyAddress - Adresse IP du proxy (IPv4/IPv6).

proxyPort - Port du proxy.

proxyLogin - Login du proxy.

proxyPassword - Mot de passe du proxy.

Pour en savoir plus sur les paramètres et la façon de les collecter automatiquement avant d’envoyer une tâche, consultez la documentation CapMonster Cloud.

Endpoint pour l’envoi de la tâche :

javascript

https://api.capmonster.cloud/createTask

Exemple de requête :

json


{
  "clientKey": "API_KEY",
  "task": {
    "type": "CustomTask",
    "class": "DataDome",
    "websiteURL": "https://example.com",
    "userAgent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/150.0.0.0 Safari/537.36",
    "metadata": {
      "captchaUrl": "https://geo.captcha-delivery.com/interstitial/?initialCid=AHrlqAAAAAMA9UvsL58YLqIAXNLFPg%3D%3D&hash=C0705ACD75EBF650A07FF8291D3528&cid=7sfa5xUfDrR4bQTp1c2mhtiD7jj9TXExcQypjdNAxKVFyIi1S9tE0~_mqLa2EFpOuzxKcZloPllsNHjNnqzD9HmBA4hEv7SsEyPYEidCBvjZEaDyfRyzefFfolv0lAHM&referer=https%3A%2F%2Fwww.example.com.au%2F&s=6522&b=978936&dm=cm",
      "datadomeCookie": "datadome=VYUWrgJ9ap4zmXq8Mgbp...64emvUPeON45z"
    },
    "proxyType": "http",
    "proxyAddress": "123.45.67.89",
    "proxyPort": 8080,
    "proxyLogin": "proxyUsername",
    "proxyPassword": "proxyPassword"
  }
}

Réponse :

json

{
  "errorId":0,
  "taskId":407533072
}

Réception du résultat

Après avoir créé la tâche, interrogez régulièrement l’état de la solution.

Adresse pour recevoir le résultat :

javascript

https://api.capmonster.cloud/getTaskResult

Exemple de requête :

json

{
  "clientKey":"API_KEY",
  "taskId": 407533072
}

Réponse :

json


{
  "errorId": 0,
  "status": "ready",
  "solution": {
    "domains": {
      "www.example.com": {
        "cookies": {
          "datadome": "P1w0VnjFcTFslfps0J4FaPpY_QPbPBW4MeYxj4LW~pztIfJiSSuBPr8oQTUHzdrfgv137FbOBd3kCUOOgny7LhIkhm5e1qdtzYM4s2e46U_qfERK4KiCy22MOSIDsDyh"
        },
        "localStorage": null
      }
    },
    "url": null,
    "fingerprint": null,
    "headers": null,
    "data": null
  }
}

Insertion du jeton sur la page

La solution obtenue (cookie datadome) peut être définie dans le navigateur ou envoyée avec une requête HTTP en l’incluant dans l’en-tête Cookie : datadome=<valeur>. Pour l’automatisation et les tests, Puppeteer, Selenium ou Playwright peuvent être utilisés pour émuler les actions de l’utilisateur, insérer les cookies et soumettre les formulaires.

Reconnaissance du CAPTCHA DataDome avec des bibliothèques prêtes à l’emploi

Le service CapMonster Cloud fournit des bibliothèques prêtes à l'emploi pour une utilisation pratique en Python et JavaScript (Node.js).

Python

JavaScript

Résolution de DataDome et insertion des cookies

Exemple en Node.js pour le cycle complet de reconnaissance du CAPTCHA sur votre page web. Approches possibles : utiliser des requêtes HTTP pour obtenir le HTML et les paramètres de protection, envoyer la réponse et traiter le résultat ; ou utiliser des outils d’automatisation (ex. Playwright) — ouvrir la page, attendre la vérification, envoyer les paramètres via le client CapMonster Cloud, obtenir le résultat, insérer les cookies dans le navigateur (pour les tests, vous pouvez utiliser des données correctes ou incorrectes) et observer le résultat.

python


// npx playwright install chromium

import { chromium } from 'playwright';
import { CapMonsterCloudClientFactory, ClientOptions, DataDomeRequest } from '@zennolab_com/capmonstercloud-client';

// Entrez votre clé API CapMonster Cloud
const API_KEY = 'YOUR_API_KEY';

// Votre site est protégé par DataDome
const TARGET_URL = 'https://example.com/';

const USER_AGENT = Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/150.0.0.0 Safari/537.36

// Configuration du proxy
const proxy = {
  proxyType: "http",
  proxyAddress: '8.8.8.8',
  proxyPort: 8080,
  proxyLogin: 'proxyLogin',
  proxyPassword: 'proxyPassword'
};

async function main() {

  // Lancer le navigateur
  const browser = await chromium.launch({ headless: true });
  const context = await browser.newContext({ userAgent: USER_AGENT });
  const page = await context.newPage();

  // Accéder au site web
  await page.goto(TARGET_URL, { waitUntil: 'networkidle' });

  // Recherche d’un cookie datadome existant (si présent)
  const existingDd = (await context.cookies()).find(c => /datadome|dd_/i.test(c.name));

  // Trouver iframe DataDome -> URL du CAPTCHA
  const captchaUrl = await page.evaluate(() =>
    Array.from(document.querySelectorAll('iframe[src]'))
      .find(i => /captcha-delivery\.com\/captcha/i.test(i.src))
      ?.src || null
  );

  console.log(`=== Paramètres DataDome extraits ===`);
  console.log(`captchaUrl:`, captchaUrl || 'non trouvé');
  console.log(`cookie datadome actuel ::`, existingDd ? ${existingDd.name}=${existingDd.value}` : 'aucun');

  const cm = CapMonsterCloudClientFactory.Create(
    new ClientOptions({ clientKey: API_KEY })
  );

  // Envoyer la tâche à CapMonster
  console.log(`Envoi de la tâche DataDome à CapMonster......`);

  // Soumission de la tâche DataDome pour résolution
  const solve = await cm.Solve(new DataDomeRequest({
    _class: "DataDome",
    websiteURL: TARGET_URL,
    userAgent: USER_AGENT,
    proxy,
    metadata: {
      captchaUrl: captchaUrl || undefined,
      datadomeCookie: existingDd
        ? `${existingDd.name}=${existingDd.value}`
        : undefined
    }
  }));

  const sol = solve?.solution;

  // Obtenir le domaine et les cookies nécessaires depuis la solution
  const host = new URL(TARGET_URL).hostname;
  const domainKey =
    Object.keys(sol.domains).find(d => d.includes(host))
    || Object.keys(sol.domains)[0];

  const cookiesArr = sol.domains[domainKey]?.cookies || [];

  console.log(`\n=== Cookies de CapMonster ===`);
  cookiesArr.forEach(c => console.log(`${c.name}=${c.value}`));

  const ddSolved =
    cookiesArr.find(c => c.name?.toLowerCase() === 'datadome')
    || cookiesArr.find(c => /datadome/i.test(c.name));

  // Définir le cookie datadome dans le navigateur
  await context.addCookies([{
    name: 'datadome',
    value: ddSolved.value,
    domain: '.' + host,
    path: '/',
    httpOnly: ddSolved.httpOnly ?? true,
    secure: ddSolved.secure ?? true,
    sameSite: ddSolved.sameSite ?? 'Lax'
  }]);

  console.log(`Cookie datadome défini :`, ddSolved.value);

  // Réouvrir le site après insertion du cookie
  const page2 = await context.newPage();
  const resp2 = await page2.goto(TARGET_URL, { waitUntil: 'domcontentloaded', timeout: 60000 });

  console.log(`Statut après insertion du cookie :: ${resp2?.status()}`);

  await browser.close();
}

main();

Il est également possible de tester la reconnaissance des CAPTCHA via l’extension navigateur CapMonster Cloud, qui permet de vérifier rapidement le CAPTCHA directement sur la page et de suivre le processus en temps réel sans écrire de code — disponible pour Chrome et Firefox.

Comment intégrer CAPTCHA DataDome sur votre site web

Pour travailler en toute confiance avec le CAPTCHA sur votre site, comprendre sa logique de vérification ou le reconnecter/reconfigurer, nous recommandons de lire cette section. Elle décrit le processus d’intégration et aide à comprendre rapidement tous les détails.

1. Connectez-vous à votre compte ou inscrivez-vous sur DataDome et obtenez les clés (client-side et server-side).

Important : l’inscription nécessite un e-mail professionnel de votre entreprise.

Après l’inscription, vous accéderez au panneau d’administration.

2. Ajoutez votre site (domaine) dans le panneau DataDome.

Ajoutez votre domaine au système et choisissez les paramètres de protection :

Protection Web (HTTP traffic protection)
Bot detection & mitigation
Frequency & behavior analysis
Pages de challenge (DataDome challenge page)
JS tag configuration

3. Installez l’intégration côté serveur.

Utilisez Protection API ou sélectionnez un module prêt pour votre stack (Node.js / Express, Nginx, Cloudflare, Java (Tomcat/Jetty/Vert.x), Go, etc.).

Installez le SDK/middleware officiel de DataDome et configurez la clé serveur (server-side key).

Exemple d’intégration de DataDome en Node.js :

DataDome protège le serveur contre les bots et requêtes suspectes, affichant automatiquement un challenge si nécessaire. Le module peut être utilisé avec Express ou le serveur HTTP intégré Node.js.

Installation

Pour Express :

javascript

npm install @datadome/module-express

Pour module HTTP Node.js :

javascript

npm install @datadome/module-http

Node.js version 18 ou supérieure est pris en charge. La clé server-side de votre panneau DataDome est requise.

Intégration avec Express

javascript


const { DatadomeExpress } = require('@datadome/module-express');
const express = require('express');
const app = express();

// Initialiser le client DataDome
const datadomeClient = new DatadomeExpress('YOUR_SERVER_KEY');

// Connecter le middleware
app.use(datadomeClient.middleware());

// Vos routes
app.get('/', (req, res) => {
  res.send('Hello World');
});

// Démarrer le serveur
app.listen(3000, () => {
  console.log('Server running on port 3000');
})

Intégration serveur HTTP Node.js

javascript


const { DatadomeHttp } = require('@datadome/module-http');
const http = require('http');

const datadomeClient = new DatadomeHttp('YOUR_SERVER_KEY');

const hostname = '127.0.0.1';
const port = 3000;

const server = http.createServer(async (req, res) => {
  const { result, error } = await datadomeClient.handleRequest(req, res);

  if (result === 'ALLOW') {
    res.statusCode = 200;
    res.setHeader('Content-Type', 'text/plain');
    res.end('Hello World\n');
  } else {
    console.log('Request challenged');
    if (error) console.error(error);
  }
});

server.listen(port, hostname, () => {
  console.log(`Server running at http://${hostname}:${port}/`);
});

Paramètres du module

Vous pouvez passer la configuration lors de la création du client :

javascript


const datadomeClient = new DatadomeExpress('YOUR_SERVER_KEY', {
  timeout: 150, // timeout en ms après lequel la requête est autorisée
  urlPatternInclusion: null, // quelles URLs vérifier
  urlPatternExclusion: /\.(avi|flv|mka|mkv|mov|mp4|mpeg|mpg|mp3|flac|ogg|ogm|opus|wav|webm|webp|bmp|gif|ico|jpeg|jpg|png|svg|svgz|swf|eot|otf|ttf|woff|woff2|css|less|js|map|json|avif|xml|gz|zip)$/i,
  endpointHost: 'api.datadome.co',
});

Options avancées :

Journalisation des en-têtes DataDome (enrichedHeaders)
CSP nonce : app.use(datadomeClient.middleware({ nonce: 'VALUE' }))
Surcharger les métadonnées de requête via handlers

Plus de détails sur l’intégration côté serveur dans documentation officielle.

4. Intégrer côté client.

Insérez le JS Tag dans le <head> de votre site :

markup


<head>
  <script>
    window.ddjskey = 'YOUR_DATADOME_JS_KEY';
    window.ddoptions = {
      // Ajoutez vos paramètres ici (optionnel)
    };
  </script>
  <script src="https://js.datadome.co/tags.js" async></script>
  <!-- Autres éléments du head -->
</head>

YOUR_DATADOME_JS_KEY → Remplacez par votre Client-Side key.

Chargez le script en début de <head> pour permettre à DataDome d’intercepter les requêtes et de suivre correctement le comportement des utilisateurs.

Si le site utilise CSP, ajoutez les directives suivantes :

Pour le script inline

markup


<script nonce="DYNAMIC_NONCE">
  window.ddjskey = 'YOUR_DATADOME_JS_KEY';
  window.ddoptions = {};
</script>

DYNAMIC_NONCE est généré pour chaque requête.

Pour le chargement de scripts externes

markup


script-src js.datadome.co ct.captcha-delivery.com 'nonce-DYNAMIC_NONCE';
connect-src api-js.datadome.co;  /* pour envoyer les données du JS Tag */
frame-src *.captcha-delivery.com; /* pour les pages de challenge */
worker-src blob:;                /* pour les web workers */

Plus de détails sur l’intégration côté client dans documentation officielle CAPTCHA DataDome.

Vérification du résultat

DataDome crée le cookie datadome= après une vérification réussie. Ce cookie est automatiquement envoyé par l'utilisateur, et le serveur accepte la requête. Si le cookie est absent ou invalide, DataDome affichera à nouveau le challenge.

Erreurs possibles et débogage

Clé ou domaine invalide

DataDome ne protège pas correctement le site ; le challenge n’apparaît pas. Vérifiez que la clé Server-Side correcte est utilisée et que le domaine est ajouté dans le panneau DataDome.

Timeout du traitement de la requête

Le serveur n’a pas reçu de réponse de l’API DataDome. Augmentez la valeur du timeout dans les paramètres du module.

Token vide ou paramètre invalide

Erreur lors de l’envoi du résultat de la vérification au serveur. Assurez-vous que le JS tag client est correctement installé et retourne le ddtoken.

Challenge non réussi

La requête a été marquée comme suspecte ou le token a expiré. Activez la journalisation via le paramètre logger du module et suivez les événements blocked et valid pour le diagnostic.

Tests de robustesse de la protection

Essayez d’effectuer une requête vers la ressource protégée sans passer par le JS Tag ou sans envoyer le jeton. Le serveur doit la bloquer (ou renvoyer un challenge).

Utilisez des outils comme k6 ou JMeter pour simuler plus de 100 requêtes par seconde. Le challenge doit s’afficher correctement et le système de validation doit rester stable.

Vérifiez le comportement du serveur lors de la réutilisation d’un jeton déjà utilisé. Le serveur doit refuser correctement la requête en renvoyant un statut 403 ou un challenge.

Conseils de sécurité et d’optimisation

Conservez la <span class="font-bold">Server-Side Key</span> uniquement sur le serveur ; ne la transmettez pas au client.

Conservez la Server-Side Key uniquement sur le serveur ; ne la transmettez pas au client.

Activez la journalisation des événements via <span class="font-bold">logger</span> ou les écouteurs <span class="font-bold">blocked/valid</span> pour suivre les raisons des blocages.

Activez la journalisation des événements via logger ou les écouteurs blocked/valid pour suivre les raisons des blocages.

Placez des liens vers la <span class="font-bold">Politique de confidentialité</span> et les <span class="font-bold">Conditions d’utilisation de DataDome</span> sur les pages de formulaire, comme recommandé pour la transparence auprès des utilisateurs.

Placez des liens vers la Politique de confidentialité et les Conditions d’utilisation de DataDome sur les pages de formulaire, comme recommandé pour la transparence auprès des utilisateurs.

Captchas pris en charge

Conclusion

Si vous avez récupéré un site avec un captcha ou un autre système de protection déjà installé, mais sans accès au code, pas de panique ! Il est assez simple d’identifier quelle technologie est utilisée. Pour vérifier que tout fonctionne correctement, vous pouvez utiliser le service de reconnaissance CapMonster Cloud dans un environnement de test isolé, afin de vous assurer que le mécanisme de traitement des jetons et la logique de vérification fonctionnent correctement.

Dans le cas de DataDome CAPTCHA, il suffit d’identifier le système, d’étudier son comportement et de vérifier que la protection fonctionne correctement. Dans cet article, nous avons montré comment reconnaître DataDome CAPTCHA et où trouver les instructions pour son intégration ou sa reconfiguration, afin de maintenir la protection en toute confiance et de garder son fonctionnement sous contrôle.

Liens utiles

Documentation CAPTCHA DataDome →

Documentation CapMonster Cloud (travail avec CAPTCHA DataDome) →

L’extension de navigateur CapMonster Cloud est disponible pour Chrome et Firefox. Le guide complet d’installation et d’utilisation est disponible ici.

Foire aux questions sur DataDome

Comment vérifier si un site est protégé par DataDome sans accès à son code source ?

L'indicateur le plus évident est le cookie datadome dans les réponses du serveur :

Ouvrez le site protégé par DataDome dans un navigateur (Chrome, Firefox).
Appuyez sur F12 (outils de développement) → allez dans l'onglet Application → Cookies.
Trouvez le domaine du site (par ex. www.example.com).
Parmi les cookies, recherchez la clé datadome

Vous pouvez également vérifier si les requêtes du site incluent des appels à geo.captcha-delivery.com dans les outils de développement → onglet Network ; ce point de terminaison appartient à l'infrastructure de livraison des challenges DataDome.

Comment intégrer la protection DataDome dans une application Node.js Express ?

Installez le package officiel :

npm install @datadome/module-express

Importez et initialisez le client :

const { DatadomeExpress } = require('@datadome/module-express')

puis

new DatadomeExpress('YOUR_SERVER_SIDE_KEY')

Attachez le middleware :

app.use(datadomeClient.middleware())

Dans la plupart des cas, le middleware doit être enregistré avant les routes protégées afin que les requêtes puissent être analysées avant d'atteindre vos gestionnaires de routes. Selon la structure de votre application, vous pouvez également appliquer le middleware de manière sélective à des routes ou groupes de routes spécifiques.

Utilisez cet exemple comme configuration minimale :

const { DatadomeExpress } = require('@datadome/module-express');
const express = require('express');
const app = express();

// Initialize DataDome client
const datadomeClient = new DatadomeExpress('YOUR_SERVER_KEY');

// Connect middleware
app.use(datadomeClient.middleware());

// Your routes
app.get('/', (req, res) => {
  res.send('Hello World');
});

// Start server
app.listen(3000, () => {
  console.log('Server running on port 3000');
})

Le module officiel prend également en charge des options de configuration et de personnalisation supplémentaires pour les intégrations avancées.

Plus de détails sur l'intégration côté serveur dans la documentation officielle.

Comment vérifier que la protection DataDome fonctionne correctement après l'intégration ?

Pour vérifier si DataDome est correctement configuré, essayez ces trois tests :

Visitez une page protégée sans le DataDome JS Tag. Si l'intégration fonctionne comme prévu, vous devriez recevoir un challenge CAPTCHA.
Simulez du trafic automatisé avec des outils comme k6 ou JMeter. DataDome devrait détecter cette activité et répondre avec un challenge.
Réutilisez un datadome cookie résolu depuis une autre adresse IP. Cela ne devrait pas fonctionner, et DataDome devrait afficher un nouveau challenge CAPTCHA.

Quelles erreurs peuvent survenir lors de la résolution DataDome et comment les corriger ?

Si la résolution DataDome échoue, voici les raisons les plus courantes :

ERROR_CAPTCHA_UNSOLVABLE: Les paramètres createTask sont incorrects. Votre proxy peut être bloqué par la DataDome CAPTCHA. Changez le serveur proxy utilisé pour la requête. Vérifiez à nouveau les paramètres envoyés dans la requête. Si l'erreur se répète, contactez le support en fournissant : taskId, type de tâche (type), image originale ou données d'entrée, date/heure de la tâche et corps de la requête.
ERROR_KEY_DOES_NOT_EXIST: Votre clientKey est incorrect ou inactif. Vérifiez la clé dans votre compte CapMonster Cloud.
ERROR_PROXY_READ_TIMEOUT: Le proxy est trop lent ou peu fiable. Essayez un autre proxy. Cette erreur peut également être causée par un metadata.captchaUrl incorrect dans la requête createTask. Vérifiez à nouveau le lien vers la captcha.
Les cookies reçus du service ne fonctionnent pas sur le site cible : La requête de résolution et la requête finale ont été envoyées depuis des IP différentes. Utilisez la même IP pour les deux. Vérifiez également la configuration correcte des cookies ; assurez-vous que le datadome cookie renvoyé est correctement défini dans votre navigateur ou les en-têtes de requête.

Comment insérer le cookie de solution DataDome dans un navigateur ou des requêtes HTTP

Pour les requêtes HTTP, incluez la valeur résolue dans l'en-tête de requête Cookie sous la forme datadome=<value> à chaque requête ultérieure vers le domaine protégé.

Dans les outils d'automatisation de navigateur comme Puppeteer, Selenium ou Playwright, ajoutez le datadome cookie en utilisant la méthode de cookie intégrée du framework avant d'ouvrir la page protégée.

Par exemple :

Dans Playwright, utilisez context.addCookies().
Dans Puppeteer, utilisez page.setCookie().
Dans Selenium, utilisez driver.add_cookie().

Assurez-vous que le cookie est défini pour le bon domaine et le bon chemin. Utilisez également ces méthodes avec httpOnly: true, secure: true et sameSite: 'Lax' pour que le navigateur le traite comme un cookie de session normal.

CAPTCHA DataDome et CapMonster Cloud

Tarifs de la solution DataDome CAPTCHA

Comment résoudre le CAPTCHA DataDome via CapMonster Cloud

Captchas pris en charge

Foire aux questions sur DataDome

CAPTCHA DataDome
et CapMonster Cloud