Docs

Install the client, or call the endpoint.

Almost everyone wants the first one: our open-source solver drives the page and uses this endpoint for you. Underneath is one JSON endpoint: a screenshot in, the clicks, drags or text that solve it out.

Setup

Base URL and key.

# same client, same request shape — only the endpoint moves
export CAPTCHA_KRAKEN_API_KEY=ck_live_…
export VLLM_BASE_URL=https://api.captchakraken.com/v1

Keys are minted from the dashboard, or by the MCP server below. They look like ck_live_ followed by a public prefix and a secret half, and the secret is shown exactly once at issue. We store only a SHA-256 of it, so a lost key is replaced rather than recovered.

Authenticate with a standard bearer header: Authorization: Bearer ck_live_…. The endpoint is api.captchakraken.com.

Quickstart

Point the client at a page.

CaptchaKraken is our public solver. It finds the widget, screenshots it, sends the board, performs the answer and checks whether the vendor accepted it. Give it a key and it uses this endpoint — you write none of the request shape below.

npm install captchakraken    # TypeScript browser driver
pip install captchakraken    # Python engine + the `captchakraken` CLI

export CAPTCHA_KRAKEN_API_KEY=ck_live_your_key_here

TypeScript — any Playwright-compatible page

import { chromium } from 'playwright';
import { CaptchaKrakenSolver } from 'captchakraken';

const page = await (await (await chromium.launch()).newContext()).newPage();
await page.goto('https://www.google.com/recaptcha/api2/demo');

await new CaptchaKrakenSolver().solve(page);   // detect → solve → click → verify

Python

from playwright.sync_api import sync_playwright
from captchakraken import PageSolver

with sync_playwright() as p:
    page = p.chromium.launch().new_page()
    page.goto("https://www.google.com/recaptcha/api2/demo")
    print(PageSolver().solve(page).is_solved)

No browser? Hand the CLI a screenshot and it prints the click plan as JSON: captchakraken path/to/captcha.png. Every browser framework it drives — Playwright, Patchright, Camoufox, Puppeteer — is in the repository's usage guide.

The rest of this page is the wire protocol underneath it. You need it to write your own client or to debug one — not to solve a captcha.

Important

This is a captcha model, not a general vision model.

The endpoint takes a board and nothing else: there is no prompt to send. The v2 models are pointer models — a vision model with small heads that read the whole answer, action, points, drags, text or the moment in a video, from one pass over the screenshot. The server owns the one fixed prompt it was trained on.

The v1 chat-completions API and its three prompts are retired: /v1/chat/completions answers 410. Clients from 4.0.0 on speak /v1/pointer.

Request

One board per request.

POST the captcha as a base64 still. Crop to the widget rather than sending the whole page.

curl https://api.captchakraken.com/v1/pointer \
  -H "Authorization: Bearer $CAPTCHA_KRAKEN_API_KEY" \
  -H "Content-Type: application/json" \
  -H "x-ck-session: $(uuidgen)" \
  -d '{ "image": "<base64 PNG or JPEG of the captcha>" }'

Animated challenges

For a board that moves, send frames instead of image: two or more JPEG frames cut at 5 fps, the way the client's clipvideo cuts them. Send exactly one of the two. A frames request bills at the video rate.

{ "frames": ["<base64 JPEG>", "<base64 JPEG>", …], "fps": 5.0 }

Two optional fields

"marked": false skips the element detector, which otherwise numbers the board's grids, cells and pieces before the model reads it. "avoid": [answer, …] names answers the widget already refused on this board, and the likeliest other ones come back.

There is no model to choose

Leave it out. The hosted endpoint answers with Abyss, and when we retrain, your integration picks up the better model without you changing a line.

From Python, without the client

import base64, os, uuid, requests

session = str(uuid.uuid4())              # one per captcha attempt
board = base64.b64encode(open("captcha.png", "rb").read()).decode()

r = requests.post(
    "https://api.captchakraken.com/v1/pointer",
    headers={
        "Authorization": f"Bearer {os.environ['CAPTCHA_KRAKEN_API_KEY']}",
        "x-ck-session": session,
    },
    json={"image": board},
)
best = r.json()["actions"][0]            # perform this; [1] and [2] are the fallbacks

The response

