Why DeathByCaptcha is the cheaper way to solve CAPTCHAs in an AI agent

Why DeathByCaptcha is the cheaper way to solve CAPTCHAs in an AI agent

Posted on 2026-11-20 | 7 min read | Category: captcha-automation | By DeathByCaptcha Engineering Team

CAPTCHA Automation


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.

Common pitfalls

  • Using a CAPTCHA solving service for illegitimate purposes instead of legitimate automation and testing.
  • Hard-coding credentials or API keys in client-side code that users can inspect.
  • Sending the wrong CAPTCHA type parameter, which returns incorrect or empty responses.
  • Failing to poll for the solution status and not handling timeouts gracefully.
  • Scaling automation without monitoring error rates, response times, and CAPTCHA type coverage.
DBC
Written by DeathByCaptcha Engineering Team
DeathByCaptcha engineers build and operate the CAPTCHA solving technology behind this site. Articles are written by our technical team and checked for accuracy before publishing.
Reviewed by DeathByCaptcha Editorial Team

Get your API key — start solving

Free to try · No credit card · Python, Node.js, Java, C# SDKs

Get your API key


Status: OK

Servers are fully operational with faster than average response time.
  • Average solving time
  • 4 seconds - Normal CAPTCHAs (1 min. ago)
  • 8 seconds - reCAPTCHA V2, V3 (1 min. ago)
  • 4 seconds - others (1 min. ago)
Chrome and Firefox logos
Browser extensions available

Updates

  1. Nov 19: We are currently updating our cryptocurrency payment processor, Hekelet, so crypto payments may be temporarily unavailable. In the meantime, you can purchase credits through 2Checkout or contact our support team for assistance. We expect normal crypto payment processing to be restored within this week. Thank you for your patience and understanding!
  2. May 13: Crypto payments got better! You can now purchase your CAPTCHAs using cryptocurrency through the Hekelet payment processor at https://deathbycaptcha.com/user-pay and receive an extra 20% FREE CAPTCHA credit with every package purchased this way.
  3. Apr 15: GitHub Updates: We’ve upgraded our libraries, expanded sample code, enhanced documentation, and added support for C++ and Go, making integration smoother than ever. Explore what’s new at github.com/deathbycaptcha!

  4. Previous updates…

Support

Our system is designed to be completely user-friendly and easy-to-use. Should you have any trouble with it, simply email us at DBC technical support emailcom, and a support agent will get back to you as soon as possible.

Live Support

Available Monday to Friday (10am to 4pm EST) Live support image. Link to live support page