Akamai SBSD solver API

Akamai Bot Manager serves an sbsd script to sessions it distrusts. Send us that script and we return the payload that answers it. You post it from your own session, and Akamai sets bm_s, bm_sc and bm_so.

Price
from €1.00 per 1,000 solves€2.50 before level discounts
Speed
About 1 second
You send
The challenge script, the page and your cookies
You get
A payload to post from your own session
Failed solves
Free

What the SBSD challenge is

SBSD sits in front of the page. When Akamai is unsure about a session, the HTML it returns carries a script tag whose address looks like /path?v=<uuid>. The browser runs that script, which collects a description of the browser and posts it back. If Akamai accepts the answer, the session gets its bm_s, bm_sc and bm_so cookies and the real page loads.

It comes in two forms, and they need a different number of posts:

Block pagePassive page
What you seeA challenge page instead of the contentThe real page, with the script running in the background
Script address?v=<uuid>&t=…?v=<uuid>, no t
Posts neededOneTwo: the payload, then a follow-up once it is accepted

Both forms are one solve and one charge. The response tells you whether a follow-up is needed.

Five requests, four of them yours

The site only ever talks to your session. We never touch it, so there is no proxy to hand over and no IP to match afterwards.

  1. Load the protected page with a Chrome client. Find the script tag whose address ends in ?v=<uuid>.
  2. Download that script with the same session and user agent. It is about 500 KB and changes on every load.
  3. Send it to notabot with the page HTML, your cookies and your user agent. About a second later you have the payload.
  4. Post the payload to the address we return, as {"body": payload}. On a passive page, post the follow-up the same way.
  5. Request the page again. If the site lets you through, the cookies in your session are good.
The five requests
// "http" is any client with a real Chrome TLS fingerprint and a cookie jar.
const UA = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/156.0.0.0 Safari/537.36";

const page = await http.get(url, { headers: { "user-agent": UA } });        // 1. the challenged page
const m = page.text.match(/<script[^>]*src="(/[^"]*?v=([0-9a-f-]{36})[^"]*)"/i);
const [scriptPath, query] = m[1].replace(/&amp;/g, "&").split("?");
const t = new URLSearchParams(query).get("t");                              // absent on a passive page
const script = await http.get(origin + m[1].replace(/&amp;/g, "&"), { headers: { "user-agent": UA, referer: url } });  // 2. the script

const solved = await notabot({                                              // 3. us
  type: "akamai.sbsd.payload", script: script.text, uuid: m[2], path: scriptPath, t,
  pageUrl: url, cookieHeader: http.cookies(), html: page.text, userAgent: UA,
});

const { payload, followup, postUrl } = solved.result;
await http.post(postUrl, { headers: { "user-agent": UA, "content-type": "application/json" }, body: JSON.stringify({ body: payload }) });   // 4. send it
if (followup) await http.post(followup.postUrl, { headers: { "user-agent": UA, "content-type": "application/json" }, body: JSON.stringify({ body: followup.payload }) });
const final = await http.get(url, { headers: { "user-agent": UA } });       // 5. the real page
What we return
{
  "ok": true,
  "requestId": "req_Hk2p…",
  "result": {
    "payload": "…",
    "followup": null,
    "postUrl": "https://shop.example.com/brLNyUZQ…/oI1Yb?t=642368385",
    "userAgent": "Mozilla/5.0 (Macintosh; …) Chrome/156.0.0.0 Safari/537.36",
    "profile": "macos-156",
    "solveMs": 186
  },
  "cost": 0.0015,
  "costMicro": 1500,
  "solveMs": 186
}

Full request and response reference: Akamai SBSD payload docs.

What makes a solve stick

One session, start to finish

The payload belongs to the session, not the IP. Post it with the same cookies, user agent and TLS fingerprint you downloaded the script with.

A fresh script every time

The script changes between loads and the payload only matches the copy you sent. Reusing an old one is the usual cause of NOT_CHALLENGED.

A client that looks like Chrome

Use current Chrome with its real TLS fingerprint and sec-ch-ua headers. Akamai turns old Chrome and plain HTTP libraries away at the first request.

Not SBSD? The other Akamai gates

Edge screen

  • A flat “Unusual Traffic Detected” page with no challenge script, decided from your headers and TLS alone before SBSD is considered.

Sensor data

  • Pages that validate _abck from sensor posts. A separate solver, not live yet.

What you send, field by field

One JSON body to POST /v1/solve, up to 2 MB. Fields not listed are dropped.

FieldRequiredWhat it is
scriptYesThe challenge script exactly as downloaded. About 500 KB; the limit is 1,000,000 characters.
uuidYesThe v= value of the script address.
pathYesThe script path, starting with /, without the query.
tOn a block pageThe t= value of the script address. Leave it out on a passive page.
pageUrlYesThe page you loaded. Its domain must be approved, and the address you post the payload to is built from it.
userAgentSend itThe exact Chrome user agent your requests use. Left out, the newest supported one is assumed.
cookieHeaderNoYour session cookies as one cookie header value, up to 8,192 characters.
htmlNoThe page HTML you received, up to 400,000 characters.
acceptLanguageNoYour browser’s language header. Default en-US,en;q=0.9. Send what your requests send.
timezoneNoAn IANA name such as Europe/Berlin. Default Europe/London.
deviceNoHardware to present: screen, dpr, hardwareConcurrency, deviceMemory, platformVersion. Unknown fields are refused.

