# Akamai Unblocker — bypass Akamai Bot Manager, get cookies (`xhrdev/akamai-unblocker`) Actor

Clear Akamai Bot Manager and keep the cookies. Returns the real page plus the \_abck clearance cookies your own scraper can reuse. Powered by xhr.dev.

- **URL**: https://apify.com/xhrdev/akamai-unblocker.md
- **Developed by:** [xhrdev](https://apify.com/xhrdev) (community)
- **Categories:** Developer tools, Automation
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$9.00 / 1,000 akamai clearances

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Akamai Unblocker

**Clear Akamai Bot Manager and keep the cookies.** Give this Actor a list of URLs and it returns the real page plus the `_abck` clearance cookies that unlocked it — so your own scraper can carry on from there without solving anything again.

A solve typically takes **11 to 18 seconds** and ends with `_abck` in its accepted `~0~` state, alongside the `ak_bmsc`, `bm_sz` and `bm_sv` cookies Akamai issues with it. It is powered by [**xhr.dev**](https://xhr.dev), a challenge solver that normally runs as a Docker container inside your own network. This Actor talks to a hosted trial of it, so you can try it before you host anything.

### Why use Akamai Unblocker?

**It gives you a cookie, not just a page.** Akamai does not gate the front door — it serves its sensor script on an ordinary HTTP 200 and gates the endpoints *behind* it. A landing page returning 200 tells you nothing about whether you can reach the account pages, the search API, or the checkout flow. What gets you in there is an accepted `_abck`, and that is what this returns.

**It knows the difference between "not blocked" and "no Akamai".** Point it at a URL with no Akamai in front of it and it tells you so in under a second, instead of launching a browser and grinding through a two-minute deadline to discover there was never anything to solve. Protection usually lives on a portal or account subdomain rather than the public site — `edd.ca.gov` runs Microsoft-IIS, while `portal.edd.ca.gov` sits behind AkamaiGHost — and this Actor says which one you gave it.

**It runs a real browser, because that is what works.** Solving Akamai server-side means the sensor requests carry the solver's TLS fingerprint rather than a browser's. Against a target that checks the submitting client, the payload gets built correctly and then simply never accepted — the solve ends in an acceptance timeout with nothing naming the cause. This Actor drives Chrome and relays each sensor request through it, which is what actually gets `_abck` to `~0~`.

**No proxy required.** Unlike DataDome work, Akamai relays its sensors through the browser this Actor drives, so there is nothing to route. Use a proxy when you want a specific geography or a fresh address — not because the solve needs one.

### How to use Akamai Unblocker

1. Click **Try for free**.
2. Pick the sites you want from the **Sites** dropdown. The default is Comcast Business, a live Akamai target you can use to watch the flow work.
3. Leave the proxy off unless you need a particular exit country.
4. Click **Start**. The log names each URL as it is checked, solved, and accepted.
5. Take the results from the **Output** tab. The `cookieHeader` field is ready to send as-is.

### Input

| Field                  | Type    | Default              | What it does                                                                   |
| ---------------------- | ------- | -------------------- | ------------------------------------------------------------------------------ |
| `startUrls`            | array   | a live Akamai target | The pages you want. Up to 25 per run on the shared trial solver.               |
| `proxyConfiguration`   | object  | off                  | Optional. Akamai needs no proxy; use one for geography or a fresh IP.          |
| `returnHtml`           | boolean | `true`               | Include the unblocked page's full HTML.                                        |
| `returnCookies`        | boolean | `true`               | Include the full cookie jar and a ready-to-send `Cookie` header.               |
| `skipWhenUnchallenged` | boolean | `false`              | Skip the solve when a URL is not actively blocked. Off by default — see below. |
| `maxRetries`           | integer | `2`                  | Attempts per URL, each with a fresh browser context.                           |
| `maxConcurrency`       | integer | `2`                  | URLs at once. Each concurrent solve is a browser context, so keep it low.      |
| `timeoutSecs`          | integer | `150`                | How long one solve gets to reach an accepted `_abck`.                          |

### Output

You can download the dataset in various formats such as JSON, HTML, CSV, or Excel.

```json
{
    "url": "https://portal.edd.ca.gov/WebApp/Login",
    "succeeded": true,
    "akamaiDetected": true,
    "challenged": false,
    "accepted": true,
    "finalUrl": "https://portal.edd.ca.gov/WebApp/Login",
    "title": "Login",
    "cookies": { "_abck": "0Xt...~0~...", "ak_bmsc": "...", "bm_sz": "...", "bm_sv": "..." },
    "cookieHeader": "_abck=0Xt...~0~...; ak_bmsc=...; bm_sz=...",
    "attempts": 1,
    "durationMs": 9204,
    "error": null,
    "errorType": null
}
```

#### Data fields

| Field            | Type    | Description                                                                                |
| ---------------- | ------- | ------------------------------------------------------------------------------------------ |
| `url`            | string  | The URL that was requested.                                                                |
| `succeeded`      | boolean | Whether the URL was delivered — cleared, or served with no Akamai in front of it.          |
| `akamaiDetected` | boolean | Whether Akamai is actually in front of this URL. `false` means there was nothing to solve. |
| `challenged`     | boolean | Whether Akamai was actively blocking the address when we arrived.                          |
| `accepted`       | boolean | Whether `_abck` reached its accepted `~0~` state. This is the one that matters.            |
| `finalUrl`       | string  | Where the browser ended up, after any redirects.                                           |
| `title`          | string  | The page's `<title>`.                                                                      |
| `cookies`        | object  | The full cookie jar, including `_abck`, `ak_bmsc`, `bm_sz` and `bm_sv`.                    |
| `cookieHeader`   | string  | The same jar, ready to send as a `Cookie` header.                                          |
| `html`           | string  | Full HTML of the unblocked page, when `returnHtml` is on.                                  |
| `attempts`       | number  | How many tries this URL took.                                                              |
| `durationMs`     | number  | Wall-clock time for this URL, including retries.                                           |
| `errorType`      | string  | Machine-readable reason when `succeeded` is false, or `null`.                              |

### Which sites are supported

You pick sites from a **dropdown**, not a free-text box, and anything outside the list is refused before the run starts. That matters more here than for an HTTP-based unblocker: work against an unsupported target is not cheap — it holds a browser open for the full timeout rather than failing fast. Refusing at the door is cheaper and more honest.

**Supported:** Comcast Business · California EDD e-Services · United Airlines

Each clears `_abck` to its accepted `~0~` state on the first attempt, in every verification run, in 7-13 seconds.

The bar is deliberately strict. Sites that clear only some of the time are left off: a target that works *most* of the time is exactly what erodes a published success rate, and we would rather under-promise than have you discover the variance yourself.

**Need a site that is not listed?** [Tell us](https://xhr.dev) — the list grows on request, and that is the most useful thing you can ask us for.

### Reading the results## Reading the results

**`accepted: true` is the success signal**, not `succeeded` alone. The second field of `_abck` is Akamai's own verdict: `~0~` means the cookie is good, and `~-1~` means the rounds ran and never landed — usually the exit IP rather than the payload.

**`akamaiDetected: false` is not a failure.** It means you pointed at a URL Akamai is not protecting, and the page was returned without a solve. If you expected a challenge, check whether the protection sits on a different subdomain.

**`errorType: "acceptance_timeout"`** means clearance was not reached within the deadline. Usually the exit address rather than the payload — add a proxy and retry, or raise `timeoutSecs`.

### Cookies are bound to the IP that earned them

Akamai binds clearance to the address that solved, so **reuse the `cookieHeader` from the same exit IP**. If you run this Actor with a proxy and then retry from somewhere else, you get a fresh block that looks exactly like a failed solve. When no proxy is set, everything leaves from the Actor's own container address — which is fine, provided your follow-up requests come from there too, or you carry the cookies into a scraper that runs alongside it.

### How much does it cost?

Each solve launches a browser and takes roughly 7 to 15 seconds, so this Actor is heavier than a plain HTTP scrape and much lighter than a full stealth-browser crawl. Cost scales with the number of URLs solved, not with page weight. Two things reduce it: turning off `returnHtml` if you only want cookies, and turning on `skipWhenUnchallenged` if you only want pages that are not gated.

One cookie can cover a whole crawl. The cheapest way to use this is to solve once and carry the `cookieHeader` into your own scraper, rather than solving per page.

### FAQ

**Which sites does this work on?** The three in the dropdown. The sensor protocol is broadly the same everywhere, but "broadly" is not a promise, so this Actor only runs against targets verified end to end. The list grows on request.

**Does it handle DataDome?** Not here. That is a separate Actor, [**DataDome Unblocker**](https://apify.com/store), which needs no browser at all and clears a challenge in about four seconds.

**Why is there a 25-URL cap?** This Actor is pointed at a shared trial container that queues Akamai sessions, and each solve costs a browser. If you need volume, you want your own container — [get in touch](https://xhr.dev).

**Can I run the solver myself?** Yes, and that is the actual product. xhr.dev ships as a Docker container that runs on your own infrastructure: your traffic goes to the target directly, and neither your cookies nor your tokens are sent to a third party. Flat fee, unlimited solves, works air-gapped. See [xhr.dev](https://xhr.dev) and the [docs](https://docs.xhr.dev).

**Where are the integration examples?** [github.com/xhrdev/examples](https://github.com/xhrdev/examples) has the Akamai browser bridge written out in full, plus an MCP server so an LLM agent can solve a challenge inside its own loop.

**Is scraping legal?** Scraping publicly available data is broadly legal in many jurisdictions, but you are responsible for what you collect and how you use it — respect the target's Terms of Service, do not gather personal data without a lawful basis, and do not overload the sites you scrape.

### Support

Found a bug or want a target supported? Open an issue on the **Issues** tab. For a self-hosted deployment or higher limits, reach us through [xhr.dev](https://xhr.dev).

# Actor input Schema

## `sites` (type: `array`):

The Akamai-protected sites to clear. This Actor only runs against sites verified end to end — each one below clears \_abck to its accepted ~0~ state on the first attempt, in every verification run. The list grows on request.

## `proxyConfiguration` (type: `object`):

Optional. Akamai relays its sensors through the browser this Actor drives, so there is nothing to route and no proxy is required — unlike the DataDome path. Use one when you need a specific geography, or a fresh address after a burn. Clearance cookies are bound to the exit IP that earned them, so reuse them from the same session.

## `returnHtml` (type: `boolean`):

Include the full HTML of the unblocked page in each dataset item.

## `returnCookies` (type: `boolean`):

Include the full cookie jar (\_abck, bm\_sz and friends) and a ready-to-send Cookie header.

## `skipWhenUnchallenged` (type: `boolean`):

Off by default, and the default is the one you usually want. Akamai serves its sensor script on an ordinary HTTP 200 and gates only the endpoints behind it, so a landing page returning 200 tells you nothing about whether you can reach the protected pages — you still need an accepted \_abck. Leave this off to always earn the cookie. Turn it on if you only want HTML from pages that are not gated, and want to skip the browser launch.

## `maxRetries` (type: `integer`):

How many times to try a URL before giving up. Each attempt takes a fresh browser context, and a fresh proxy session if a proxy is configured.

## `maxConcurrency` (type: `integer`):

How many URLs to work on at once. Each concurrent solve is a browser context, so keep this low — the solver also queues Akamai sessions.

## `startUrls` (type: `array`):

Optional. Exact pages to clear, instead of each site's default page. Every URL must be on one of the supported domains above, or it is refused before the run starts.

## `targetPolicy` (type: `string`):

Verified only (the default) refuses any URL outside the supported list, before the run starts. That matters here more than for HTTP-based unblockers: work against an unsupported target does not fail fast, it holds a browser open for the full timeout on every attempt. Need a site added? Ask at https://xhr.dev.

## `timeoutSecs` (type: `integer`):

How long one solve gets to reach an accepted \_abck. A cold solve can take 60s; raise this before lowering it.

## Actor input object example

```json
{
  "sites": [
    "comcast.com"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  },
  "returnHtml": true,
  "returnCookies": true,
  "skipWhenUnchallenged": false,
  "maxRetries": 2,
  "maxConcurrency": 2,
  "targetPolicy": "verified-only",
  "timeoutSecs": 150
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "sites": [
        "comcast.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("xhrdev/akamai-unblocker").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "sites": ["comcast.com"] }

# Run the Actor and wait for it to finish
run = client.actor("xhrdev/akamai-unblocker").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "sites": [
    "comcast.com"
  ]
}' |
apify call xhrdev/akamai-unblocker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,xhrdev/akamai-unblocker"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/raxu67rZnd3HY1Mzo/builds/LXpnpf7svyRLcXlr0/openapi.json