Akamai Web Unlocker

Request the page. Receive its resolved HTML. Describe the protected HTTP action Capzy should perform after clearing the page. The result is that action's HTML and HTTP metadata.

Get the integration code

POST /createTask · example

{
  "clientKey": "capzy_YOUR_API_KEY",
  "task": {
    "type": "AkamaiWebUnlockerTask",
    "websiteURL": "https://example.com/",
    "request": {
      "path": "/search",
      "method": "POST",
      "form": {
        "q": "query"
      }
    },
    "proxyType": "http",
    "proxyAddress": "123.45.67.89",
    "proxyPort": "8080",
    "proxyLogin": "user",
    "proxyPassword": "pass"
  }
}

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

Target URL + request options + proxyYour session proxy requiredHTML + final URL + HTTP status

Describe the page request.

Describe the protected HTTP action Capzy should perform after clearing the page. The result is that action's HTML and HTTP metadata.

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

Read path, method, and form fields.

In Network, perform the action your workflow needs and select its request. Copy the site's base/page URL into websiteURL.
Copy the request's relative path, including relevant query parameters, into request.path and its Request Method into request.method.
For a form POST, read the Payload panel and preserve the field names and values in request.form.

Input collection example - replace illustrative values

{
  "websiteURL": "https://example.com/",
  "request": {
    "path": "/search",
    "method": "POST",
    "form": {
      "q": "YOUR_QUERY"
    }
  }
}

request is a JSON object. It describes the action the solver will execute, so use that endpoint's real input contract.

How Akamai Web Unlocker works

The Akamai Web Unlocker runs your protected request end-to-end instead of just returning a cookie. You give it the target URL and the request you want to make (path, method, form fields); it clears Akamai Bot Manager (mints a validated _abck), submits your request, solves a sec-cpt proof-of-work if one fires, and hands back the final HTML — the actual result of your action, not just clearance.

We launch a real browser through your sticky proxy, rotate sessions until an IP clears Bot Manager, run the minting navigation, then submit your request via an in-page fetch — solving the sec-cpt PoW inline if Akamai returns a 428. You get the final response HTML, status, and URL. A sticky proxy you control is required because Akamai binds the cleared session to its egress IP.

End-to-end: mints _abck, submits your request, solves sec-cpt, returns the page
Returns final HTML — no cookie replay or TLS matching on your side
Solves the sec-cpt proof-of-work inline when Akamai escalates
Runs through your sticky proxy for IP-consistent clearance

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 Akamai-protected site/base URL to clear and act on

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": "AkamaiWebUnlockerTask",
    "websiteURL": "https://example.com/",
    "request": {
      "path": "/search",
      "method": "POST",
      "form": {
        "q": "query"
      }
    },
    "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
Inspect solution.status, solution.finalUrl, and solution.redirected before parsing solution.html. The returned HTML is the executed action's document; it is not a response token to submit elsewhere.

AkamaiWebUnlockerTask · Price unavailable / 1,000

solve_akamai_web_unlocker.py

import json, os, time
import requests

API = "https://api.capzy.ai"
KEY = os.environ["CAPZY_API_KEY"]
task = json.loads("{\"type\":\"AkamaiWebUnlockerTask\",\"websiteURL\":\"https://example.com/\",\"request\":{\"path\":\"/search\",\"method\":\"POST\",\"form\":{\"q\":\"query\"}},\"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.

HTML + final URL + HTTP status

Inspect solution.status, solution.finalUrl, and solution.redirected before parsing solution.html. The returned HTML is the executed action's document; it is not a response token to submit elsewhere.

string: The final HTML response after clearing Akamai and running your request — parse this directly, no cookie replay needed
number: HTTP status of the final response
string: Final URL (may differ from the submitted one after redirects)
boolean: Whether a redirect occurred while running the request

POST /getTaskResult · example response

{
  "errorId": 0,
  "status": "ready",
  "solution": {
    "html": "<html>...<body>Search results...</body></html>",
    "status": 200,
    "finalUrl": "https://example.com/search?q=query",
    "redirected": false
  }
}

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

Read the page

The Web Unlocker runs your protected request end-to-end, so the result IS the final page HTML — there's no token or cookie to replay.

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


# Step 3 — the unlocker already ran your request; the final page is in "html"
sol = result["solution"]
print(sol["status"], sol["finalUrl"])   # e.g. 200  https://.../Results
html = sol["html"]                       # parse this directly — no cookie replay needed
# from bs4 import BeautifulSoup; soup = BeautifulSoup(html, "html.parser")

When something doesn't work.

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

How is this different from Akamai Web (cookies)?

Akamai Web returns the _abck cookie set for you to replay yourself (and you must match TLS/UA). The Unlocker runs the whole request for you inside the cleared browser and returns the final HTML — no cookie replay, no TLS fingerprint matching on your end.

Why does it need a sticky proxy?

Akamai binds the cleared session to its egress IP. The unlocker rotates sticky sessions until one clears Bot Manager, then keeps that IP for the request — a rotating proxy would drop the session mid-flow.

Integration checks for Akamai Web Unlocker

A sticky proxy is REQUIRED — Akamai binds the cleared session to its IP, and the unlocker rotates sticky sessions until one clears. Rotating/per-request proxies won't hold the session.
Describe the request precisely (path, method, form). The unlocker performs exactly that action inside the cleared session and returns its result.

Connect Akamai Web Unlocker to your workflow.

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

Get an API key Full API documentation

UnavailablePer 1,000 solves

UnavailableAverage solve time

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