actions holds the three likeliest distinct plans, best first: perform the first, and try the second and third if the widget refuses it. answer repeats the first. Points are on a 0–1000 scale of the board you sent, so they survive whatever size you screenshotted at; ids name the numbered elements they land on, and size is the board in pixels as the model saw it. Besides click, an action can be a drag with source and destination points, or typed text. One response is one billable response, however many actions it holds.

{
  "actions": [
    { "action": "click", "points": [[212, 418], [705, 431]], "ids": [4, 6] },
    { "action": "click", "points": [[212, 418]], "ids": [4] },
    { "action": "click", "points": [[705, 431]], "ids": [6] }
  ],
  "answer": { "action": "click", "points": [[212, 418], [705, 431]], "ids": [4, 6] },
  "size": [720, 704],
  "elements": [
    { "id": 1, "class": "grid", "box": [8.0, 96.5, 712.0, 640.0], "score": 0.99 },
    …
  ]
}

Reporting the outcome

When an attempt ends, POST /v1/solve-outcome with {"session": "<id>", "solved": true}. It is never billed and never changes the solve; it is how we learn which boards the model loses. The client sends it for you.

Headers

Two optional headers that affect your bill.

HeaderWhy it matters
x-ck-sessionA UUID identifying one captcha attempt. Responses sharing a session are grouped, and that grouping is what both per-attempt limits are counted over — the $1.50-per-1,000 billing ceiling and the 10-response abandon threshold. Without it, every response bills independently and neither engages — send a fresh UUID per captcha, and reuse it across every response for it.
x-ck-clientIdentifies the integration, e.g. camoufox/0.4.11. Used for attribution and support; it has no effect on price.

There is no header that sets the puzzle class. Pricing is derived from the body — one image or a list of frames — so a header cannot move a request into a cheaper bracket.

Errors

Branch on the code, never on the message.

Every error is a JSON {"error": {"message", "type", "code"}} body. The prose gets reworded; error.code does not.

StatusCodeMeaningWhat to do
401missing_api_keyNo Authorization header was sent.Send Authorization: Bearer ck_live_…
401invalid_api_keyThe key is unknown or has been revoked.Check the key, or mint a new one.
402insufficient_creditsThe account balance cannot cover the round.Top up. The same key resumes working immediately.
403account_suspendedThe account is suspended.Contact support.
429rate_limitedToo many requests from this key.Back off; honour the Retry-After header.
400invalid_requestThe body is malformed, or it sends both or neither of image and frames.Check the JSON against the shape above.
410invalid_requestA request to the retired /v1/chat/completions solver.Upgrade the client to 4.0.0 or later, or POST to /v1/pointer.
413request_too_largeThe screenshot exceeds the body limit.Downscale or crop before encoding.
409solve_abandonedOne attempt was served 10 times without settling.Usually IP reputation, not the answers. Start a new x-ck-session.
502upstream_unavailableThe solver fleet is unreachable. Not your fault.Retry shortly with backoff. Nothing is billed.

A revoked key and an unknown key both return invalid_api_key. Telling the difference apart would confirm to an attacker which of their guesses was once real.

MCP

Managing the account from an agent.

The same account, driven from an MCP client. It signs you in through GitHub, mints and revokes keys, and reads back what you have spent.

# Claude Code, Claude Desktop, or any MCP client
claude mcp add captchakraken -- npx -y captchakraken-mcp

Sign in

sign_in prints a short code and a link. You approve it in the browser with GitHub; the account is created on the spot if it does not exist, free credits and all.

Mint keys

create_api_key returns a live ck_live_ key, once. list_api_keys and revoke_api_key do the rest.

Watch the money

get_balance and get_usage report the balance, the burn rate and the per-day spend. get_topup_link opens Stripe.

The token the MCP server holds manages the account — it cannot solve captchas, and an API key cannot manage the account. Two credentials, two blast radii. Revoke either from the dashboard.

Billing

$0.40 per 1,000 image responses.

You are billed per inference response — no subscription required, no monthly minimum, no per-seat fee, and no charge at all for challenges that never reach the model. Monthly plans buy more credits per dollar; see plans.

What you sendCredits eachPer 1,000 responses
Image response
Grid, click and drag puzzles
3$0.40
Video response
Video challenges, which only the hosted model handles
10$1.33
reCAPTCHA checkbox, Cloudflare Turnstile
Detected locally; no model call is made.
0Free

Most image captchas are solved in 1–2 image inference requests, and most videos are solved in 1–2.

