Akamai Solver — Akamai Session Cookies per URL

One set of Akamai Bot Manager session cookies (_abck, bm_sz, ak_bmsc, bm_sv) per URL for pages protected by an Akamai edge challenge, plus the fetched page. Paste the cookie header into your own HTTP client, browser or pipeline and keep calling the site without solving the challenge yourself.

• One dataset row per URL: the session cookie family (_abck, bm_sz, ak_bmsc, bm_sv), a ready-to-send Cookie header, the credential domain and expiry, and the page body fetched with those cookies.
• Paste cookieHeader straight into a Cookie: header — no extra parsing.
• Cookies are bound to the IP, TLS client profile and user-agent they were issued for on most targets; tokenBinds reports what the credential is bound to when the target publishes it.
• Pay only for rows you receive: $0.55 per 1,000 rows on the Free plan plus a small start fee.

What does Akamai Solver do?

Akamai Solver accepts a list of public page URLs that sit behind an Akamai Bot Manager edge challenge (a session cookie wall served at the CDN layer). For each URL it detects the challenge, obtains the session cookie family (_abck, bm_sz, ak_bmsc, bm_sv), fetches the page with those cookies and writes one dataset row containing the credential and the page.

• Cookies and page (default): every URL in urls produces one row with sessionCookies, cookieHeader, the credential descriptor and body (the fetched page).
• One row per URL: maxResults caps how many URLs are processed in one run.
• No challenge? Still a row: pages that arrive without a challenge still produce one row with credentialNeeded: false.

What data can you extract from Akamai Solver?

Field	Description	Example
url	The input URL	https://www.example.com/
statusCode	HTTP status of the fetch after the cookie was applied	200
body	Page HTML fetched with the cookies	<!doctype html>…
bodyLen	Byte length of the page before text truncation	209553
sessionCookies	The issued Akamai cookie family (_abck, bm_sz, ak_bmsc, bm_sv)	{"_abck":"…","bm_sz":"…","ak_bmsc":"…"}
cookieHeader	_abck=…; bm_sz=…; ak_bmsc=…, ready to send as a Cookie header	_abck=…; bm_sz=…; ak_bmsc=…
credential	Session credential descriptor object	see Output example
credential.domain	Domain the cookies are valid for	www.example.com
credential.cookieHeader	Same value as cookieHeader	_abck=…; bm_sz=…; ak_bmsc=…
credential.cookies	Array of individual cookie objects	[{"name":"_abck","value":"…"}]
credential.ttlSeconds	Cookie lifetime hint in seconds	86400
credential.issuedAt	When the cookies were issued (UTC)	2026-10-28T12:00:00Z
credential.expiresAt	issuedAt + ttlSeconds (UTC)	2026-10-29T12:00:00Z
tokenIssued	true when cookies were issued for this row	true
tokenBinds	Which caller attributes the credential is bound to	{"ip":"pinned","tls":"any"}
elapsedMs	How long this URL took	2750
rowType	Always page	page

How to use Akamai Solver

1. Open Akamai Solver in Apify Console (a free Apify account is enough to try it).
2. Fill urls with one or more page URLs that sit behind an edge challenge.
3. Leave maxResults small, for example 3, for your first run.
4. Click Start and wait for the run to finish.
5. Read cookieHeader from each row and send it as the Cookie request header on your next requests to that domain.

An empty input runs the sample values from the input form, limited to at most 10 rows, so you can see the output format before spending anything.

What to fill in

Field	What to enter	Default
urls	One or more public page URLs behind an edge challenge	required
maxResults	Most rows this run delivers and charges, one per URL	3
country	Two-letter country code for the outbound connection	empty
proxyGroup	Outbound connection group name	empty

{
  "urls": ["https://www.example.com/"],
  "maxResults": 3
}

• maxResults is the most rows for the whole run, one per URL (maximum 70).
• Unknown fields are ignored; a malformed urls or a non-http(s) address fails the run before any row is charged.
• The INPUT_ECHO record in the run's key-value store shows what the run understood.

Output example

{
  "rowType": "page",
  "entityId": "https://www.example.com/",
  "url": "https://www.example.com/",
  "statusCode": 200,
  "body": "<!doctype html><html>…</html>",
  "bodyLen": 209553,
  "sessionCookies": {
    "_abck": "ABC123~0~YAAQ…",
    "bm_sz": "DEF456~YAAQ…",
    "ak_bmsc": "GHI789…"
  },
  "cookieHeader": "_abck=ABC123~0~YAAQ…; bm_sz=DEF456~YAAQ…; ak_bmsc=GHI789…",
  "credential": {
    "domain": "www.example.com",
    "cookieHeader": "_abck=ABC123~0~YAAQ…; bm_sz=DEF456~YAAQ…; ak_bmsc=GHI789…",
    "cookies": [
      {"name": "_abck", "value": "ABC123~0~YAAQ…", "domain": "www.example.com", "path": "/"},
      {"name": "bm_sz", "value": "DEF456~YAAQ…", "domain": "www.example.com", "path": "/"},
      {"name": "ak_bmsc", "value": "GHI789…", "domain": "www.example.com", "path": "/"}
    ],
    "ttlSeconds": 86400,
    "issuedAt": "2026-10-28T12:00:00Z",
    "expiresAt": "2026-10-29T12:00:00Z"
  },
  "tokenIssued": true,
  "elapsedMs": 2750
}

Export the dataset as JSON, CSV, Excel, XML, RSS or an HTML table. To use the cookies, send cookieHeader as the Cookie request header on requests to credential.domain while credential.expiresAt has not passed.

