Skip to content

DataDome Cookie

Build cookie clearance from the served challenge. Capture the HTTP challenge that your own session received. Send its challenge URL or raw HTML, with the page and session identity that produced it.

POST /createTask · example
{
  "clientKey": "capzy_YOUR_API_KEY",
  "task": {
    "type": "AntiDataDomeTask",
    "websiteURL": "https://example.com/blocked",
    "captchaUrl": "https://geo.captcha-delivery.com/captcha/?initialCid=...",
    "proxyType": "http",
    "proxyAddress": "123.45.67.89",
    "proxyPort": "8080",
    "proxyLogin": "user",
    "proxyPassword": "pass"
  }
}

Illustrative values. Replace the inputs with values from your current integration.

Challenge URL + HTML + session contextYour session proxy requiredDataDome cookie + user-agent

Preserve the challenge response.

Capture the HTTP challenge that your own session received. Send its challenge URL or raw HTML, with the page and session identity that produced it.

Your API key authenticates Capzy.
Provider keys, challenge IDs, images, and session values belong inside task.

Read the current blocked response.

  1. In Network, select the original blocked request. Copy its parent page URL into websiteURL.
  2. Copy the complete captcha-delivery.com challenge URL into captchaUrl. Alternatively, copy the raw 403 Response body containing the dd configuration into html.
  3. Keep query parameters and the original body intact. Supply one captured challenge route from this attempt.
Input collection example - replace illustrative values
{
  "websiteURL": "https://example.com/blocked",
  "captchaUrl": "https://geo.captcha-delivery.com/captcha/?YOUR_COMPLETE_QUERY"
}

This captured HTTP flow is different from the DataDome browser slider and interstitial tasks.

How DataDome Cookie works

This is the fast, browserless DataDome path. Instead of driving a real browser through the slider, it parses the dd challenge object from the block, builds the device link, generates the signed gesture/proof-of-work payload, and POSTs it to DataDome's /check endpoint to mint the datadome cookie — the same cookie the browser flow returns, at a fraction of the cost and time.

You capture the DataDome challenge (the geo.captcha-delivery.com captchaUrl, or the raw 403 HTML that contains the dd object) and hand it to us with your session cookies and User-Agent. We assemble and sign the payload over HTTP and return the datadome cookie, bound to your proxy IP.

  • Pure HTTP — no browser, ~90% less bandwidth
  • ~80% faster than the browser slider path
  • Covers both slider and interstitial flows
  • Returns the datadome cookie + matching User-Agent

Know what goes in.

Choose a field to see its purpose, where to get it, and its place in the request. Optional values omitted from the example can be added when your flow uses them.

Keep your proxy exit and session identity consistent when using this result.

Request authentication

Required task inputs

Optional context

Proxy connection

websiteURL

stringRequired

The protected page URL (also used as Referer/origin)

Where it comes from

Copy the full page URL from the address bar or the document request in Network, including the path where this flow runs.

Open the input guide
Example valuehttps://example.com/blocked
POST /createTask · selected configuration
{
  "clientKey": "capzy_YOUR_API_KEY",
  "task": {
    "type": "AntiDataDomeTask",
    "websiteURL": "https://example.com/blocked",
    "captchaUrl": "https://geo.captcha-delivery.com/captcha/?initialCid=...",
    "proxyType": "http",
    "proxyAddress": "123.45.67.89",
    "proxyPort": "8080",
    "proxyLogin": "user",
    "proxyPassword": "pass"
  }
}

The selected field is highlighted when present. Preserve the declared value type and current challenge context.

Make your first request.

Create the task, keep its taskId, and poll until status is ready. Then read the selected variant's solution.

More examples
  1. Create the task

    Send clientKey and the selected task to /createTask from your server. Keep the returned taskId.

  2. Wait for the solution

    Send that same key and ID to /getTaskResult. While processing, wait two seconds before checking again. Stop on Ready or an error.

  3. Apply the result

    Install the refreshed datadome cookie in the original jar and replay the blocked request with solution.userAgent and the same proxy. Preserve existing authentication cookies.

solve_datadome_cookie.py
import json, os, time
import requests