The browser the payload describes

An sbsd answer is a description of a browser, so it has to agree with the browser making your requests. That is why the user agent matters more here than anywhere else: the payload is built for one specific Chrome version, and it has to match the headers and TLS handshake of the client that posts it.

Send the frozen Chrome-on-macOS user agent for one of the supported versions (145, 148, 155 or 156 today) and use that same string on every request of the flow. Anything else is refused before solving, with the supported list in the message, and is not charged. Language, timezone and the optional device fields let the payload match the rest of your client, so set them to what your requests actually send.

Sites turn old Chrome away at the very first request, so use the newest version. The list moves up as Chrome ships; the changelog records each change.

When a solve fails

A failed solve is never charged. The response names the reason, and each one has a specific fix.

ReasonWhat it meansWhat to do
NOT_CHALLENGEDThe script, the v= value and the t= value do not come from the same page load.Download the script fresh and send the uuid and t from that same response.
UNSUPPORTED_PROFILEakamai.sbsd.payload only. The userAgent is not one of the supported Chrome versions. The message lists them.Use one of the Chrome versions listed in the message, on every request.
BAD_INPUTakamai.sbsd.payload only. A browser field (acceptLanguage, timezone or device) is invalid. The message says which.Fix the field the message names, or leave it out to use the default.
domain_not_allowedThe domain of pageUrl is not approved for your account yet.Request the site on the Sites page. Subdomains of an approved domain are covered.
bad_paramsA required field is missing or invalid, or the body is too large.Check the field the message names. The whole body must stay under 2 MB.
SOLVER_ERRORThe solver hit a case it could not handle. Retry once; if it repeats, send us the requestId.Retry once. If it repeats, send us the requestId.

If the payload is accepted but the page still blocks you, the cause is on the session: a different user agent, a client without a Chrome TLS fingerprint, or a flagged IP. Every code and reason: error reference.

Akamai SBSD payload pricing

€2.50 per 1,000 successful solves, and less as your lifetime top-ups grow. No subscription, credits never expire, and a solve that fails is not charged.

Akamai SBSD payload, per 1,000 solves
Topped up in totalLevelYou pay
Under €100List price€2.50
From €100−20%€2.00
From €250−30%€1.75
From €500−40%€1.50
From €1,000−50%€1.25
From €2,500−55%€1.125
From €5,000−60%€1.00
  • Top up from €10 by card. The balance works for every solver.
  • A level counts everything you have ever topped up, and it never drops.
  • The price is reserved when you call and released if the solve fails.
  • Each key can carry its own daily, monthly or total spend limit.
Pricing calculator

An API call instead of a headless browser

notabot APIHeadless browser
What you runOne HTTPS requestA Chrome instance per session, plus the servers under it
When the protection updatesWe patch the solver. Your code is unchangedYou patch stealth plugins and redeploy
What you pay forSuccessful solves onlyCPU, memory and bandwidth, whether or not the page passes
Scaling upSend more requestsAdd more machines

Akamai SBSD solver: questions

What is Akamai SBSD?

SBSD is a challenge Akamai Bot Manager serves to sessions it does not trust yet. The page loads a challenge script, the browser runs it and posts the answer back, and Akamai then sets the bm_s, bm_sc and bm_so cookies that let the session through.

How do I know a site is using SBSD?

Look at the HTML you get back. A challenged page contains a script tag whose address ends in ?v= followed by a UUID, with an extra &t= value when it is a block page. Cookies named bm_s, bm_so or bm_sc in your jar are the other sign.

Do I need a browser?

No. You download the challenge script, send it to notabot, and post the payload we return. You do need an HTTP client with a real Chrome TLS fingerprint and the matching sec-ch-ua headers, because Akamai rejects a plain Node, Python or Go client before any payload matters.

Do I send you my proxy?

No. You make every request to the site yourself, from your own session and IP. We only see the script, the page and the cookies you send us, and we return the payload.

How fast is it and what does it cost?

About one second, nearly all of it uploading the script. It costs €2.50 per 1,000 successful solves at list price and €1.00 at the top discount level. A solve that fails is not charged.

Which user agents are supported?

Current desktop Chrome on macOS. The payload describes a browser, so the user agent you send us must be the exact one your requests use. The docs list the supported Chrome versions.

Why did I get NOT_CHALLENGED?

The script, the v= value and the t= value did not come from the same page load. Download the script fresh for every solve and send the values from that same response. It is not charged, so retry.

What about Akamai sensor data and _abck?

That is a different Akamai gate with its own solver, which is not live yet. If the site answers with a flat "Unusual Traffic Detected" page and no script, that is the edge fingerprint screen, which has its own product.

Guides

Other solvers

Page updated . Reference for every solver: documentation.

Try it on your own target.

Login, copy a key, send one request. If the solve fails, it costs you nothing.

Akamai SBSD solver API (bm_s, bm_so) | notabot