Skip to content

DataDome Tags

Prepare telemetry for the session you are building. Read the site's DataDome Tags client key and collector configuration. This task generates or refreshes visitor context for that page and session.

POST /createTask · example
{
  "clientKey": "capzy_YOUR_API_KEY",
  "task": {
    "type": "DataDomeTags",
    "websiteURL": "https://example.com/",
    "ddk": "AE3F04AD3F0DEADBEEF00112233445566",
    "proxyType": "http",
    "proxyAddress": "123.45.67.89",
    "proxyPort": "8080",
    "proxyLogin": "user",
    "proxyPassword": "pass"
  }
}

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

Site key ddk + session + proxyYour session proxy requiredUpdated DataDome cookie

Read the Tags configuration.

Read the site's DataDome Tags client key and collector configuration. This task generates or refreshes visitor context for that page and session.

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

Copy the client-side ddk configuration.

  1. In Sources, search the page's DataDome Tags configuration for ddk. Copy that site's client key into the ddk field.
  2. Use the complete page URL as websiteURL. In Network, inspect the Tags collector request to see whether it uses a custom first-party endpoint.
  3. Send tagsUrl only when preserving that custom collector; copy its complete Request URL.
Input collection example - replace illustrative values
{
  "websiteURL": "https://example.com/account",
  "ddk": "YOUR_DATADOME_CLIENT_KEY",
  "tagsUrl": "https://example.com/YOUR_CUSTOM_COLLECTOR"
}

ddk identifies the site. datadomeCookie identifies a visitor session; they have separate roles.

How DataDome Tags works

DataDome's JS tag continuously POSTs device + behavioral telemetry to its /js/ collector to build session trust in the background. When that trust is high enough, DataDome never escalates to a slider or interstitial. This solver assembles and submits those tags for you — deterministically, no browser — so you can warm a session up-front instead of solving a challenge after you're already blocked.

You provide the site's DataDome client key (ddk) and your current session. We assemble the tags payload and submit the two sequential collector POSTs (type='ch' then type='le'), returning the refreshed datadome cookie. No puzzle, no interstitial, no browser.

  • Proactive — prevents the slider/interstitial from firing at all
  • Deterministic tag assembly — no browser, no puzzle
  • Returns a refreshed datadome cookie bound to your session
  • Supports first-party-proxied collector endpoints (tagsUrl)

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 (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/
POST /createTask · selected configuration
{
  "clientKey": "capzy_YOUR_API_KEY",
  "task": {
    "type": "DataDomeTags",
    "websiteURL": "https://example.com/",
    "ddk": "AE3F04AD3F0DEADBEEF00112233445566",
    "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

    Merge the returned datadome cookie into the existing session and use solution.userAgent on subsequent requests through the same exit. Keep the site's login and transaction cookies intact.

DataDomeTags · $2.00 / 1,000
solve_datadome_tags.py
import json, os, time
import requests

API = "https://api.capzy.ai"
KEY = os.environ["CAPZY_API_KEY"]
task = json.loads("{\"type\":\"DataDomeTags\",\"websiteURL\":\"https://example.com/\",\"ddk\":\"AE3F04AD3F0DEADBEEF00112233445566\",\"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.

Updated DataDome cookie

Merge the returned datadome cookie into the existing session and use solution.userAgent on subsequent requests through the same exit. Keep the site's login and transaction cookies intact.

string
The refreshed datadome cookie value — set it on your domain for subsequent requests from the same IP
string
Alias of cookie (same value)
string
The User-Agent the tags/cookie are bound to — replay with this exact value
POST /getTaskResult · example response
{
  "errorId": 0,
  "status": "ready",
  "solution": {
    "cookie": "datadome=<refreshed 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

Merge the returned datadome cookie into the existing session and use solution.userAgent on subsequent requests through the same exit. Keep the site's login and transaction cookies intact.

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?

Yes. The tags path submits the two collector POSTs (ch then le) and returns a refreshed datadome cookie — no browser. The cookie is IP-bound, so warm and replay through the same proxy.

How is this different from the slider / cookie solvers?

Those REACT to a block (you solve the challenge you were served). Tags is PROACTIVE: you warm DataDome's trust up-front so the challenge never fires. Use it before you get blocked; use DataDomeSlider or the cookie path once you already have.

Where do I find the ddk?

It's the static DataDome client key on the site — look in the DataDome tag script for a `ddk` / client key value (often a 32-char hex string). Pass it as ddk (aliases: sitekey, s).

Integration checks for DataDome Tags
  • The datadome cookie is IP-bound. Use the same proxy for warming and for your subsequent requests.
  • Warm trust BEFORE you get blocked. The point of tags is to prevent the challenge — once you're hard-blocked, use DataDomeSlider or the cookie path instead.
  • Tags raise session trust; they don't guarantee zero challenges. Keep DataDomeSlider wired as a fallback for sessions that still get challenged.

Connect DataDome Tags to your workflow.

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

$2.00Per 1,000 solves
1.5sAverage solve time

DataDomeTags · Live configuration