DataDome Interstitial

Handle the device check before loading the page. This task handles the device-check page by visiting the protected URL. It does not need a captured interstitial iframe URL or image inputs.

Get the integration code

POST /createTask · example

{
  "clientKey": "capzy_YOUR_API_KEY",
  "task": {
    "type": "DataDomeInterstitial",
    "websiteURL": "https://example.com/blocked",
    "userAgent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36",
    "proxyType": "http",
    "proxyAddress": "123.45.67.89",
    "proxyPort": "8080",
    "proxyLogin": "user",
    "proxyPassword": "pass"
  }
}

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

Interstitial URL + session proxyYour session proxy requiredDataDome session cookie

Capture the device-check interstitial.

This task handles the device-check page by visiting the protected URL. It does not need a captured interstitial iframe URL or image inputs.

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

Copy the original URL and session identity.

Enable Preserve log in Network and open the protected page. Find the document request preceding the DataDome device-check navigation.
Copy that original Request URL into websiteURL, rather than the geo.captcha-delivery.com/interstitial URL.
Open its Request Headers and copy the exact User-Agent into required userAgent. Confirm this is a device check; use the slider solver for a visible puzzle.

Input collection example - replace illustrative values

{
  "websiteURL": "https://example.com/blocked",
  "userAgent": "YOUR_ORIGINAL_REQUEST_USER_AGENT"
}

captchaUrl is ignored here. Capture websiteURL and userAgent from the same session you will continue through the solving proxy.

How DataDome Interstitial works

The DataDome interstitial is the full-page device-check that appears instead of a slider — a 'Please wait…' / verification screen served from geo.captcha-delivery.com/interstitial/. There's no puzzle to drag: DataDome runs a proof-of-work and fingerprint check in the page and, if it passes, issues the datadome cookie.

Send websiteURL, the original userAgent, and your sticky session proxy. We load the interstitial through that proxy, run the device check, and collect the datadome cookie. Install it in the original session and replay through the same proxy and user-agent. This task documents cookie and token in its result; retain the userAgent you submitted rather than expecting a returned userAgent field.

Clears the device-check interstitial with no puzzle solving
Often a silent pass — faster and cheaper than the slider
Returns the datadome cookie for replay
Uses your session proxy; continue through the same sticky exit

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. We load it in a real browser and let DataDome's device-check JavaScript run and issue the datadome cookie — no interaction, no puzzle.

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": "DataDomeInterstitial",
    "websiteURL": "https://example.com/blocked",
    "userAgent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36",
    "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

Create the task
Send clientKey and the selected task to /createTask from your server. Keep the returned taskId.
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.
Apply the result
Apply the returned datadome cookie to the original session and retry the protected URL with task.userAgent. Keep the cookie's target scope and solving exit; this result is session clearance rather than a form response token.

DataDomeInterstitial · $2.00 / 1,000

solve_datadome_interstitial.py

import json, os, time
import requests

API = "https://api.capzy.ai"
KEY = os.environ["CAPZY_API_KEY"]
task = json.loads("{\"type\":\"DataDomeInterstitial\",\"websiteURL\":\"https://example.com/blocked\",\"userAgent\":\"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36\",\"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 session cookie

Apply the returned datadome cookie to the original session and retry the protected URL with task.userAgent. Keep the cookie's target scope and solving exit; this result is session clearance rather than a form response token.

string: The full Set-Cookie string DataDome issued: datadome=VALUE; Max-Age=31536000; Domain=.yoursite.com; Path=/; Secure; SameSite=Lax. Set it on your HTTP client for the target domain. IP-bound — replay from the same proxy IP.
string: The bare datadome cookie VALUE (no attributes) — for integrations that read a generic .token field.

POST /getTaskResult · example response

{
  "errorId": 0,
  "status": "ready",
  "solution": {
    "cookie": "datadome=<long opaque value>; Max-Age=31536000; Domain=.example.com; Path=/; Secure; SameSite=Lax",
    "token": "<long opaque datadome cookie value, IP-bound>"
  }
}

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

Continue with the original DataDome identity

Install the returned datadome token as a cookie. Continue with task.userAgent and the same session/proxy; this task does not document a returned userAgent field.

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

sol = result["solution"]
from urllib.parse import urlsplit
session.cookies.set("datadome", sol["token"], domain=urlsplit(task["websiteURL"]).hostname, path="/")
session.headers["User-Agent"] = task["userAgent"]
response = session.get(task["websiteURL"], timeout=30)
print(response.status_code)

When something doesn't work.

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

When do I use this vs DataDomeSlider?

Use DataDomeInterstitial for the full-page 'device check' / 'Please wait…' screen (the geo.captcha-delivery.com/interstitial/ flow) — there's no puzzle, so we just run DataDome's JS and collect the cookie. Use DataDomeSlider when you get the draggable slider/click puzzle. Both return the datadome cookie.

How do I make it more reliable?

It comes down to the exit IP. DataDome scores IP reputation heavily, so use a sticky, high-reputation residential or mobile proxy. Send just the websiteURL (we load the page and let the device check issue the cookie) and the same userAgent you'll replay with — keep requesting from that same exit IP.

Integration checks for DataDome Interstitial

The datadome cookie is IP-bound. Reuse the same proxy for the solve and for subsequent requests.
Supply the original userAgent and keep it on every follow-up request. The cookie is bound to that identity and the solving proxy exit. This task documents cookie/token in the solution; retain task.userAgent rather than expecting a returned identity.

Connect DataDome Interstitial to your workflow.

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

Get an API key Full API documentation

$2.00Per 1,000 solves

9.1sAverage solve time

DataDomeInterstitial · Live configuration