$1.00 = 7,500 credits. The per-response rate is the contractual figure and is what your account is actually charged; the response counts above are what we typically see, not a guarantee — a captcha that fights back takes more, and you are billed for what was actually served.

Credits

Buy what you need. It does not expire.

Any whole dollar amount from $5 up to $2,000— these three are shortcuts, not the only sizes. Amounts of $25 and over earn bonus credits, up to +20%; the table is on the top-up page.

$25196,875 credits

includes a +5% volume bonus

65,625 image responses

$50412,500 credits

includes a +10% volume bonus

137,500 image responses

$100862,500 credits

includes a +15% volume bonus

287,500 image responses

Those counts are division, not an estimate — 3 credits per image response into the pack, bonus credits included. Credits you top up carry over indefinitely and are not tied to a billing period; only a monthly plan's credits lapse, at the end of each month. Need more than $2,000 at once, or an invoice? Talk to us.

Monthly plans

Using it every month? A plan buys more for the same money.

Optional. A plan posts its credits each month when the payment succeeds; they never expire and are spent exactly like credits you top up. Subscribe or cancel any time from your dashboard's plans page.

Starter

$19per month

Credits reset every month

213,750 credits a month: 1.5× on-demand, about $0.27 per 1,000 images.

    Pro

    $49per month

    Credits reset every month

    643,125 credits a month: 1.75× on-demand, about $0.23 per 1,000 images.

    • Feature requests, prioritised when we decide what to build next

    Power User

    $99per month

    Credits reset every month

    1,485,000 credits a month: 2× on-demand, about $0.20 per 1,000 images.

    • Feature requests, prioritised when we decide what to build next
    • Dedicated support channels on Discord

    Abyss Licence

    Coming soon

    $499per month

    Run Abyss on your own hardware, with every update. Hosted use is billed per response.

    • Feature requests, prioritised when we decide what to build next
    • Dedicated support channels on Discord

    Every account gets email support and our public Discord.

    How billing works

    Four rules, and no others.

    One response, one charge

    Every inference response costs the credits listed for its class. The class is derived from what you actually sent — an image or a video — not from a header, so a request cannot be relabelled into the cheaper bracket by anyone, including us.

    Our misses are free

    When the model under-selects and the challenge must be asked again for that reason, the extra response costs nothing and is labelled missed-tiles-retry on your usage so you can see it happened.

    One captcha, one ceiling

    No captcha attempt is billed more than $1.50 per 1,000, image or video, however many responses it takes. We keep answering free up to 10 responses, then abandon the attempt. A pathological captcha cannot drain an account.

    Failures we caused are not billed

    If a response fails on our side — capacity, an error, anything that is not an answer — it is recorded at zero credits and appears on your usage with the reason.

    Two things move your effective cost, and you should hear them here rather than infer them from an invoice. A reCAPTCHA grid re-draws after each click, so a session on a flagged IP draws harder challenges and lands above the typical response count. And if a vendor rejects a submission the model got right — a function of IP reputation and browser fingerprint more than of the answer — that response was still served and still billed. Tell us your setup and we will estimate it with you before you spend anything.

    Common questions

    Before you ask.

    Is there a subscription?

    Not unless you want one. Credits are prepaid and drawn down as you use them, with no monthly fee, seat count, or minimum spend. If you use the service every month, a monthly plan (from $19) buys up to 2× the credits per dollar, with prioritised feature requests and chat support on the larger plans; see plans.

    Do credits expire?

    No. They stay on the account until they are used.

    What if I run out mid-run?

    Requests are refused with a clear insufficient_credits error rather than being served into a negative balance. Top up and the same key resumes working immediately.

    How do I check my balance from code?

    GET /v1/balance with the same API key you solve with returns balance_credits and balance_usd, at no charge. Every solve response also carries X-CK-Balance-Credits and X-CK-Balance-USD, the balance after that round.

    Can I get a refund?

    Unused credits, yes — see the refund policy. Credits already spent on solves we delivered are not refundable.

    Do unspent plan credits carry over?

    No. A plan's credits reset every month: what is left when the next month posts, or when the plan ends, lapses and is not refunded. That is why a plan buys more credits per dollar. Plan credits are spent before credits you top up, and top-up credits never expire. The dashboard and the plans page show how many plan credits will lapse, and when.

    Do you offer volume pricing?

    Yes: top-ups earn a volume bonus, and the monthly plans buy up to 2× the credits per dollar. Beyond those, get in touch with your expected monthly volume and challenge mix.