API = "https://api.capzy.ai"
KEY = os.environ["CAPZY_API_KEY"]
task = json.loads("{\"type\":\"AntiDataDomeTask\",\"websiteURL\":\"https://example.com/blocked\",\"captchaUrl\":\"https://geo.captcha-delivery.com/captcha/?initialCid=...\",\"proxyType\":\"http\",\"proxyAddress\":\"123.45.67.89\",\"proxyPort\":\"8080\",\"proxyLogin\":\"user\",\"proxyPassword\":\"pass\"}")

def call(path, payload):
    response = requests.post(f"{API}/{path}", json={"clientKey": KEY, **payload}, timeout=30)
    response.raise_for_status()
    data = response.json()
    if data.get("errorId", 0) or data.get("status") == "failed":
        raise RuntimeError(data.get("errorDescription") or data.get("errorCode") or "Task failed")
    return data

created = call("createTask", {"task": task})
for attempt in range(60):
    result = call("getTaskResult", {"taskId": created["taskId"]})
    if result.get("status") == "ready":
        solution = result["solution"]
        print(solution)
        break
    time.sleep(2)
else:
    raise TimeoutError("Task is still processing; keep the taskId to check it later.")

Before runningReplace all illustrative inputs with your captured values. Set CAPZY_API_KEY in your environment. Install requests with pip install requests.

Polling and failuresThe example checks HTTP/API failures, uses 30-second request timeouts, and stops after 60 result checks. Retain taskId if your task is still processing.

Understand what comes back.

Follow this task from creation to completion. Response fields and usage follow your selected request variant.

DataDome cookie + user-agent

Install the refreshed datadome cookie in the original jar and replay the blocked request with solution.userAgent and the same proxy. Preserve existing authentication cookies.

string
The datadome cookie value — set it on your domain to pass DataDome on subsequent requests from the same IP
string
Alias of cookie (same value)
string
The User-Agent the cookie is bound to — replay with this exact value
POST /getTaskResult · example response
{
  "errorId": 0,
  "status": "ready",
  "solution": {
    "cookie": "datadome=<long opaque datadome cookie value, IP-bound>",
    "datadome": "datadome=<same value>",
    "userAgent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36"
  }
}

Illustrative values. Additional metadata may be returned; only Ready contains a completed solution.

Use the result

Install the refreshed datadome cookie in the original jar and replay the blocked request with solution.userAgent and the same proxy. Preserve existing authentication cookies.

Execution context result is the parsed Ready response from the polling example. session, when referenced, is your existing requests.Session (or browser-compatible session) with the original cookie jar, headers, and solving proxy configured in session.proxies for both http and https. Keep this client for the complete flow. task is the task object you submitted. For Shape, action_body is the original protected request body as bytes or a string, with its original Content-Type in session.headers. Install curl_cffi when the fragment imports it; match the target's required browser/TLS identity.

Use the result · Python

from http.cookies import SimpleCookie
sol = result["solution"]
cookie_values = SimpleCookie()
cookie_values.load(sol["cookie"])
for name, cookie in cookie_values.items():
    session.cookies.set(name, cookie.value, domain="target.example.com", path="/")
session.headers["User-Agent"] = sol["userAgent"]
# session retains the original cookie jar and the solve's proxy.
resp = session.get("https://target.example.com/", timeout=30)
print(resp.status_code)

When something doesn't work.

Check your captured values, the selected variant, and the response before starting another task.

Is this available now?

It's in closed beta while we harden the payload signer against DataDome's rotation. Until it's generally available it may return ERROR_TASK_TYPE_DISABLED — use DataDomeSlider (the browser path) for production, or contact us for beta access.

captchaUrl or html — which do I send?

Either. Send the geo.captcha-delivery.com captchaUrl from the blocked iframe, or the raw 403 HTML that contains the `var dd={...}` object. Include your existing datadome cookie for continuity.

Integration checks for DataDome Cookie
  • Beta — not yet generally available. The payload signer that keeps up with DataDome's rotation is still being hardened, so this task type may return ERROR_TASK_TYPE_DISABLED. Use DataDomeSlider (browser path) for production today; contact us for beta access.
  • The datadome cookie is IP-bound. Reuse the same proxy for the solve and for every subsequent request.
  • Pass the datadome cookie from your blocked session (datadomeCookie or the cookies array) for visitor continuity — it materially raises success rate.

Connect DataDome Cookie to your workflow.

Get your Capzy API key and use this guide's integration.

UnavailablePer 1,000 solves
UnavailableAverage solve time

AntiDataDomeTask · Live configuration
Current stats are unavailable. Check the solver catalog.