# notabot API: complete reference for agents > Base URL https://api.notabot.sh/v1 · auth header `x-api-key` · markdown index at https://notabot.sh/llms.txt --- # Overview notabot is a hosted API that solves anti-bot challenges without a browser. You send a protected URL and an HTTP proxy; it returns the cookies and user agent that get you past the challenge. You are charged only for successful solves. ## Integration in five lines 1. Log in with Discord at https://notabot.sh/app, create an API key on the Keys page (`nab_live_…`, shown once). 2. Request the target domain on the Sites page. A human approves it once. Until then the API answers `domain_not_allowed` (free). Subdomains are covered by their parent domain. 3. Top up on the Billing page (min €10). You are billed only for successful solves. 4. `POST https://api.notabot.sh/v1/solve` with header `x-api-key` and a JSON body `{ "type", "url", "proxy" }`. 5. Send `result.cookies` and `result.userAgent` on your own requests, through the **same proxy**. ## Solvers | type | what it does | price per successful solve | | --- | --- | --- | | `akamai.sbsd.payload` | Akamai Bot Manager sbsd: you make the requests and we build the answer (no proxy). Returns `_abck`, `bm_s`, `bm_sc`, `bm_so`. See the akamai-payload section. | €0.0025 | | `akamai.edge` | Clears an Akamai edge fingerprint screen ('Unusual Traffic'), a different gate from sbsd. No sensor is generated. | €0.0025 | | `cloudflare.jsd` | Cloudflare JavaScript Detections. Returns `cf_clearance`. | €0.0025 | | `queueit.botdeflector` | Queue-it BotDeflector audio challenge, solved from a flow token you already hold. Different request shape, see its own section. | €0.003 | | `datadome` | Clears a DataDome wall and returns a trusted `datadome` cookie bound to your IP. Fetches `url` through your proxy; send your own residential proxy. Beta. Different request shape, see its own section. | €0.003 | | `tmpt` | Ticketmaster EPS reCAPTCHA helper. `op:"reload"` turns the reCAPTCHA anchor HTML into the `reload` payload you post yourself; `op:"version"` returns the release id (free). Different request shape, see its own section. | €0.006 | `queueit.botdeflector` takes a `flowToken` instead of fetching `url` itself — see the queueit-botdeflector section for its request shape. `tmpt` is a passthrough that takes `op` + `anchorHtml` + `page_url` and never fetches `url` — see the tmpt section. Other types (`akamai.sensor`, `cloudflare.turnstile`, `cloudflare.waf`) exist in the type list but are not enabled and answer `unsupported_type`. ## Things an agent must know - A human must approve each domain once. You cannot do this through the API. - Cookies are bound to the proxy's exit IP and to the returned user agent. Use a sticky residential or mobile proxy. - Failed calls are never charged. Only HTTP 200 is charged. - The API cannot create or revoke keys, or move money. That is dashboard-only on purpose. --- # POST /v1/solve `POST https://api.notabot.sh/v1/solve` · header `x-api-key: nab_live_…` · `content-type: application/json` · body max 2 MB · synchronous (Cloudflare JSD about 1 to 3 s, Akamai SBSD 2 to 10 s, mostly your proxy's round trips; set your client timeout to 60 s). ## Request body | field | type | required | notes | | --- | --- | --- | --- | | `type` | string | yes | `akamai.sbsd`, `akamai.sbsd.payload` (different fields, see the akamai-payload section), `akamai.edge`, `cloudflare.jsd`, `queueit.botdeflector` (different fields, see the queueit-botdeflector section) or `tmpt` (different fields, see the tmpt section) | | `url` | string | yes | http(s) URL of a page behind the protection. Domain must be approved. | | `proxy` | string | strongly advised | `http://user:pass@host:port`. Public host only (private/loopback refused with `bad_params`). Without it the solve runs from our own IP, which most sites reject. | | `userAgent` | string | no | max 512 chars. Leave out; the response says which to use. | Other fields are dropped. ## Success (HTTP 200) ```json { "ok": true, "requestId": "req_Qm3x…", "result": { "cookies": { "_abck": "…", "bm_s": "…", "bm_sc": "…", "bm_so": "…" }, "userAgent": "Mozilla/5.0 … Chrome/156.0.0.0 Safari/537.36", "status": 200, "attempts": 1 }, "cost": 0.0025, "costMicro": 2500, "solveMs": 2140 } ``` `cloudflare.jsd` returns `result: { cf_clearance, cookies: { cf_clearance }, userAgent, status }`. ## Error (any non-200) ```json { "error": { "code": "insufficient_balance", "message": "…" }, "requestId": "req_…" } ``` Branch on `error.code`, never on the message text. `requestId` is also in the `x-request-id` response header. ## Copy-paste client (Node) ```js // Node 18+. One function, handles every error class correctly. const API = "https://api.notabot.sh/v1/solve"; const sleep = (ms) => new Promise((r) => setTimeout(r, ms)); export async function solve({ type, url, proxy, userAgent }, { tries = 4 } = {}) { for (let attempt = 1; ; attempt++) { const res = await fetch(API, { method: "POST", headers: { "x-api-key": process.env.NOTABOT_KEY, "content-type": "application/json" }, body: JSON.stringify({ type, url, proxy, userAgent }), signal: AbortSignal.timeout(60_000), }).catch((e) => ({ networkError: e })); if (res.networkError) { if (attempt >= tries) throw res.networkError; await sleep(500 * 2 ** attempt); continue; } const body = await res.json(); if (res.ok) return body.result; // { cookies, userAgent, status, ... } const { code, message } = body.error; const retryAfter = Number(res.headers.get("retry-after")) * 1000 || 0; const retryable = ["solver_unavailable", "solver_timeout", "internal", "rate_limited"].includes(code); const newIp = code === "solve_failed" && /GATE_NOT_CLEARED|BLOCKED|TRANSPORT_ERROR|RATE_LIMIT/.test(message); if (newIp) throw Object.assign(new Error(message), { code, rotateProxy: true }); // caller picks a fresh IP if (!retryable || attempt >= tries) throw Object.assign(new Error(message), { code }); await sleep(Math.max(retryAfter, 500 * 2 ** attempt) + Math.random() * 250); } } ``` ## Copy-paste client (Python) ```python import os, random, re, time, requests API = "https://api.notabot.sh/v1/solve" RETRY = {"solver_unavailable", "solver_timeout", "internal", "rate_limited"} class SolveError(Exception): def __init__(self, code, message, rotate_proxy=False): super().__init__(f"{code}: {message}") self.code, self.rotate_proxy = code, rotate_proxy def solve(type, url, proxy=None, user_agent=None, tries=4): body = {"type": type, "url": url, **({"proxy": proxy} if proxy else {}), **({"userAgent": user_agent} if user_agent else {})} for attempt in range(1, tries + 1): try: r = requests.post(API, json=body, headers={"x-api-key": os.environ["NOTABOT_KEY"]}, timeout=60) except requests.RequestException: if attempt == tries: raise time.sleep(0.5 * 2 ** attempt); continue if r.ok: return r.json()["result"] # cookies, userAgent, status, ... err = r.json()["error"]; code, msg = err["code"], err["message"] if code == "solve_failed" and re.search("GATE_NOT_CLEARED|BLOCKED|TRANSPORT_ERROR|RATE_LIMIT", msg): raise SolveError(code, msg, rotate_proxy=True) # retry with a fresh IP if code not in RETRY or attempt == tries: raise SolveError(code, msg) time.sleep(max(float(r.headers.get("retry-after", 0)), 0.5 * 2 ** attempt) + random.random() * 0.25) ``` --- # akamai.sbsd.payload Use `akamai.sbsd.payload` when you already run your own sessions and proxies. Price €0.0025 per successful call, about 1 second. The site never sees our IP. Same endpoint, same auth, same errors as `/v1/solve`. ## Flow 1. GET the protected page with a Chrome client (real Chrome TLS fingerprint, cookie jar). The challenged page has a script tag whose src looks like `/?v=<36-char uuid>` (plus `&t=` on a block page). 2. GET that script with the same session and user agent. Download it fresh each time. 3. `POST /v1/solve` with the fields below. 4. POST `result.payload` to `result.postUrl` as `{"body": payload}` (content-type application/json, same user agent and cookies). If `result.followup` is not null, then POST `{"body": followup.payload}` to `followup.postUrl` the same way, only after the first was accepted. 5. GET the page again. If the site lets you through, your session cookies are good. ## Request body | field | type | required | notes | | --- | --- | --- | --- | | `type` | string | yes | `akamai.sbsd.payload` | | `script` | string | yes | the challenge script as downloaded, about 500 KB, max 1,000,000 chars | | `uuid` | string | yes | the `v=` value of the script URL | | `path` | string | yes | script path starting with `/`, no query | | `t` | string | no | the `t=` value; present on a block page, omit on a passive page | | `pageUrl` | string | yes | the page you loaded; its domain must be approved | | `cookieHeader` | string | no | your session cookies as one cookie header value, max 8192 chars | | `html` | string | no | the page HTML you received, max 400,000 chars | | `userAgent` | string | send it | one of the profiles below, identical to the UA on all your requests; default is the newest | | `acceptLanguage` | string | no | default `en-US,en;q=0.9` | | `timezone` | string | no | IANA name, default `Europe/London` | | `device` | object | no | `screen` {width,height,availHeight,colorDepth}, `dpr`, `hardwareConcurrency`, `deviceMemory`, `platformVersion`; unknown fields refused | Other fields are dropped. Body max 2 MB. ## Supported user agents Send the exact frozen Chrome string for one of these, nothing else (otherwise `solve_failed` with `UNSUPPORTED_PROFILE`, free, and the message lists them): - macos-145: `Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36` - macos-148: `Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/148.0.0.0 Safari/537.36` - macos-155: `Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/155.0.0.0 Safari/537.36` - macos-156: `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` Use the newest: sites refuse old Chrome at the first request. Your own client needs the matching Chrome TLS fingerprint and `sec-ch-ua` headers. ## Success ```json { "ok": true, "result": { "payload": "…", "followup": null, "postUrl": "https://shop.example.com/?t=", "userAgent": "…", "profile": "macos-156", "solveMs": 186 }, "cost": 0.0025, "costMicro": 2500 } ``` ## Failures (all free) - `NOT_CHALLENGED`: script, uuid and t are not from the same page load. Fetch them again together. - `UNSUPPORTED_PROFILE` / `BAD_INPUT`: fix the user agent or the named field. - The site's verdict is only visible to you: if the re-GET is still blocked, start over with a fresh session. --- # queueit.botdeflector Some Queue-it waiting rooms gate entry behind BotDeflector: an audio-captcha-style challenge instead of admitting on a redirect. Price €0.003 per successful solve. Unlike every other type, we never fetch `url` ourselves — you already minted a `flowToken` on your own Queue-it session, and we solve the challenge against Queue-it's host and hand back a ready-to-POST request for you to redeem on that same session. ## Request body | field | type | required | notes | | --- | --- | --- | --- | | `type` | string | yes | `queueit.botdeflector` | | `url` | string | yes | the protected page (e.g. the shop URL). Used only to check your domain approval — never fetched. | | `flowToken` | string | yes | the BotDeflector flow token from your own Queue-it session, max 4096 chars | | `checksumHash` | string | no | the `x-queueit-challange-hash` from your softblock page, if you have it. When given, the returned request is complete; otherwise add that header yourself before posting. | | `proxy` | string | if the flow token is IP-bound | same shape as every other type; pass the IP that minted the token | ## Success (HTTP 200) ```json { "ok": true, "requestId": "req_Nn8f…", "result": { "challengeFlowResult": "…", "botdeflector": { "method": "POST", "url": "https://securedbyqueueit.queue-it.net/spa-api/queue///challenge/botdeflector/verify", "headers": { "x-queueit-challange-customerid": "…", "x-queueit-challange-eventid": "…", "x-requested-with": "XMLHttpRequest" }, "body": { "challengeType": "botdeflector", "sessionId": "…", "solution": "…", "customerId": "…", "eventId": "…" } } }, "cost": 0.003, "costMicro": 3000, "solveMs": 740 } ``` ## Redeeming it 1. Take `result.botdeflector.method`, `.url`, `.headers` and `.body`. 2. Add your session's `Cookie` header. If you did not send `checksumHash`, also add `x-queueit-challange-hash` from your softblock page. 3. POST it, on the same session that minted the flow token. A real pass continues through the waiting room normally. ## Failures (all free) - `solve_failed` with `TRANSPORT_ERROR`: the backend could not be reached or was at capacity. Retry the same request. - `solve_failed` with any other reason: the flow token was rejected (not valid or already consumed). Mint a fresh one — do not reuse a flow token across unrelated sessions. --- # datadome DataDome gates a page with a device/interstitial check and a `datadome` cookie that is bound to **your IP and User-Agent**. The `datadome` type fetches `url` through your proxy, runs the check, and returns a trusted `datadome` cookie you then ride on your own session. It is domain-gated like the other fetching solvers: approve the site first. **Beta.** This solver is new and depends on a clean residential IP. The DataDome cookie binds to the exit IP, so you must send your own residential `proxy` — a datacenter or already-flagged IP is refused by DataDome (returned to you as `solve_failed (BLOCKED)`, free), not by us. Everything below works; the open issue is sourcing a clean IP, which is yours to provide. ## Interstitial or captcha — which do you have? DataDome serves one of two challenges when it blocks you. Read the `dd` block on the page (`var dd={rt:'…'}`) or the `url` DataDome returns: | challenge | marker | solved here? | | --- | --- | --- | | Interstitial | `rt:"i"`, URL has `/interstitial/` | yes — the automatic device check `datadome` clears | | Slider / puzzle captcha | `rt:"c"`, URL has `/captcha/` | no — `datadome` returns `solve_failed (BLOCKED)` (free); your IP is flagged, rotate to a clean residential IP to get the interstitial back | A `BLOCKED` result is the signal your exit was served the slider: fix the IP, not the call. `datadome` clears the **page interstitial only** — it does not mint clearance for `/api/` or XHR endpoints that return their own captcha JSON. ## op — €0.003 per success `POST https://api.notabot.sh/v1/solve` | field | type | required | notes | | --- | --- | --- | --- | | `type` | string | yes | `datadome` | | `url` | string | yes | the protected page URL (approved site) | | `proxy` | string | recommended | your residential proxy, `http://user:pass@host:port`; the cookie binds to its IP | | `userAgent` | string | no | the UA you will reuse with the cookie (defaults to a Chrome UA) | ```json { "ok": true, "requestId": "req_…", "result": { "datadome": "", "cookies": { "datadome": "…" }, "userAgent": "Mozilla/5.0 (…) Chrome/…", "status": 200 }, "cost": 0.003, "costMicro": 3000, "solveMs": 900 } ``` ## Using it 1. Call `datadome` with the protected `url` and your residential `proxy`. 2. Take `result.datadome` (and the other `result.cookies`) and set them on your session. 3. Make your real requests from the **same IP and User-Agent** — the cookie is bound to both. ## Failures (all free) - `solve_failed` with `BLOCKED`: DataDome served a hard captcha — your IP is flagged. Rotate to a clean residential IP. - `solve_failed` with `NOT_CHALLENGED`: the page showed no DataDome interstitial, or no clearance was produced. Nothing to solve. - `solve_failed` with `TRANSPORT_ERROR`: the backend or proxy was unreachable. Retry. --- # tmpt Ticketmaster's eticketing / EPS pages gate on a reCAPTCHA Enterprise score. `tmpt` is a thin passthrough to our reCAPTCHA reload-builder: you run the browser-facing steps, and we build the one piece you cannot — the `/recaptcha/enterprise/reload` request body (the "reload" payload) that mints a scoring token. We never fetch `url` and there is no proxy, so this type is not domain-gated. It has two ops. ## op: "version" — free `POST https://api.notabot.sh/v1/solve` with `{ "type": "tmpt", "op": "version" }` returns the current reCAPTCHA release id, which you need to build the anchor URL. This op is free (€0). ```json { "ok": true, "requestId": "req_…", "result": { "version": "bSuJ2xBC8cFy7pM4Z3Hu9boH" }, "cost": 0, "costMicro": 0, "solveMs": 120 } ``` ## op: "reload" — €0.006 per success | field | type | required | notes | | --- | --- | --- | --- | | `type` | string | yes | `tmpt` | | `op` | string | no | `reload` (the default) or `version` | | `anchorHtml` | string | yes | the HTML of the Google reCAPTCHA `/enterprise/anchor` page you fetched, max 400000 chars | | `page_url` | string | yes | the URL of the page the reCAPTCHA is on, for example the event page | | `action` | string | no | `pageView` (the default) or `Event` | | `userAgent` | string | no | the UA you will use when you post the reload (defaults to a Windows Chrome UA) | | `cookies` | string[] | no | your site's non-HttpOnly cookies as `name=value` strings | ```json { "ok": true, "requestId": "req_…", "result": { "reload": "" }, "cost": 0.006, "costMicro": 6000, "solveMs": 300 } ``` ## Using it 1. `op:"version"` → `version`. 2. Build the reCAPTCHA `/enterprise/anchor` URL with that `version` and your site's reCAPTCHA key, and GET it → `anchorHtml`. 3. `op:"reload"` with that `anchorHtml` and the `page_url` the reCAPTCHA is on → `reload` (base64). We return it unchanged. 4. base64-decode `reload` and POST it to `https://www.google.com/recaptcha/enterprise/reload?k=` (content-type `application/x-protobuffer`) → the `rresp` token. 5. POST the token to the site's `/epsf/gec/v3/pageView` → it sets the `tmpt` cookie. Ride it on your own session. ## Failures (all free) - `solve_failed` with `VENDOR_ANOMALY`: the reload builder returned nothing usable for your anchor. Fetch a fresh anchor and retry; anchors expire. - `solve_failed` with `TRANSPORT_ERROR`: the backend could not be reached. Retry. --- # Errors and retry policy No error is ever charged. | code | HTTP | meaning | | --- | --- | --- | | `bad_params` | 400 | The body is not valid JSON, is over 2 MB, or `type`, `url`, `proxy` or `userAgent` (or, for the payload type, a field such as `script`) is missing or invalid. The message names the field. | | `unsupported_type` | 400 | The `type` is unknown, or that solver is not enabled yet. | | `invalid_key` | 401 | The `x-api-key` header is missing, malformed, unknown or revoked. | | `insufficient_balance` | 402 | Your balance is below the price of this solve. Top up on the Billing page. | | `key_limit_reached` | 402 | This key hit its own spend limit. Raise the limit on the Keys page or wait for the window to reset (00:00 UTC). | | `account_banned` | 403 | The account is suspended. Contact support on Discord. | | `domain_not_allowed` | 403 | The site is not approved for your account yet. Request it on the Sites page; approval is manual and subdomains of an approved domain are covered. | | `not_found` | 404 | Unknown route. | | `rate_limited` | 429 | Too many requests. Wait for the number of seconds in the `retry-after` header. | | `internal` | 500 | A fault on our side. Safe to retry. | | `solve_failed` | 500 | The solve did not succeed. The message carries a reason, see below. | | `solver_unavailable` | 503 | The solver is down or at capacity. When it is just busy the response has a `retry-after` header; wait that long and retry. | | `solver_timeout` | 500 | The solve ran past 30 seconds. Retry. | ## solve_failed reasons The message ends with the reason, e.g. `Solve failed (GATE_NOT_CLEARED). You were not charged.` | reason | meaning | | --- | --- | | `NOT_CHALLENGED` | The site did not challenge this IP, so there was nothing to solve. Fetch the page directly. | | `GATE_NOT_CLEARED` | The answer was valid but the site still held the session back. Nearly always a flagged IP. Retry on a fresh one. | | `BLOCKED` | The site refused the request before any challenge was shown. Usually the IP. | | `TRANSPORT_ERROR` | The proxy or the site dropped the connection. Retry, ideally on a new IP. | | `BAD_PROXY` | The proxy is not a usable `http://user:pass@host:port` URL, or it refused us. | | `CHALLENGE_NOT_FOUND` | The page loaded but the protection script was not on it. The URL may not sit behind this solver's protection. | | `SOLVER_ERROR` | The solver hit a case it could not handle. Retry once; if it repeats, send us the requestId. | | `UNSUPPORTED_PROFILE` | `akamai.sbsd.payload` only. The `userAgent` is not one of the supported Chrome versions. The message lists them. | | `BAD_INPUT` | `akamai.sbsd.payload` only. A browser field (`acceptLanguage`, `timezone` or `device`) is invalid. The message says which. | | `RATE_LIMIT` | The site rate-limited the proxy IP. Slow down or change IP. | ## Retry policy (implement exactly this) | situation | action | | --- | --- | | `solver_unavailable`, `solver_timeout`, `internal` | retry same request; exponential back-off with jitter; honour `retry-after` when present; max 3 to 4 tries | | `rate_limited` (429) | wait `retry-after` seconds, then retry | | `solve_failed` with `GATE_NOT_CLEARED`, `BLOCKED`, `TRANSPORT_ERROR`, `RATE_LIMIT` | retry with a **different proxy IP** | | `solve_failed` with `NOT_CHALLENGED` | do not retry; fetch the page directly, nothing to solve | | `bad_params`, `unsupported_type`, `invalid_key`, `account_banned` | do not retry; fix the request or stop | | `domain_not_allowed` | do not retry; the domain needs approval on the Sites page (human step) | | `insufficient_balance`, `key_limit_reached` | do not retry; a human must top up or raise the key limit | --- # Using the result Three rules, all required: 1. **Same proxy.** Make your requests through the exact proxy you passed to the solve. If the exit IP changes the cookies stop working. 2. **Same user agent.** Copy `result.userAgent` into your `user-agent` header unchanged. 3. **All cookies.** Send every entry of `result.cookies` as a `Cookie` header and keep any cookies the site sets afterwards. ```python import requests # for a real site use a client with a Chrome TLS fingerprint, see "tls" result = solve("akamai.sbsd", "https://shop.example.com/", proxy=PROXY) cookie = "; ".join(f"{k}={v}" for k, v in result["cookies"].items()) page = requests.get( "https://shop.example.com/events", headers={"user-agent": result["userAgent"], "cookie": cookie}, proxies={"https": PROXY}, # SAME proxy as the solve ) ``` ## tls Sites also check the TLS/HTTP2 fingerprint of your connection. Stock Node, Python (`requests`) and Go clients differ from Chrome and a site may reject good cookies sent that way. For your own requests use a Chrome-impersonating client (curl-impersonate, httpcloak, tls-client) or a real browser. The solve itself already uses a Chrome fingerprint. ## Lifetime The site decides how long cookies live. Reuse a result until the site challenges you again, then solve again. Solving before every request only costs money. ## If requests are still blocked Check in order: same proxy? identical user agent? Chrome-like TLS client? fresh residential or mobile IP (datacenter and flagged IPs cause most blocks). --- # Limits and proxies | limit | value | | --- | --- | | requests per second, per key | 50 | | requests per second, per account | 200 | | request body | 2 MB | | solve timeout (server side) | 30 s then `solver_timeout` | | recommended client timeout | 60 s | | `userAgent` length | 512 chars | Over the limit: `rate_limited` (429) with `retry-after`. When the solver is full: `solver_unavailable` (503) with `retry-after`. Wait, then retry. Higher limits: ask on Discord. ## Proxies - Format `http://user:pass@host:port` (or https). SOCKS is not supported. - Must be publicly routable; private, loopback and link-local addresses are refused. - Residential or mobile with a sticky session works best. - Your proxy credentials are used for that request only and are not stored with usage records. --- # Account API (read-only) Base https://api.notabot.sh/v1 · auth: `Authorization: Bearer nab_live_…` or `x-api-key` · GET only (other methods answer 405) · 20 requests/s per key. Use it to check balance before a batch or to monitor spend. It cannot create/revoke keys or spend money. `/v1/usage` query: `range` = `24h` | `7d` (default) | `30d` | `90d`; `key` = key id; `type` = solver type. ### GET /v1/me Who the key belongs to and the discount level the account is on. ```json { "id": 42, "username": "pedro", "createdAt": "2026-10-16T09:12:44.000Z", "partner": false, "level": { "discount": 0.2, "discountBp": 2000 }, "requestId": "req_…" } ``` ### GET /v1/balance Your wallet balance, the solves it buys, and the solves left on each key. ```json { "currency": "EUR", "balance": 37.11, "balanceMicro": 37110000, "lifetimeTopup": 50, "level": { "discountBp": 2000, "next": { "atLifetimeTopupMicro": 250000000, "discountBp": 3000 } }, "solvesLeft": { "akamai.sbsd": 14844, "cloudflare.jsd": 24740 }, "keys": [ { "id": 7, "name": "prod", "limit": null, "solvesLeft": { "akamai.sbsd": 14844 } } ], "requestId": "req_…" } ``` ### GET /v1/keys Every active key with its spend limit and remaining capacity. Secrets are never returned. ```json { "keys": [ { "id": 7, "name": "prod", "display": "nab_live_Ab3d…9k", "createdAt": "2026-10-16T09:20:01.000Z", "lastUsedAt": "2026-10-27T10:58:12.000Z", "limit": { "kind": "daily", "amountMicro": 5000000, "spentMicro": 1200000, "resetsAt": "2026-10-28T00:00:00.000Z" }, "solvesLeft": { "akamai.sbsd": 1520, "cloudflare.jsd": 2533 } } ], "requestId": "req_…" } ``` ### GET /v1/keys/7 The same fields for a single key, by id. Another account’s key id answers 404. ```json { "id": 7, "name": "prod", "display": "nab_live_Ab3d…9k", "limit": null, "solvesLeft": { "akamai.sbsd": 14844 }, "requestId": "req_…" } ``` ### GET /v1/usage Totals, a time series, and the split by site and by key. Filter with range (24h, 7d, 30d, 90d), key and type. ```json { "range": "7d", "bucket": "day", "totals": { "ok": 3324, "failed": 41, "spent": 8.31, "spentMicro": 8310000, "p50LatencyMs": 612, "p95LatencyMs": 1480, "busiestHourUtc": 19 }, "series": [ { "start": "2026-10-21T00:00Z", "ok": 480, "failed": 6, "p50LatencyMs": 598 } ], "bySite": [ { "site": "shop.example.com", "ok": 3324, "failed": 41, "spentMicro": 8310000 } ], "byKey": [ { "key": "prod", "ok": 3324, "failed": 41, "spentMicro": 8310000 } ], "requestId": "req_…" } ``` --- # Billing and levels Prepaid credit, no subscription, never expires, only successful solves consume it. Top up by card on the Billing page (min €10). All sales are final. Lifetime levels: your level counts the top-up you are making, applies to it immediately and never drops. A discount of d% means each euro buys 1/(1-d) euros of credit. | lifetime top-ups | discount | | --- | --- | | from the start | none | | €100+ | 20% | | €250+ | 30% | | €500+ | 40% | | €1,000+ | 50% | | €2,500+ | 55% | | €5,000+ | 60% | Example: €100 at the 20% level buys €125 of credit, which is 50,000 Akamai solves. The Usage page lists every request and exports CSV/JSON. --- # Sites (domain approval) Each domain is approved by a human once. Request it on https://notabot.sh/app/sites. Status becomes approved or rejected (with a note). Approved domains work within about 30 seconds. Approving `example.com` covers `shop.example.com`. Before approval the API answers `domain_not_allowed` (403, free). Members of a partner programme automatically use the programme's approved sites. An agent cannot approve a domain. If you get `domain_not_allowed`, tell the human to request it. --- # Partner programme Apply on https://notabot.sh/app/org. After approval you create a programme and get a link like `https://notabot.sh/join/your-name`. Anyone who opens it and logs in with Discord joins the programme and can use all of its approved sites. Partner share of member top-ups, credited to the partner's balance: | members' spend this year | partner share | | --- | --- | | from the first euro | 5% | | €12,000+ | 8% | | €60,000+ | 12% | | €180,000+ | 15% | --- # FAQ - **Do I pay for failed solves?** No. Only a 200 response is charged. - **Do I need a browser?** No. Call the API over HTTPS. For your own requests to the site use a Chrome-TLS client or a browser. - **Why does it need my proxy?** Cookies are tied to the IP that earned them. - **domain_not_allowed?** The domain is not approved for the account. A human requests it on the Sites page. - **GATE_NOT_CLEARED?** Valid answer but the site still held the session; almost always the IP. Retry on a fresh residential or mobile IP. - **NOT_CHALLENGED?** The site did not challenge that IP; fetch the page directly. Free. - **solver_unavailable?** The solver is at capacity or restarting. Wait `retry-after` and retry. Never charged. - **Higher limits or new solvers?** Ask on Discord.