Why use this Akamai solver?

• Pay per row. You pay for rows written to the dataset, not for URLs tried.
• Partial results are kept. A stopped or timed-out run still delivers and bills only the rows already collected.
• Clear errors. A row that fails carries a reason in error instead of a silent empty result.
• Several URLs per run. Pass a list and get one row each.
• No setup. You do not need proxies, cookies or an account with the target site.

How much does it cost to use Akamai Solver?

The Actor uses pay-per-event pricing: a $0.005 start fee per run and a price per row delivered. Platform usage is included in these prices.

Apify plan	Price per row	Price per 1,000 rows
Free	$0.00055	$0.55
Starter	$0.00055	$0.55
Scale	$0.00055	$0.55
Business	$0.00055	$0.55
Platinum	$0.00055	$0.55
Diamond	$0.00055	$0.55

• maxResults applies to the whole run, one row per URL. Default 3; the maximum is 70.
• Runs on the free Apify plan stop at 200 rows.
• The run never costs more than the Maximum cost per run you set in the run options (maxTotalChargeUsd in the API).
• The Apify Free plan includes $5.00 in monthly usage credit (about 9,090 rows at $0.00055 per row across Free-plan runs capped at 200 rows per run).

Example: 20 URLs → 20 rows → 20 × $0.00055 + $0.005 = $0.016 on the Free plan.

What happens when the run timeout is too short

A run can pause with the status message "Queued on the collection backend; this run will resume automatically when results are ready (about N s)." It temporarily shows ABORTED. When results are ready, the same run resumes, reports "Resumed: delivering N rows.", writes to the same dataset and finishes as SUCCEEDED. Previously delivered rows are not delivered or charged twice.

This can happen at most three times per run. Keep the default timeout to reduce interruptions. The synchronous endpoints run-sync and run-sync-get-dataset-items wait at most 300 seconds and may return an empty dataset while the run is paused. For longer requests, start asynchronously and read the dataset after SUCCEEDED, or use a succeeded-event webhook.

Use with AI agents and the API

Apify MCP server (Claude, ChatGPT, Cursor, VS Code)

Add this Actor as a tool in any MCP client that supports remote servers:

https://mcp.apify.com?tools=lentic_clockss/akamai-solver

Sign in with Apify when the client asks (OAuth), or send the header Authorization: Bearer <YOUR_APIFY_TOKEN>. The tool starts a run and returns the run and dataset IDs; the agent then reads the rows with get-dataset-items. Clients without remote MCP support can run npx @apify/actors-mcp-server --tools lentic_clockss/akamai-solver with the APIFY_TOKEN environment variable.

Example prompt: "Get session cookies for https://www.example.com/."

• Agent execution note: Set maxResults between 5 and 20 on exploratory tool calls to keep responses compact, and read RUN_SUMMARY and INPUT_ECHO from the default key-value store to inspect normalized inputs and delivered row counts. When a long run briefly reports ABORTED with the automatic-resume status message, wait for the same run ID to finish as SUCCEEDED instead of starting a duplicate run.

Apify API

import requests
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("lentic_clockss/akamai-solver").call(
    run_input={"urls": ["https://www.example.com/"], "maxResults": 3}
)
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["cookieHeader"])
    resp = requests.get(item["url"], headers={"Cookie": item["cookieHeader"]}, timeout=30)
    print(resp.status_code, len(resp.text))

Or over HTTP: POST https://api.apify.com/v2/acts/lentic_clockss~akamai-solver/runs with the input as the JSON body and your token in the Authorization: Bearer header, then GET https://api.apify.com/v2/datasets/<datasetId>/items?format=json.

Integrations

Connect the results to Google Sheets, Make, Zapier, n8n, Slack, Airtable or your own webhook from the Integrations tab of the Actor, or schedule regular runs with Apify Schedules.

FAQ

How do I use the cookies?

Send cookieHeader as the Cookie header on requests to credential.domain, or set each cookie from credential.cookies individually. The cookies stay valid until credential.expiresAt.

Are the cookies bound to one address?

Cookies are typically bound to the IP address and TLS client profile they were issued for. tokenBinds reports which caller attributes the credential is bound to when the target publishes that information.

Why did a row have no sessionCookies?

The page arrived without a challenge (tokenIssued is false, credentialNeeded is false) or the issue step failed; such a row still carries statusCode, body when the page was fetched, and error when it was not.

Why did my run end as ABORTED?

A run ends ABORTED when the run timeout you set is shorter than the time the URLs needed, or when the run's charge limit was reached. Rows already collected are still delivered and billed.

How many results can I get?

One row per URL in urls, at most maxResults (maximum 70) per run. Runs on the free Apify plan stop at 200 rows.

Is it legal to use this Actor?

You are responsible for complying with the target site's terms and with data-protection law. Public pages only; personal data needs a lawful basis.

Limitations

• Only public pages that answer an edge challenge at the CDN layer are supported; other kinds of site protection are out of scope.
• The cookies are issued for the domain in the URL and do not transfer to a different site.
• body is truncated at 200,000 characters per row.
• Cookie validity depends on the target site's edge configuration; ttlHintS is an estimate, not a guarantee.

Related solvers and scrapers

More developer and data tools from the same publisher:

• AWS WAF Scraper
• Cloudflare solver
• DataDome Scraper
• Imperva Credential Scraper
• Stealth Web Scraper
• Phone Number Validator
• GitHub Scraper
• Polymarket Scraper

Browse all of our scrapers at apify.com/lentic_clockss.

Support

Found a problem or need another field? Open an issue in the Issues tab of this Actor's page and include the run ID and the input you used.