Why DeathByCaptcha is the cheaper way to solve CAPTCHAs in an AI agent
A vision model's sticker price looks cheaper than DeathByCaptcha: a fraction of a cent for one image call against $2.89 per thousand token solves. That comparison is the wrong one. An agent does not solve a CAPTCHA in one call; it takes a screenshot, reasons, calls a tool, waits, retries when the answer is rejected, and pays for every step. Once the loop and the success rate are counted, DeathByCaptcha is the cheaper way to get a solved challenge — and for reCAPTCHA, Turnstile and the other token types, the only way.
This article shows the arithmetic, the costs the per-call price hides, and how to wire DeathByCaptcha into an agent in a few lines.
What a vision model can and cannot do
Image CAPTCHAs are the grey area. A capable vision model can read a clean image, and it can fail on a distorted one. It has no way to know whether the answer is right until the form rejects it, so the real cost is the retry.
Token CAPTCHAs are a different problem. reCAPTCHA v2 and v3, Cloudflare Turnstile, Amazon WAF and DataDome do not ask the browser to read an image; they ask it to present a token that the site validates. A model looking at pixels cannot produce that token. Either the agent calls DeathByCaptcha, or the flow does not complete.
| Challenge | Vision model | DeathByCaptcha |
|---|---|---|
| Normal image CAPTCHA | Sometimes, with retries | Yes |
| reCAPTCHA v2 / v3 | No valid token | Yes, token |
| Cloudflare Turnstile | No valid token or cookie | Yes, token |
| Amazon WAF / DataDome | No valid token | Yes, token, IP-bound |
| Audio CAPTCHA | No, needs transcription | Yes |
The price list, and the price that matters
DeathByCaptcha publishes the price per thousand solves:
| Type | Price |
|---|---|
| Normal image CAPTCHA | $0.99 to $2 per 1K |
| reCAPTCHA v2 / v3 / invisible | $2.89 per 1K |
| GeeTest v3 / v4 | $2.89 per 1K |
| Cloudflare Turnstile | $2.89 per 1K |
| Amazon WAF, DataDome and the rest | $2.89 per 1K |
| Audio CAPTCHA | $0.59 per 1K |
That is $0.00289 per token solve and between $0.00099 and $0.002 per image solve. It is the price of a solved challenge: DeathByCaptcha charges only for correctly solved challenges, and an incorrect solution can be reported for a refund. The listed price is already a cost per success; the model's failures are not free.
A vision-model attempt is not a solved challenge. Count what one attempt actually contains:
- the screenshot or the image tokens;
- the reasoning tokens the agent spends deciding what it is looking at;
- the tool call and the page text it reads around the challenge;
- the retry, with the whole loop again, when the answer is rejected;
- the engineering time behind the prompt and the retry logic.
The image call is the smallest part. The number that decides the budget is cost per successful solve:
cost per success = cost per attempt / success rate
The table below counts only the image and the output tokens, so it is conservative. Add the reasoning tokens and the gap widens.
| Model tier (input per 1M) | Cost per attempt | At 50% success | At 25% success |
|---|---|---|---|
| $0.10 to $0.30 | $0.0002 to $0.0004 | $0.0004 to $0.0008 | $0.0008 to $0.0016 |
| $0.75 to $2 | $0.0005 to $0.0025 | $0.0010 to $0.0050 | $0.0020 to $0.0100 |
| $3 to $8 | $0.0020 to $0.0100 | $0.0040 to $0.0200 | $0.0080 to $0.0400 |
Compare with DeathByCaptcha: $0.00099 to $0.002 per image solve and $0.00289 per token solve.
- At 50% success, only the cheapest tier can undercut the image price; the middle and upper tiers do not.
- At 25% success, even the cheap tier sits at the top of the image range, and the rest are several times the DeathByCaptcha price.
- Token challenges do not appear because no success rate produces a valid token. The model has no price at which it competes.
The tiers follow the list prices in the model catalogue available at the time of writing (November 2026): Haiku-class $0.10/$0.50 per million input/output tokens, Flash-Lite $0.30/$2.50, Flash $0.75/$3.75, Sonnet-class $2/$10, Opus-class $4/$20. Image tokenisation varies by provider, so the table is an estimate, not a quote.
A local model changes the marginal cost — no per-token bill, only hardware, power and maintenance — but not the capability ceiling. At low volume the machine dominates the per-solve cost; at high volume it amortises, and it still cannot produce a token.
The one honest exception is a clean image, a high success rate and a small model. There the model can cost less than the image solve. That is the narrow case: the moment the image is distorted, the page needs a token, or the agent loop is counted, DeathByCaptcha is cheaper per successful solve.
Wiring DeathByCaptcha into an agent
The Python client already ships an agent wrapper and examples:
agents/agent_wrapper.py—CaptchaSolver, with retries and cost data.agents/example_tool_use.py— a tool definition for Claude/GPT.agents/example_langchain.py— LangChain integration.deathbycaptcha-agent-api-metadata— the OpenAPI and JSON-LD spec for agents and code generators.
The pattern is always the same: the model calls a tool, the tool talks to DeathByCaptcha on the server, the browser injects the result.
A tool definition the model can understand:
{
"name": "solve_captcha",
"description": "Solve a CAPTCHA challenge with DeathByCaptcha. Use it when a page presents an image challenge or needs a reCAPTCHA, Turnstile, WAF or DataDome token. Never invent a token.",
"input_schema": {
"type": "object",
"properties": {
"type": {"type": "integer", "description": "DeathByCaptcha type: 0 image, 4 reCAPTCHA v2, 5 v3, 12 Turnstile, 16 WAF, 21 DataDome"},
"image_base64": {"type": "string", "description": "Screenshot or image bytes for image challenges"},
"sitekey": {"type": "string"},
"pageurl": {"type": "string"},
"action": {"type": "string"},
"min_score": {"type": "number"}
},
"required": ["type", "pageurl"]
}
}
The handler stays on your side, where the credentials live:
import base64
import io
import json
import os
import deathbycaptcha
client = deathbycaptcha.HttpClient(
os.environ["DBC_USERNAME"],
os.environ["DBC_PASSWORD"],
)
def solve_captcha(args):
if args["type"] == 4:
params = {"googlekey": args["sitekey"], "pageurl": args["pageurl"]}
result = client.decode(type=4, token_params=json.dumps(params))
elif args["type"] == 5:
params = {"googlekey": args["sitekey"], "pageurl": args["pageurl"]}
if args.get("action"):
params["action"] = args["action"]
if args.get("min_score"):
params["min_score"] = args["min_score"]
result = client.decode(type=5, token_params=json.dumps(params))
else:
image = io.BytesIO(base64.b64decode(args["image_base64"]))
result = client.decode(captcha=image, type=args["type"])
if not result or not result.get("text"):
raise RuntimeError("DeathByCaptcha returned no solution")
return {
"captcha_id": result["captcha"],
"text": result["text"],
}
The agent receives the text or token, and your browser tool injects it. The model never sees the DeathByCaptcha credentials, and the token is not part of the conversation history unless you put it there.
Guardrails that keep the bill predictable
- Budget per task. Pass a maximum spend or a maximum number of solves to the tool; refuse beyond it.
- Retry cap. Two attempts, not an unbounded loop. A challenge that keeps failing usually means the page changed, not that the third try will work.
- Timeout. DeathByCaptcha has defaults (sixty seconds for image, a hundred twenty for tokens); do not let the agent's own timeout cut a solve that is still running.
- No credentials in prompts. The tool runs server-side; the model calls it with a challenge, nothing else.
- Log the id, not the token. The captcha id is enough for support and reporting; the token is single-use.
- Refuse unknown types. If the model asks for a type DeathByCaptcha does not support, fail instead of guessing.
The decision table
| Situation | DeathByCaptcha | Vision model |
|---|---|---|
| reCAPTCHA, Turnstile, WAF, DataDome | The only path | Impossible |
| Distorted or noisy image | Yes | Rarely |
| Clean image, small model, high success rate | Compare; the model can win | Possible |
| Agent loop and retries counted | Yes: price per solve, no prompt | Costs multiply |
| Page content is untrusted | Yes: bounded tool call | Prompt injection surface |
| Strict latency budget under a few seconds | Check the type; token solves take time | Unpredictable |
The short version: DeathByCaptcha is cheaper per successful solve for the token challenges, where the model cannot compete at any price, and for image challenges once the loop and the retry rate are counted. The exception — a clean image, a small model and a high success rate — is real but narrower than the sticker price suggests.
Next steps
- Agent metadata for code generators: https://github.com/deathbycaptcha/deathbycaptcha-agent-api-metadata
- Python client with the agent examples: https://github.com/deathbycaptcha/deathbycaptcha-api-client-python
- API documentation: https://deathbycaptcha.com/api
If you already have an agent loop, the change is small: add one tool, keep the credentials on the server, and let the model call DeathByCaptcha when the page becomes a challenge instead of asking it to read one.

English
Spanish
Russian
Chinese
French
Hindi
Arabic
Bengali
Indonesian
Portuguese
com, 