DEV Community: DBC

Playwright Captcha Solver: Wire Death By Captcha into Your Automation

DBC — Wed, 14 Oct 2026 11:49:53 +0000

Playwright makes browser automation fast — until a captcha challenge
stops the run mid-flow. This quickstart wires Death By Captcha (DBC)
into a Playwright script with one repeatable pattern: the script reads
the challenge parameters from the page, requests a solution from the
DBC API, injects the token back into the page, and continues — the
site verifies it exactly as if the widget had been solved in a real
browser. No click emulation, no brittle waits on challenge dialogs.

Everything below runs against Google's own public reCAPTCHA demo, so
you can test the whole loop end to end before pointing it at your own
target. The calls are the ones from the official runnable examples —
nothing here is invented. Beyond the client's few methods (balance,
upload, poll) there is no extra SDK surface to learn: the whole
integration is one request-and-inject cycle you can read in a single
sitting and reuse everywhere the same challenge type shows up.

Why the token flow

reCAPTCHA v2 has two integration shapes: replaying the interactive
challenge inside your browser context, or the token flow used here.
The token flow solves the challenge on the provider's side and returns
a response token that is valid for one submission; your script injects
it and moves on. That is what makes it work headless and inside CI:
nothing in your browser has to mimic a human pointer, and the page
sees a normal solved widget.

The same shape repeats across the supported set — the payload fields
change, the loop does not.

What you need

A DBC account — solutions are paid from your account balance, so check the balance before decoding: https://deathbycaptcha.com/register
Python 3 or Node.js, plus Playwright
Credentials in environment variables, never in the code:

export DBC_USERNAME=your_username
export DBC_PASSWORD=your_password

Install

Python:

pip install deathbycaptcha-official playwright
playwright install

Node.js:

npm install deathbycaptcha-lib playwright

The full flow in Python

import json
import os
import time

import deathbycaptcha
from playwright.sync_api import sync_playwright

DEMO_URL = "https://www.google.com/recaptcha/api2/demo"

client = deathbycaptcha.HttpClient(
    os.environ["DBC_USERNAME"], os.environ["DBC_PASSWORD"]
)


def solve_recaptcha_v2(page_url, sitekey, timeout=120):
    """Request a reCAPTCHA v2 token (API type=4), poll until solved."""
    if not client.get_balance():
        raise SystemExit("no balance - top up before decoding")
    upload = client.upload(
        type=4,
        token_params=json.dumps(
            {"googlekey": sitekey, "pageurl": page_url}
        ),
    )
    cid = upload["captcha"]
    deadline = time.time() + timeout
    while time.time() < deadline:
        time.sleep(0.5)
        detail = client.get_captcha(cid)
        if isinstance(detail, dict) and detail.get("text"):
            return detail["text"]
    raise TimeoutError("no solution; retry with backoff")


with sync_playwright() as p:
    browser = p.chromium.launch()
    page = browser.new_page()
    page.goto(DEMO_URL, timeout=60000)

    # 1. read the challenge parameters from the page
    sitekey = page.get_attribute("#recaptcha-demo", "data-sitekey")

    # 2. request the solution token from DBC
    token = solve_recaptcha_v2(DEMO_URL, sitekey)

    # 3. inject the token and trigger the page's own callback
    page.evaluate(
        """(t) => {
            const el = document.getElementById('g-recaptcha-response');
            if (!el) return;
            el.style.display = 'block';
            el.value = t;
            el.dispatchEvent(new Event('input', { bubbles: true }));
            el.dispatchEvent(new Event('change', { bubbles: true }));
            const cfg = window.___grecaptcha_cfg;
            if (!cfg || !cfg.clients) return;
            for (const k of Object.keys(cfg.clients)) {
                const c = cfg.clients[k];
                for (const key of Object.keys(c)) {
                    const item = c[key];
                    if (item && typeof item.callback === 'function')
                        return item.callback(t);
                    if (item && item.W &&
                        typeof item.W.callback === 'function')
                        return item.W.callback(t);
                }
            }
        }""",
        token,
    )

    # 4. submit and wait for the page to report success
    page.click("#recaptcha-demo-submit")
    page.wait_for_selector(".recaptcha-success", timeout=15000)
    print("solved")
    browser.close()

Run it:

python playwright_dbc_quickstart.py

If the token is accepted, the script prints solved and exits 0. If
the challenge is not solved within the timeout it raises — a broken
integration fails loudly instead of hanging your pipeline. That
failure path is the runnable test: wire the script into CI as-is, or
drop the last three lines into a test runner and assert on the
success selector like any other page state.

What each step does:

