Limites de solicitação simultânea CaptchaAI: diagnóstico e correções

Quando você executa muitas tarefas CAPTCHA paralelas, CaptchaAI retorna ERROR_NO_SLOT_AVAILABLE. Isso significa que você excedeu o limite de tarefas simultâneas da sua conta. Este guia explica os limites, como lidar com eles e como maximizar o rendimento sem atingir o limite.

Sintomas

Entendendo os limites

CaptchaAI possui dois tipos de limites de taxa:

O limite de tarefas simultâneas depende do seu plano. Verifique seu painel emcaptchaai.compara o seu limite atual.

Correção 1: adicione um semáforo para limitar a simultaneidade

Controle quantas tarefas são executadas em paralelo:

import requests
import time
import threading

API_KEY = "YOUR_API_KEY"
MAX_CONCURRENT = 20  # Stay below your account limit

semaphore = threading.Semaphore(MAX_CONCURRENT)


def solve_captcha(params):
    """Solve a CAPTCHA with concurrency control."""
    with semaphore:
        params["key"] = API_KEY
        params["json"] = 1

        submit = requests.post("https://ocr.captchaai.com/in.php", data=params).json()
        if submit.get("status") != 1:
            raise RuntimeError(f"Submit: {submit.get('request')}")

        task_id = submit["request"]
        time.sleep(10)

        for _ in range(30):
            result = requests.get("https://ocr.captchaai.com/res.php", params={
                "key": API_KEY, "action": "get", "id": task_id, "json": 1
            }).json()
            if result.get("status") == 1:
                return result["request"]
            if result.get("request") != "CAPCHA_NOT_READY":
                raise RuntimeError(f"Solve: {result['request']}")
            time.sleep(5)
        raise TimeoutError("Timed out")

Correção 2: tente novamente em ERROR_NO_SLOT_AVAILABLE

Quando você atingir o limite, espere e tente novamente em vez de falhar imediatamente:

def submit_with_retry(params, max_retries=5):
    """Submit with automatic retry for slot errors."""
    params["key"] = API_KEY
    params["json"] = 1

    for attempt in range(max_retries):
        resp = requests.post("https://ocr.captchaai.com/in.php", data=params).json()

        if resp.get("status") == 1:
            return resp["request"]

        error = resp.get("request", "")
        if error == "ERROR_NO_SLOT_AVAILABLE":
            wait = 2 ** attempt  # Exponential backoff: 1, 2, 4, 8, 16 seconds
            print(f"No slot available, retrying in {wait}s (attempt {attempt + 1})")
            time.sleep(wait)
            continue
        else:
            raise RuntimeError(f"Submit error: {error}")

    raise RuntimeError("Max retries exceeded — no slots available")

Correção 3: use uma fila de tarefas

Em vez de inundar a API, enfileire tarefas e processe-as em uma taxa controlada:

from queue import Queue
from threading import Thread

task_queue = Queue()
results = {}


def worker():
    while True:
        task_id_local, params = task_queue.get()
        try:
            token = solve_captcha(params)
            results[task_id_local] = {"status": "ok", "token": token}
        except Exception as e:
            results[task_id_local] = {"status": "error", "message": str(e)}
        finally:
            task_queue.task_done()


# Start worker threads (limited by semaphore)
for _ in range(MAX_CONCURRENT):
    t = Thread(target=worker, daemon=True)
    t.start()

# Add tasks to queue
captcha_tasks = [
    {"method": "userrecaptcha", "googlekey": "KEY1", "pageurl": "https://site1.com"},
    {"method": "userrecaptcha", "googlekey": "KEY2", "pageurl": "https://site2.com"},
    # ... more tasks
]

for i, params in enumerate(captcha_tasks):
    task_queue.put((i, params))

task_queue.join()
print(f"Completed: {len(results)} tasks")

Correção 4: reduza a frequência de votação

A pesquisa com muita frequência desperdiça chamadas de API e pode acionar limites de taxa:

# WRONG — polling every 1 second
time.sleep(1)

# CORRECT — poll every 5 seconds
time.sleep(5)

# BETTER — wait longer on initial delay, then poll
time.sleep(15)  # Initial wait
for _ in range(20):
    # ... poll
    time.sleep(5)

Monitorando tarefas ativas

Acompanhe quantas tarefas estão ativas no momento:

active_count = 0
lock = threading.Lock()

def track_solve(params):
    global active_count
    with lock:
        active_count += 1
        print(f"Active tasks: {active_count}/{MAX_CONCURRENT}")
    try:
        return solve_captcha(params)
    finally:
        with lock:
            active_count -= 1

Perguntas frequentes

Qual é o limite de tarefas simultâneas padrão?

Depende do seu plano de conta. Verifique seu painel CaptchaAI para saber seu limite atual. Você pode aumentá-lo atualizando seu plano.

A votação conta para o limite de taxa?

Sim. Cada solicitação res.php conta. Faça pesquisas a cada 5 segundos, não a cada 1 segundo.

Posso aumentar meu limite simultâneo?

Sim. Entre em contato com o suporte CaptchaAI ou atualize seu plano para aumentar o número máximo de tarefas simultâneas.

Qual é a diferença entre ERROR_NO_SLOT_AVAILABLE e HTTP 429?

ERROR_NO_SLOT_AVAILABLE significa muitas tarefas sendo resolvidas. HTTP 429 significa muitas solicitações de API por segundo (mesmo apenas pesquisas). Ambos exigem recuo.

Dimensione sua solução em CaptchaAI

Maximize o rendimento emcaptchaai.com.

Guias relacionados

• Limites de taxa e limitação
• Limitação de taxa de API CaptchaAI e 429 respostas
• Resolução paralela de CAPTCHA
• ERROR_NO_SLOT_AVAILABLE Gerenciamento de filas