CAPTCHA Solver Services and APIs Compared

Prices in the table are copied from each service's own pricing page on 2026-10-27, per 1,000 solved CAPTCHAs. They change often, so check the page before you buy.

2Captcha's page showed prices in British pounds when we read it; the "Who solves" column quotes each service's own home page. Enterprise versions cost more: reCAPTCHA v3 Enterprise is $1.50 at CapMonster Cloud and $3.00 at CapSolver, and reCAPTCHA Enterprise is $5 at Anti-Captcha.

What the numbers mean for a budget:

• reCAPTCHA: plan on $0.60 to $3 per 1,000 tokens. The AI services are at the low end; the human and hybrid services cost more and handle odd challenge types.
• hCaptcha: none of the five pricing pages lists it on 2026-10-27, so ask a service before you build on it. hCaptcha's own published prices are what site owners pay to run it, not what solving costs.
• Speed: CapSolver lists under 9 s for reCAPTCHA v2 and under 3 s for v3 and Turnstile; DeathByCaptcha's live snapshot showed about 4 s for reCAPTCHA; Anti-Captcha states 5 s. These are the services' own figures: measure on your target.

Other kinds of solvers: CAPTCHA solver extensions for Chrome solve in the page you are viewing; open-source OCR libraries read old text CAPTCHAs; and the CAPTCHA types themselves (reCAPTCHA, hCaptcha, Turnstile, GeeTest) are compared in CAPTCHA providers compared.

A solver bills for tokens it returns; you pay for tokens the site accepts. Divide one by the other.

When the solver works through your proxy, the traffic it uses on that proxy is billed to your proxy balance as well. Fewer triggers cut the bill more than a lower rate: if a slower request rate and cleaner IPs halve your CAPTCHAs, they halve the solving cost.

Every service above uses the same pattern: create a task, poll for the result, submit the token. Anti-Captcha's API is POST https://api.anti-captcha.com/createTask and /getTaskResult, with clientKey and a task object in the JSON body; 2Captcha uses the same methods on https://api.2captcha.com. A task returns status: "processing" until it is "ready", and the reCAPTCHA token is in solution.gRecaptchaResponse.

What matters at volume:

import asyncio
import httpx

API = "https://api.2captcha.com"          # or "https://api.anti-captcha.com": the same JSON methods
KEY = "YOUR_SOLVER_KEY"
PF_LOGIN, PF_PASS = "<login>", "<password>"
MAX_IN_FLIGHT = 20                        # below your solver's limit and your balance at peak


async def solve(client, sem, job_id, site_key, page_url, timeout=180, retries=2):
    # one ProxyField sticky session per job: the solver and your scraper exit from the same IP
    pf_user = f"{PF_LOGIN}-country-us-session-{job_id}-ttl-600"
    task = {"type": "RecaptchaV2Task", "websiteURL": page_url, "websiteKey": site_key,
            "proxyType": "http", "proxyAddress": "gate.proxyfield.io", "proxyPort": 7000,
            "proxyLogin": pf_user, "proxyPassword": PF_PASS}
    async with sem:
        for attempt in range(retries + 1):
            r = (await client.post(f"{API}/createTask", json={"clientKey": KEY, "task": task})).json()
            if r.get("errorCode") == "ERROR_NO_SLOT_AVAILABLE":
                await asyncio.sleep(5)
                continue
            if r.get("errorId"):
                raise RuntimeError(r.get("errorCode"))
            loop = asyncio.get_running_loop()
            deadline = loop.time() + timeout
            while loop.time() < deadline:
                await asyncio.sleep(5)
                res = (await client.post(f"{API}/getTaskResult",
                                         json={"clientKey": KEY, "taskId": r["taskId"]})).json()
                if res.get("errorId"):
                    break                 # unsolvable or failed: retry with a new task
                if res.get("status") == "ready":
                    return pf_user, res["solution"]["gRecaptchaResponse"]
        raise TimeoutError(f"job {job_id}: no token")


async def main(jobs):
    sem = asyncio.Semaphore(MAX_IN_FLIGHT)
    async with httpx.AsyncClient(timeout=30) as client:
        return await asyncio.gather(
            *(solve(client, sem, j["id"], j["site_key"], j["url"]) for j in jobs),
            return_exceptions=True)

# jobs = [{"id": "job0001", "site_key": "...", "url": "https://example.com/form"}, ...]
# results = asyncio.run(main(jobs))

