Skip to content
capzy
Login

DataDome Slider

Solve the slider in the session you will continue. The browser slider flow starts from the protected page. Supply the User-Agent and proxy your continued request will use.

Get the integration code
POST /createTask · example
{
  "clientKey": "capzy_YOUR_API_KEY",
  "task": {
    "type": "DataDomeSlider",
    "websiteURL": "https://www.example.com/",
    "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.

Protected URL + user-agent + proxyYour session proxy requiredDataDome cookie + user-agent

Prepare the protected slider session.

The browser slider flow starts from the protected page. Supply the User-Agent and proxy your continued request will use.

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

Use the page that triggered the slider.

  1. Open Network and select the original document request before the DataDome redirect. Copy that URL into websiteURL.
  2. Read User-Agent from its Request Headers and send that value in userAgent. This field is required for this task.
  3. Keep the original application session ready for the returned cookie; the browser task navigates the page to obtain its challenge.
Input collection example - replace illustrative values
{
  "websiteURL": "https://example.com/account",
  "userAgent": "YOUR_CURRENT_USER_AGENT"
}

A captured captchaUrl is not required by this browser flow. The captured HTTP-cookie flow has its own guide.

How DataDome Slider works

DataDome runs ~85,000 per-customer ML models and is widely considered the hardest anti-bot system in the industry. It scores behavior + IP reputation + TLS/JA3 fingerprint, with the slider being only the visible tip. Deployed on major e-commerce, ticketing, and travel sites where low-reputation IPs almost always fail.

Send the protected websiteURL, your userAgent, and a sticky session proxy. We navigate that page through your proxy, solve the DataDome challenge, and return the datadome cookie plus the userAgent used. Install the cookie and continue the protected request through the same exit IP and identity. The separate DataDome Cookie task provides its own HTTP-based flow and availability; use that product's guide for its inputs.

  • Uses your sticky session proxy so the returned cookie matches your replay exit
  • Capzy proprietary infrastructure — high-quality solves
  • Solves the slider challenge reliably
  • Handles slider, click, and interstitial challenge variants
  • Loads the protected page directly and solves whatever DataDome serves (slider or device check) — no captchaUrl to capture
  • Fast-fail on hard-blocked IPs (t=bv) — returns ERROR_IP_BLOCKED in <1s instead of hanging
  • Captures cookie directly from DD's /check response — works even when the challenge runs out-of-iframe
  • Returns 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.

Send the websiteURL you want to reach and the userAgent you'll replay with. We load the page and solve whatever DataDome serves — no captchaUrl needed.

Request authentication

Required task inputs

Optional context

Proxy connection

websiteURL

stringRequired

The protected URL you want to reach. This is the primary input — our solver loads this page itself in a real browser (bound to your proxy exit) and solves whatever DataDome serves there (slider or device check). Pair it with a sticky proxy and replay from the same exit IP + userAgent.

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://www.example.com/
POST /createTask · selected configuration
{
  "clientKey": "capzy_YOUR_API_KEY",
  "task": {
    "type": "DataDomeSlider",
    "websiteURL": "https://www.example.com/",
    "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
  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 solution.cookie or its token value as datadome in the original session. Keep the same proxy and browser identity for the protected request; do not replace the whole cookie jar with one cookie.

DataDomeSlider · $2.00 / 1,000
solve_datadome.py
import json, os, time
import requests

API = "https://api.capzy.ai"
KEY = os.environ["CAPZY_API_KEY"]
task = json.loads("{\"type\":\"DataDomeSlider\",\"websiteURL\":\"https://www.example.com/\",\"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 cookie + user-agent

Install solution.cookie or its token value as datadome in the original session. Keep the same proxy and browser identity for the protected request; do not replace the whole cookie jar with one cookie.

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.
string
The User-Agent the cookie is bound to. You MUST replay your requests with this exact User-Agent (and the same proxy IP) or DataDome rejects the cookie.
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>",
    "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 solution.cookie or its token value as datadome in the original session. Keep the same proxy and browser identity for the protected request; do not replace the whole cookie jar with one cookie.

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.

Why is DataDome so hard compared to Akamai or Imperva?

DataDome trains a separate ML model per customer site (~85,000 in production) using that site's traffic. Approaches that work on one Akamai deployment don't transfer the same way for DataDome — every site is its own classifier.

Should I use my own proxy?

Yes for mission-critical workflows. A high-reputation IP you control gives the best results on DataDome. Send DataDomeSlider with proxyType + proxyAddress to use your own.

DataDomeSlider keeps failing — how do I make it more reliable?

It's almost always the exit IP. DataDome scores IP reputation heavily, so use a sticky, high-reputation residential or mobile proxy (DataDomeSlider with your own proxy). Make sure the userAgent matches what you'll replay with, and keep requesting from the same exit IP. You only send websiteURL — no captchaUrl, no cookie.

What does ERROR_IP_BLOCKED mean?

DD has flagged the proxy IP as too risky to serve any challenge. Either the URL was issued with t=bv (instant hard-block) or the puzzle DOM rendered with zero height (soft-block). Retry with a different proxy — preferably a different high-reputation exit.

When do I use DataDomeInterstitial vs DataDomeSlider?

Use DataDomeInterstitial when you hit the full-page 'device check' / 'Please wait…' interstitial (the geo.captcha-delivery.com/interstitial/ flow). It runs its own dedicated path: there's no puzzle, so we just run DataDome's challenge JS in a real browser and collect the cookie — typically faster and cheaper than the slider. Use DataDomeSlider when you get the draggable slider/click puzzle. Both return the datadome cookie and accept the same proxy params.

What's the difference between DataDomeSlider and AntiDataDomeTask?

DataDomeSlider drives a real browser (Playwright) and is the recommended, generally-available path — it handles slider, click, and interstitial. AntiDataDomeTask is a fast path that generates the datadome cookie purely over HTTP (device link → signed payload → /check): much faster and lighter, covering interstitial and slider. It's currently in closed beta while we harden the payload signer against DataDome's rotation; until it's generally available, use DataDomeSlider.

Do I send the captchaUrl or the page HTML to the fast path?

Either. AntiDataDomeTask accepts captchaUrl (the geo.captcha-delivery.com URL from the blocked iframe) or html (the raw 403 challenge body containing the dd object). Send the existing datadome cookie too (datadomeCookie or the cookies array) for visitor continuity — it materially raises success rate.

Integration checks for DataDome Slider
  • DataDome is the hardest anti-bot system on the market. Realistic success rate is 50-65% on enterprise sites — well below what you'd see on Akamai or Imperva. For mission-critical workflows, supply your own high-reputation proxy via DataDomeSlider.
  • Send us the websiteURL — the protected page you want to reach. That's all we need: our solver loads the page itself in a real browser and solves whatever DataDome serves (slider or device check). You do NOT need a captchaUrl — a captured geo.captcha-delivery.com URL is bound to the session/IP that produced it, so it's stale from a different exit and is ignored.
  • Use a sticky proxy and keep requesting from the same exit IP. DataDome binds the cookie to the exit IP + User-Agent, so reuse both on every follow-up request. (No captchaUrl or cookie to send — just the websiteURL.)
  • Cookies are IP-bound. The datadome cookie we return is tied to the exit IP it was solved on — reuse the same proxy on subsequent requests, using the same proxy you supplied to the task.
  • userAgent must match. DataDome binds the cookie to the User-Agent (and IP). Send us the SAME userAgent you'll replay your requests with. We support modern Chrome on Windows (Chrome 120–149, Windows NT 10.0); if you omit it we use a current Chrome-on-Windows UA and return it in the solution — replay with that exact value. DataDomeSlider returns the userAgent; for DataDomeInterstitial retain the userAgent you submitted.
  • Pick the task type for the challenge the site shows: a draggable slider/click puzzle → DataDomeSlider; a full-page 'device check' / 'verifying your browser' interstitial → DataDomeInterstitial. Both take just websiteURL + userAgent + a proxy.

Connect DataDome Slider 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.7sAverage solve time

DataDomeSlider · Live configuration