How to Get the Most from CaptchaAI's Free Trial

CaptchaAI offers a 1-day trial so you can verify the service fits your use case before subscribing. One day is enough time to test everything that matters — if you know what to check.

This guide walks through the exact tests to run during your trial to make an informed decision.

Getting trial access

1. Visit ticket.captchaai.com and submit a trial request
2. CaptchaAI support activates your account with trial access
3. Log in to captchaai.com and retrieve your API key
4. Your trial runs for 24 hours from activation

The API key you receive during the trial is the same key you keep if you subscribe. Your integration code continues working without modification.

Trial checklist

Run through these in order, from fastest to most time-consuming.

1. Verify API connectivity (5 minutes)

import requests

API_KEY = "YOUR_API_KEY"  # Replace with your trial key

# Check balance and confirm API auth works
resp = requests.get("https://ocr.captchaai.com/res.php", params={
    "key": API_KEY,
    "action": "getbalance",
    "json": 1,
})
result = resp.json()
print(f"API status: {result}")
# Expected: {"status": 1, "request": "1.00000"} or similar

If this returns an error, check your API key. The endpoint must be ocr.captchaai.com, not captchaai.com.

2. Solve your primary CAPTCHA type (15 minutes)

Test with the CAPTCHA type your production system encounters. The code below handles reCAPTCHA v2; swap the method for other types.

import requests
import time

API_KEY = "YOUR_API_KEY"

def solve_and_time(method_params):
    """Submit a task and measure end-to-end solve time."""
    start = time.time()

    # Submit
    resp = requests.post("https://ocr.captchaai.com/in.php", data={
        "key": API_KEY,
        "json": 1,
        **method_params,
    })
    result = resp.json()
    if result["status"] != 1:
        return None, f"Submit error: {result['request']}"

    task_id = result["request"]
    submit_time = time.time() - start

    # Poll
    for attempt in range(30):
        time.sleep(5)
        res = requests.get("https://ocr.captchaai.com/res.php", params={
            "key": API_KEY,
            "action": "get",
            "id": task_id,
            "json": 1,
        }).json()
        if res["status"] == 1:
            total_time = time.time() - start
            return res["request"], f"Solved in {total_time:.1f}s (submit: {submit_time:.2f}s)"
        if res["request"] != "CAPCHA_NOT_READY":
            return None, f"Error: {res['request']}"
    return None, "Timeout"

# Test reCAPTCHA v2
token, stats = solve_and_time({
    "method": "userrecaptcha",
    "googlekey": "6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-",
    "pageurl": "https://www.google.com/recaptcha/api2/demo",
})
print(f"reCAPTCHA v2: {stats}")
if token:
    print(f"Token: {token[:40]}...")

# Test Cloudflare Turnstile
token, stats = solve_and_time({
    "method": "turnstile",
    "sitekey": "0x4AAAAAAABUYP0XeMJF0xoy",
    "pageurl": "https://peet.ws/turnstile-test/managed.html",
})
print(f"Cloudflare Turnstile: {stats}")

3. Test the CAPTCHA types you'll use in production (30 minutes)

4. Measure real solve times (1 hour)

Run 10+ solves for each CAPTCHA type you care about. Record:

• Fastest solve
• Slowest solve
• Average

Compare against CaptchaAI's published benchmarks (reCAPTCHA v2 < 60s, Turnstile < 10s, image < 0.5s). In practice, most solves land well within these maximums.

import statistics

results = []
for i in range(10):
    token, stats = solve_and_time({
        "method": "userrecaptcha",
        "googlekey": "6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-",
        "pageurl": "https://www.google.com/recaptcha/api2/demo",
    })
    if token:
        # Extract time from stats string
        t = float(stats.split("in ")[1].split("s")[0])
        results.append(t)
        print(f"Solve {i+1}: {t:.1f}s")

if results:
    print(f"\nAvg: {statistics.mean(results):.1f}s")
    print(f"Min: {min(results):.1f}s")
    print(f"Max: {max(results):.1f}s")

5. Test error handling and retry logic (30 minutes)

Intentionally trigger errors to confirm your code handles them:

# Test invalid API key handling
resp = requests.post("https://ocr.captchaai.com/in.php", data={
    "key": "INVALID_KEY",
    "method": "userrecaptcha",
    "googlekey": "dummy",
    "pageurl": "https://example.com",
    "json": 1,
})
print(f"Invalid key response: {resp.json()}")
# Expected: {"status": 0, "request": "ERROR_WRONG_USER_KEY"}

6. Estimate your thread requirements (30 minutes)

During the trial, observe how many solves you run in parallel at peak. This tells you your required thread count:

import threading

concurrent_peak = threading.local()
lock = threading.Lock()
max_concurrent = [0]
current = [0]

# Wrap your solve function to track concurrency
def tracked_solve(*args, **kwargs):
    with lock:
        current[0] += 1
        if current[0] > max_concurrent[0]:
            max_concurrent[0] = current[0]
    try:
        return solve_and_time(*args, **kwargs)
    finally:
        with lock:
            current[0] -= 1

# After your trial tests:
print(f"Peak concurrent solves observed: {max_concurrent[0]}")
print(f"Recommended minimum threads: {int(max_concurrent[0] * 1.25) + 1}")

What to decide before the trial ends

By the end of your trial you should know:

1. Average solve time for your CAPTCHA type → Confirms the service meets speed requirements
2. Peak concurrency observed → Tells you which plan to buy
3. Error rate → Should be < 0.5% for well-formed requests
4. API response format → Your code is ready for production

With these four data points, picking a plan is straightforward using the thread count calculator.

FAQ

Can I extend the trial if I need more time? Contact CaptchaAI support and explain your situation. Trial extensions are handled case by case.

Does the trial have thread limits? Trial access typically includes a limited thread count sufficient for evaluation. For high-concurrency testing, contact support.

Is my trial API key the same as my production key? Yes. If you subscribe after the trial, the same key continues working without reconfiguration.

What if the solve quality isn't what I expected? Try the solve again — CAPTCHAs vary in difficulty. If you observe consistently low success rates, share sample CAPTCHAs with support for review.

Request your trial

The 1-day trial is the fastest way to validate CaptchaAI before committing. Request access at ticket.captchaai.com and run through this checklist to make an informed decision.