Then send the form from your scraper through http://<pf_user>:<password>@gate.proxyfield.io:7000, with the token in g-recaptcha-response (hCaptcha: h-captcha-response) or passed to the callback named in the widget's data-callback attribute. Keep session ids to letters and digits, like the job0001 above. A ProxyField sticky session holds one IP for up to the ttl you set (30 to 129,600 seconds, 20 minutes by default); an IP idle for 120 s gets a new IP, so submit soon after the token arrives. More on concurrency in Python: async web scraping in Python.

A decision rule from the table, before you test:

Then measure on your own target, on a few hundred tasks at your real concurrency:

1. Accept rate. "Solved" by the service is not "accepted" by the site.
2. Solve time. The median and the slow tail; a token that arrives after it expires is wasted.
3. Price per accepted token (the section above).
4. Proxy support. Some sites check that the token was solved from the IP and browser that submits it.
5. Queue at peak. Watch for no-slot errors and slower solves when you run your full concurrency.
6. Terms and data. Read what the service does with the pages you send, and whether its terms allow your use.

A CAPTCHA solver takes a challenge your script cannot answer and returns what the page expects. For a text CAPTCHA that is the text; for reCAPTCHA, hCaptcha or Turnstile it is a token, a long string the page normally gets when a person passes the check. Your script reads the type, the site key (a public value in the page's HTML) and the page URL, sends them to the service, polls for the answer and submits it as the page would. "CAPTCHA solver for humans" usually means the other direction: help for people who struggle with CAPTCHAs, which most CAPTCHA vendors cover with an audio alternative.

For some tasks, yes. Token CAPTCHAs can be solved "proxyless" (the service uses its own IPs) or through your proxy. When a site ties the token or its follow-up checks to the IP, a proxyless token fails; passing your proxy keeps the IP the same from solve to submit.

ProxyField proxies use the fields every service above asks for: proxyType http (or socks5), proxyAddress gate.proxyfield.io, proxyPort 7000, and your username and password. Put a session in the username so the solver and your scraper share one IP: <login>-country-us-session-job0001-ttl-600, with -region-<region> and -city-<city> if you need a place, as in <login>-country-us-region-new_york-city-new_york-session-he9f2qga-ttl-600. Where you use an IP allowlist instead of a password, allowlist the solver's IPs and give it the port you set up in the dashboard instead of 7000.

• It expired. Tokens are short-lived and single-use: hCaptcha's default window is 120 seconds.
• Wrong site key or page. The token was solved for another key or URL than the one that verifies it.
• IP or browser mismatch. Solved from one IP and submitted from another, or with another User-Agent.
• The score, not the puzzle. Score-based systems such as reCAPTCHA v3 can reject a valid token when the rest of the request looks automated; that is why v3 prices depend on the score.
• Submitted the wrong way. The page reads the token through a callback, not the hidden field.

Machine learning already solves most image and token CAPTCHAs: CapMonster Cloud and CapSolver are AI services, and 2Captcha sends most tasks to AI models first. That is why modern systems lean on invisible signals (browser checks, behavior, scores) more than on the puzzle. CyberSiARA, for example, markets its SiARA Shield as a human visual test "designed to resist AI and OCR-based attacks", shown only when behavioral analysis finds a session suspicious (CyberSiARA); more in DataDome, PerimeterX and hCaptcha CAPTCHAs.

It depends on the site's terms and on what you use it for. A CAPTCHA in front of a login, a sign-up or a checkout shows the site does not want that action automated; using solvers to create fake accounts, post spam or buy limited stock in bulk is the abuse CAPTCHAs exist to stop. ProxyField's acceptable use policy forbids fake accounts, fake engagement and fraud: collect public pages only and follow the site's terms. See is web scraping legal.

A solver is the last step. Cut the number of challenges first with a slower rate, a consistent client and clean IPs: how to avoid and solve CAPTCHAs when scraping has the checklist, and CAPTCHA proxies covers what proxies change.

Residential IPs for your scraper and your solver. ProxyField residential proxies: 412M+ IPs in 195+ countries, per-request rotation or sticky sessions up to 36 h, HTTP, HTTPS and SOCKS5 on gate.proxyfield.io:7000, a 99.6% success rate according to our service data. $2.95/GB for 1 GB down to $1.95/GB from 1,000 GB, no subscription; start with the Easy Trial (1 GB for $2.95). Traffic never expires, and all purchases are final.