CaptchaAI's Unlimited Solves Model Explained

Most CAPTCHA solving APIs charge per solve. Every reCAPTCHA token, every image, every Turnstile challenge deducts a credit. CaptchaAI works differently: you pay a fixed monthly subscription based on how many CAPTCHAs you want to solve at the same time — not how many you solve in total.

This distinction matters enormously once your volume scales past a few thousand solves per month.

What "unlimited solves" actually means

A thread in CaptchaAI's model is one concurrent solve slot. If you have 5 threads, you can have 5 CAPTCHAs being solved simultaneously at any given moment. Once a solve completes, that thread is free for the next task.

There is no monthly cap on total solves. You can run your 5 threads around the clock for 30 days and solve as many CAPTCHAs as you need. The only limit is how many you can run in parallel at one time.

CaptchaAI thread model:

Thread 1: [Solve A]──[Solve B]──[Solve C]──[Solve D]──...
Thread 2: [Solve E]──[Solve F]──[Solve G]──[Solve H]──...
Thread 3: [Solve I]──[Solve J]──[Solve K]──[Solve L]──...
Thread 4: [Solve M]──[Solve N]──[Solve O]──[Solve P]──...
Thread 5: [Solve Q]──[Solve R]──[Solve S]──[Solve T]──...

All solved → Unlimited total, 5 at once max

Compare that to per-solve providers, where every letter in the diagram above costs money.

The math: threads vs per-solve at scale

Here is what the BASIC plan ($15/month, 5 threads) looks like across different volumes:

At 1,000 solves per day, CaptchaAI on the Basic plan costs $15. The same volume on a per-solve API costs $90 or more. The savings multiply as you scale.

What happens when you hit your thread limit

If all your threads are busy and a new CAPTCHA is submitted, the API returns ERROR_NO_SLOT_AVAILABLE. Your code should queue the task and retry after a short wait.

import requests
import time

API_KEY = "YOUR_API_KEY"

def submit_captcha_with_retry(site_key, page_url, max_retries=10):
    """Submit reCAPTCHA v2 with retry on thread limit."""
    for attempt in range(max_retries):
        resp = requests.post("https://ocr.captchaai.com/in.php", data={
            "key": API_KEY,
            "method": "userrecaptcha",
            "googlekey": site_key,
            "pageurl": page_url,
            "json": 1,
        })
        result = resp.json()
        if result.get("status") == 1:
            return result["request"]  # task ID
        if result.get("request") == "ERROR_NO_SLOT_AVAILABLE":
            print(f"All threads busy, retrying in 5s (attempt {attempt + 1})")
            time.sleep(5)
            continue
        raise Exception(f"Submit error: {result}")
    raise Exception("Thread slots never freed — consider upgrading your plan")

def poll_result(task_id, timeout=120):
    """Poll until solved."""
    for _ in range(timeout // 5):
        time.sleep(5)
        resp = requests.get("https://ocr.captchaai.com/res.php", params={
            "key": API_KEY,
            "action": "get",
            "id": task_id,
            "json": 1,
        })
        result = resp.json()
        if result.get("status") == 1:
            return result["request"]
        if result.get("request") != "CAPCHA_NOT_READY":
            raise Exception(f"Solve error: {result}")
    raise Exception("Timeout waiting for solve")

If you frequently hit ERROR_NO_SLOT_AVAILABLE, your workload needs more threads. Upgrade to the next plan or stack multiple plans for higher concurrency.

Which plan fits which workload

The effective cost per solve drops as threads increase — because each additional thread adds capacity without adding per-unit cost.

Why AI solving makes unlimited viable

Per-solve APIs that use human workers can't offer unlimited pricing because each solve requires paying a human. CaptchaAI solves CAPTCHAs with AI — once the infrastructure is running, the marginal cost of one more solve is near zero.

This is why CaptchaAI can offer:

• Unlimited total solves at a fixed monthly fee
• Consistent speed — no queues behind human workers
• 100% Cloudflare Turnstile success rate — AI doesn't vary like humans

When per-solve pricing is cheaper

For very low volumes (under 200 solves/month), a per-solve API with a pay-as-you-go model might be lower total cost. At $0.003/solve, 200 solves is $0.60. CaptchaAI's minimum plan is $15/month.

If you solve CAPTCHAs regularly and your volume is above 500/month, CaptchaAI's unlimited model wins on cost.

FAQ

Does "unlimited" have any fair use restrictions? CaptchaAI's unlimited solves are genuinely unlimited within your thread count. The thread count is your constraint — not a monthly cap. If you need reassurance for a high-volume use case, contact CaptchaAI support.

What happens to unused thread capacity? It is available the next time you submit a task. Unused capacity does not roll over or accumulate — threads are concurrent solve slots, not a balance.

Can I add more threads without switching plans? Yes. You can subscribe to multiple plans simultaneously. Your total threads are additive. This is the recommended approach for bursting beyond a single plan's limit.

Does the model change for different CAPTCHA types? No. Whether you solve reCAPTCHA v2, Cloudflare Turnstile, BLS, or image CAPTCHAs, the thread model is the same. Type affects solve speed (and therefore throughput per thread), but not pricing structure.

Start with unlimited solves

CaptchaAI plans start at $15/month. There is no per-solve billing, no credits to top up constantly, and no surprise charges when your scraper runs overnight. Get your API key at captchaai.com and start solving CAPTCHAs at scale.