CaptchaAI VIP Plans Explained: When to Upgrade to 1,000+ Threads

Most CaptchaAI users never outgrow the ENTERPRISE plan (200 threads, $300/month). But some operations genuinely need more. Distributed scraping networks, high-frequency monitoring systems, and multi-tenant SaaS products can exhaust 200 threads quickly.

CaptchaAI's VIP plans exist for exactly these cases.

VIP plan overview

All VIP plans include:

• Unlimited CAPTCHA solves
• All supported CAPTCHA types (reCAPTCHA all variants, Cloudflare, GeeTest, BLS, Image/OCR, Grid)
• Same REST API used by all plans
• 10% annual discount

Note: You can also order multiple plans to stack threads. Two ENTERPRISE plans ($600/month) give 400 threads. VIP-1 ($1,500/month) gives 1,000 threads at a lower per-thread cost.

What 1,000 threads actually delivers

With 1,000 concurrent threads, your capacity per CAPTCHA type:

For context: 240,000 reCAPTCHA v2 solves per hour at VIP-1. If you need that, VIP is your tier.

ROI comparison vs per-solve pricing at VIP volumes

VIP-1 ($1,500/month): 10,000,000 reCAPTCHA v2 solves/month

VIP-3 ($7,500/month): 50,000,000 solves/month

At VIP-3 volumes, CaptchaAI saves over $1.7 million per year compared to per-solve pricing at 2Captcha rates.

VIP vs stacking Enterprise plans

For operations between 200 and 1,000 threads, the math between stacking Enterprise plans and buying VIP-1 is worth examining:

Cost-per-thread is identical. The advantage of VIP-1 is a single subscription instead of five separate plan invoices. For operations 400–800 threads, stacking Enterprise plans is fine and avoids over-committing.

When to choose VIP over stacking Enterprise

Choose VIP-1 when:

• You need 1,000 threads consistently
• You prefer consolidated billing (one plan vs multiple)
• You're a platform or SaaS with guaranteed sustained volume

Choose stacking Enterprise when:

• Your thread requirement varies between 200 and 800
• You want flexibility to scale down without renegotiating a plan
• You're growing into the 1,000-thread requirement gradually

Handling 1,000 concurrent tasks in code

import asyncio
import aiohttp

API_KEY = "YOUR_API_KEY"

async def submit_captcha(session, site_key, page_url):
    """Submit a single reCAPTCHA v2 task asynchronously."""
    async with session.post("https://ocr.captchaai.com/in.php", data={
        "key": API_KEY,
        "method": "userrecaptcha",
        "googlekey": site_key,
        "pageurl": page_url,
        "json": 1,
    }) as resp:
        result = await resp.json(content_type=None)
        if result.get("status") != 1:
            raise Exception(f"Submit error: {result.get('request')}")
        return result["request"]

async def poll_result(session, task_id, timeout=120):
    """Poll for result with async backoff."""
    for _ in range(timeout // 5):
        await asyncio.sleep(5)
        async with session.get("https://ocr.captchaai.com/res.php", params={
            "key": API_KEY,
            "action": "get",
            "id": task_id,
            "json": 1,
        }) as resp:
            result = await resp.json(content_type=None)
            if result.get("status") == 1:
                return result["request"]
            if result.get("request") != "CAPCHA_NOT_READY":
                raise Exception(f"Error: {result.get('request')}")
    raise Exception("Timeout")

async def solve_many(tasks, concurrency=1000):
    """Solve multiple CAPTCHAs with bounded concurrency."""
    semaphore = asyncio.Semaphore(concurrency)
    async with aiohttp.ClientSession() as session:
        async def bounded_solve(site_key, page_url):
            async with semaphore:
                task_id = await submit_captcha(session, site_key, page_url)
                return await poll_result(session, task_id)

        results = await asyncio.gather(
            *[bounded_solve(sk, url) for sk, url in tasks],
            return_exceptions=True
        )
    return results

# Run 1,000 parallel solves
import asyncio
tasks = [("6Le-wvkS...", f"https://example.com/page/{i}") for i in range(1000)]
tokens = asyncio.run(solve_many(tasks, concurrency=1000))
successful = [t for t in tokens if not isinstance(t, Exception)]
print(f"Solved: {len(successful)}/1000")

FAQ

Is there a plan above VIP-3? CaptchaAI's pricing page notes that you can order multiple plans to get more threads. For requirements above 5,000 threads, contact the team for a custom arrangement.

How long does it take to activate a VIP plan? VIP plans activate immediately through the standard checkout process, same as other plans.

Can I trial a VIP plan before committing? CaptchaAI offers a 1-day trial. For VIP-level volume validation, contact support to discuss evaluation options.

Does VIP pricing change for annual billing? Yes. All VIP plans receive the 10% annual discount. VIP-3 annual is $6,750/month vs $7,500 monthly.

Scale without limits

CaptchaAI VIP plans are built for operations where per-solve pricing would cost tens of thousands of dollars per month. If your volume justifies the tier, the savings compared to alternatives are substantial. Contact CaptchaAI at captchaai.com to set up a VIP plan.