get_balance() — confirm the account can pay for the job before submitting anything.
upload(type=4, ...) — type 4 is the reCAPTCHA v2 token API. The googlekey (the widget's site key) and pageurl (the exact URL where the challenge loads, path included) identify the challenge; the client polls get_captcha() until the token text arrives.
The token goes into the page's hidden response field and the page's own reCAPTCHA callback fires — from the site's point of view the widget was solved normally.
The submit click plus the success selector close the loop.

The same flow in Node.js

const { HttpClient } = require('deathbycaptcha-lib');

const client = new HttpClient(
  process.env.DBC_USERNAME, process.env.DBC_PASSWORD);

function solveRecaptchaV2(pageUrl, sitekey) {
  return new Promise((resolve, reject) =>
    client.decode(
      {
        extra: {
          type: 4,
          token_params: JSON.stringify(
            { googlekey: sitekey, pageurl: pageUrl }),
        },
      },
      (solution) => solution && solution.text
        ? resolve(solution.text)
        : reject(new Error('no solution yet - retry with backoff'))
    ));
}

The page-side steps — extract the sitekey, request the token, inject
it, trigger the callback — are identical to the Python version. The
official sample also checks the balance first, and the full runnable
script ships in the official Node.js client repository under
examples/playwright.

Beyond reCAPTCHA v2

The same loop covers the rest of the supported set. Turnstile is the
same call with a different type and payload name — type=12 with a
turnstile_params payload carrying sitekey and pageurl — and
reCAPTCHA v3, GeeTest, DataDome, plus image and text captchas follow
their own documented payloads: each CAPTCHA type is routed to a model
specialized for that type. The official Python client ships a runnable
sample per type under examples/.

Both clients default to the encrypted HTTPS transport and also ship a
socket transport for high-throughput production runs; the method names
stay the same, so moving between them later is a constructor change,
not a rewrite.

On the library side, official clients cover Python, Node.js, C#, Java,
.NET, Go, C, C++ and Perl, and the browser extensions for Chrome/Brave
and Firefox cover the no-code path for manual sessions.

Fitting it into a bigger run

Nothing in the script has to run standalone. In a real scraper or test
suite the pattern sits next to the action that gets blocked: navigate,
detect the challenge widget on the page, call the solve step, inject,
continue. Because the token is requested only when a challenge is
actually present, unblocked runs submit no jobs at all, and the
balance check doubles as a first failure gate for scheduled jobs.
Keep the solve function in one shared module and every Playwright
entrypoint in the project can call it without copy-paste.

Notes that save runs

Keep the solve path and the submit path on the same network. The token is verified from the IP that submits it, and a mismatch between that address and the context the challenge was solved in is the usual cause of rejected tokens. If your automation already goes through a proxy, pass it in the same params payload (proxy + proxytype) so both hops align.
Retry with backoff on an empty result. "No solution yet" is transient by design — the official examples retry instead of failing immediately.
Set explicit timeouts at every hop: navigation, upload, polling, page waits. Silent stalls are how one flaky challenge turns into a hung pipeline.

Docs and sign-up

The same shape applies to the other runners: the integration pages
for Selenium and Puppeteer walk the same request-and-inject loop, and
the per-type FAQ documents every payload field the clients accept.

API reference and client links: https://deathbycaptcha.com/api
Playwright integration page: https://deathbycaptcha.com/playwright-captcha-solver
Balance and pricing: https://deathbycaptcha.com/user-pay
Create an account: https://deathbycaptcha.com/register

Best Captcha Solvers 2026: Comparison

DBC — Fri, 09 Oct 2026 14:18:53 +0000

If you are picking a captcha solving service for automation, web
scraping, or browser testing in 2026, the shortlist usually looks
the same: a handful of long-running APIs that solve reCAPTCHA,
Cloudflare Turnstile, GeeTest, and image captchas and return a
token or text answer your script can use. This article is a real
comparison of the five services that show up in those shortlists:
shared criteria, a side-by-side matrix built from each provider's
public documentation, and a per-provider analysis — so you can
re-rank the table against your own priorities.

How we compared

Six criteria, applied to every provider:

Modern captcha type coverage — reCAPTCHA (v2/v3/Enterprise), Cloudflare Turnstile, GeeTest, and image captchas.
Official client libraries — languages each provider ships officially, not community wrappers.
API and documentation — a clear HTTP flow (send the challenge, receive the solution) with real docs.
Pricing model — pay-as-you-go with published rates, plus what our own testing showed about advertised vs charged amounts (see the matrix note ¶).
Integration fit — Selenium / Playwright / Puppeteer workflows and browser extensions.
Availability — what each service publishes about uptime (status page, claims) versus what a real solve does at your hour; the DBC API accepts requests 24/7.

Method: every capability cell was checked against the provider's
own public docs on 2026-10-09; the pricing (¶) and availability (†)
notes are our own testing. Features move fast — re-check before you buy.
Scope: only the four modern types above; legacy challenge types
are out of scope. Ranking note: this is DBC's own disclosed
comparison, DBC is weighted first on integration breadth, and the
matrix is here so you can disagree with that weighting.

Side-by-side matrix

Provider	Types*	Clients	Extension	Availability	Pricing
Death By Captcha	4 of 4	9	Chrome, FF	24/7	deathbycaptcha.com/user-pay
2Captcha	4 of 4	7	Chrome	verify†	not clear¶
Anti-Captcha	4 of 4	10	—	verify†	rate page
CapSolver	4 of 4	SDKs	Chrome, FF	verify†	rate page
CapMonster Cloud	4 of 4	5	Chrome, FF	verify†	rate page

* Types = the four compared modern types — reCAPTCHA (v2/v3/Enterprise), Cloudflare Turnstile, GeeTest, and image captchas. All five cover 4 of 4, verified in each provider's public docs on 2026-10-09. Parity on types is the finding here.
Clients = official client languages published by each provider: DBC 9 (Python, Node.js, C#, Java, .NET, Go, C, C++, Perl); 2Captcha 7 (Python, Java, C#, C++, JavaScript, Ruby, PHP); Anti-Captcha 10 (Python, Node.js, Go, PHP, Java, Kotlin, C#, C++, Rust, Ruby); CapSolver ships SDKs plus community libraries without one fixed language list; CapMonster Cloud 5 (C#, Python, JS, Go, PHP).
FF = Firefox; the DBC extension also runs on Brave.
† Availability: the DBC API accepts requests 24/7. All four others publish a status page and uptime-style claims (checked 2026-10-09 — e.g. "99.9% uptime" and "uptime since 2007" appear in their marketing). Our own testing (October 2026) saw the opposite: a status page showed the service operational while a real solve request failed. Treat any "operational" badge as a starting point, not proof — verify with a live solve at your target hour.
¶ Pricing: all five publish pay-as-you-go rates. With 2Captcha, our own testing (October 2026) hit a mismatch between the rate advertised on their site and the amount actually charged — we mark them "not clear": verify for yourself with a small run before committing. We quote no figures here; read current rates on each provider's rate page.

1. Death By Captcha (DBC)

Death By Captcha (DBC) is a reliable captcha solver API for
automation, web scraping, and browser workflows, with official
client libraries, browser extensions, and support for modern
captcha types. Against the criteria:

Types: all four covered — each CAPTCHA type is routed to a model specialized for that type.
Clients: nine official ones (Python, Node.js, C#, Java, .NET, Go, C, C++, Perl), covering both application stacks and systems languages (C, C++, Perl) in one official set.
Extension: Chrome and Firefox stores; the Chrome build also runs on Brave.
Availability: the API accepts requests 24/7.
Workflow: official examples for Selenium, Playwright, and Puppeteer — send the challenge (type, page URL, sitekey), get the solution back, inject the token into your run.
Docs and pricing: public API docs, public rate page, pay-as-you-go.

Start with the API docs, check
the rate page for pricing,
and create an account.

2. 2Captcha

A long-running service with a wide HTTP API and seven official
client libraries (Python, Java, C#, C++, JavaScript, Ruby, PHP).
All four compared types are covered, the official extension lives
in the Chrome store, and the docs ship ready-made code examples
for scraping scripts. Trade-off vs the rest of this table:
Firefox users are not covered by an official extension.

3. Anti-Captcha

The most developer-facing of the five: a documentation-first API
with an apidoc, tutorials, and the widest official client list
here — ten languages (Python, Node.js, Go, PHP, Java, Kotlin, C#,
C++, Rust, Ruby). All four compared types are covered. Trade-off:
it is API-only — no browser extension appears on their public
surface, so everything runs through your own code.

4. CapSolver

A newer-generation, task-based API covering all four compared
types plus adjacent protections (AWS WAF, Cloudflare challenge).
Its weight sits in integration: SDKs with community libraries,
hooks for Selenium, Puppeteer, Playwright and n8n, an official
Chrome/Firefox extension, and 2026-era agent integrations (MCP
and agent tooling). Docs are organized as guides per captcha type.

5. CapMonster Cloud

A straightforward JSON request/response API with five official
SDKs (C#, Python, JS, Go, PHP) and official Chrome and Firefox
extensions. All four compared types are covered. It is the
simplest of the five to start with if one of those five languages
fits your stack; teams outside them lean on community libraries.

How to choose

Start from the matrix: if a provider misses a type you need or your language, it is out.
Check the official client for your stack — Python and Node.js cover most teams, but on Go, .NET, C or Rust the lists diverge fast.
Read the docs before signing up: the send-solution flow has to fit your run loop cleanly.
Test on your own targets first: one integration, small batches, measure solve quality against your real sites.
Compare pricing on each provider's rate page — figures change, and verify the actual charge with a small run: at least one provider here billed us differently than advertised.
Verify availability with a live solve at your own target hour: in our testing, a status badge showed "operational" while a real request failed.

Bottom line

On the four modern types the market treats as table stakes, all
five services are effectively at parity — so the real decision is
about clients, docs, extensions, and workflow fit, which is what
the matrix and the notes above spell out. Our own weighting puts
Death By Captcha (DBC) first for integration breadth: nine
official clients, extensions for both browser families, 24/7 API
availability, official Selenium/Playwright/Puppeteer examples,
and typed-model routing behind one API.