ERROR_ZERO_BALANCE significa que sua conta CaptchaAI não tem fundos para processar tarefas. Veja como lidar com isso com elegância, configurar alertas e evitar tempos de inatividade inesperados.
Por que esse erro ocorre
| Causa | Frequência | Resolução |
|---|---|---|
| Saldo da conta esgotado | Mais comum | Adicione fundos em captchaai.com |
| Uso acima do esperado | Comum | Configurar monitoramento de saldo |
| Exposição acidental de chave | Raro | Gire a chave de API e verifique o uso |
| A forma de pagamento expirou | Ocasional | Atualizar informações de faturamento |
Verificação rápida de saldo
import requests
def check_balance(api_key):
"""Check current CaptchaAI balance."""
resp = requests.get(
"https://ocr.captchaai.com/res.php",
params={"key": api_key, "action": "getbalance", "json": 1},
timeout=10,
)
data = resp.json()
if data.get("status") == 1:
return float(data["request"])
raise RuntimeError(f"Balance check failed: {data.get('request')}")
balance = check_balance("YOUR_API_KEY")
print(f"Balance: ${balance:.4f}")
Lide com o equilíbrio zero com elegância
import requests
import time
import logging
logger = logging.getLogger(__name__)
class BalanceAwareSolver:
"""Solver that handles zero balance without crashing."""
def __init__(self, api_key, min_balance=0.50):
self.api_key = api_key
self.min_balance = min_balance
self._last_balance_check = 0
self._cached_balance = None
def solve(self, params):
"""Solve CAPTCHA with balance pre-check."""
# Check balance every 5 minutes
if time.time() - self._last_balance_check > 300:
self._check_balance()
if self._cached_balance is not None and self._cached_balance < 0.01:
raise InsufficientBalanceError(
f"Balance too low: ${self._cached_balance:.4f}. "
"Add funds at https://captchaai.com"
)
try:
return self._submit_and_poll(params)
except ZeroBalanceError:
self._cached_balance = 0.0
logger.error("ERROR_ZERO_BALANCE — add funds at captchaai.com")
raise
def _check_balance(self):
"""Check and cache balance."""
try:
resp = requests.get(
"https://ocr.captchaai.com/res.php",
params={
"key": self.api_key,
"action": "getbalance",
"json": 1,
},
timeout=10,
)
data = resp.json()
if data.get("status") == 1:
self._cached_balance = float(data["request"])
self._last_balance_check = time.time()
if self._cached_balance < self.min_balance:
logger.warning(
f"Low balance: ${self._cached_balance:.4f} "
f"(threshold: ${self.min_balance:.2f})"
)
except Exception as e:
logger.debug(f"Balance check failed: {e}")
def _submit_and_poll(self, params):
"""Submit task and poll for result."""
data = {"key": self.api_key, "json": 1, **params}
resp = requests.post(
"https://ocr.captchaai.com/in.php", data=data, timeout=30,
)
result = resp.json()
if result.get("status") != 1:
error = result.get("request", "")
if error == "ERROR_ZERO_BALANCE":
raise ZeroBalanceError("Account balance is zero")
raise RuntimeError(f"Submit failed: {error}")
task_id = result["request"]
time.sleep(10)
for _ in range(24):
resp = requests.get(
"https://ocr.captchaai.com/res.php",
params={
"key": self.api_key, "action": "get",
"id": task_id, "json": 1,
},
timeout=15,
)
data = resp.json()
if data.get("status") == 1:
return data["request"]
if data["request"] != "CAPCHA_NOT_READY":
raise RuntimeError(data["request"])
time.sleep(5)
raise TimeoutError("Solve timeout")
class ZeroBalanceError(Exception):
"""Raised when account has no balance."""
pass
class InsufficientBalanceError(Exception):
"""Raised when balance is below minimum threshold."""
pass
Monitoramento de saldo com alertas
import smtplib
from email.message import EmailMessage
import threading
import time
import logging
logger = logging.getLogger(__name__)
class BalanceMonitor:
"""Monitor balance and send alerts when low."""
def __init__(self, api_key, alert_threshold=1.00, check_interval=600):
self.api_key = api_key
self.alert_threshold = alert_threshold
self.check_interval = check_interval
self._alert_sent = False
self._running = False
def start(self):
"""Start background monitoring."""
self._running = True
thread = threading.Thread(target=self._monitor_loop, daemon=True)
thread.start()
logger.info("Balance monitor started")
def stop(self):
"""Stop monitoring."""
self._running = False
def _monitor_loop(self):
"""Check balance periodically."""
while self._running:
try:
balance = self._get_balance()
logger.info(f"Balance: ${balance:.4f}")
if balance <= 0:
self._send_alert("CRITICAL: CaptchaAI Zero Balance",
f"Balance is ${balance:.4f}. Solving will fail.")
elif balance < self.alert_threshold and not self._alert_sent:
self._send_alert("WARNING: CaptchaAI Low Balance",
f"Balance: ${balance:.4f} (threshold: ${self.alert_threshold:.2f})")
self._alert_sent = True
elif balance >= self.alert_threshold:
self._alert_sent = False # Reset alert flag
except Exception as e:
logger.error(f"Monitor error: {e}")
time.sleep(self.check_interval)
def _get_balance(self):
"""Check account balance."""
resp = requests.get(
"https://ocr.captchaai.com/res.php",
params={"key": self.api_key, "action": "getbalance", "json": 1},
timeout=10,
)
data = resp.json()
if data.get("status") == 1:
return float(data["request"])
raise RuntimeError(data.get("request"))
def _send_alert(self, subject, body):
"""Send email alert. Replace with your notification method."""
logger.critical(f"{subject}: {body}")
# Implement email, Slack webhook, or other notification here
# Usage
monitor = BalanceMonitor("YOUR_API_KEY", alert_threshold=2.00)
monitor.start()
Estime os custos antes de executar
# Approximate costs per CAPTCHA type
COST_PER_SOLVE = {
"recaptcha_v2": 0.003,
"recaptcha_v3": 0.004,
"turnstile": 0.002,
"geetest": 0.003,
"image": 0.001,
"bls": 0.002,
}
def estimate_cost(captcha_type, quantity):
"""Estimate cost for a batch of solves."""
rate = COST_PER_SOLVE.get(captcha_type, 0.003)
total = rate * quantity
return total
def check_budget(api_key, captcha_type, planned_solves):
"""Check if balance covers planned solves."""
balance = check_balance(api_key)
estimated = estimate_cost(captcha_type, planned_solves)
if balance >= estimated:
print(f"Budget OK: ${balance:.4f} covers ~{int(balance / COST_PER_SOLVE[captcha_type])} solves")
return True
else:
shortfall = estimated - balance
print(f"Need ${shortfall:.4f} more for {planned_solves} {captcha_type} solves")
return False
# Check before a large batch
check_budget("YOUR_API_KEY", "recaptcha_v2", 5000)
Padrão de degradação elegante
class GracefulSolver:
"""Fall back to manual or skip when balance is zero."""
def __init__(self, api_key, on_zero_balance="skip"):
self.api_key = api_key
self.on_zero_balance = on_zero_balance # "skip", "queue", "raise"
self._pending_queue = []
self.solver = BalanceAwareSolver(api_key)
def solve_or_degrade(self, params, item_id=None):
"""Try to solve, degrade gracefully on zero balance."""
try:
return self.solver.solve(params)
except (ZeroBalanceError, InsufficientBalanceError):
return self._handle_zero(params, item_id)
def _handle_zero(self, params, item_id):
"""Handle zero balance based on configured strategy."""
if self.on_zero_balance == "skip":
logger.warning(f"Skipping CAPTCHA for item {item_id} — no balance")
return None
elif self.on_zero_balance == "queue":
self._pending_queue.append({"params": params, "item_id": item_id})
logger.info(f"Queued item {item_id} — {len(self._pending_queue)} pending")
return None
else: # "raise"
raise ZeroBalanceError("No balance — stopping automation")
def retry_pending(self):
"""Retry queued items after balance is refilled."""
if not self._pending_queue:
return []
results = []
remaining = []
for item in self._pending_queue:
try:
token = self.solver.solve(item["params"])
results.append({"item_id": item["item_id"], "token": token})
except (ZeroBalanceError, InsufficientBalanceError):
remaining.append(item)
break # Stop retrying — still no balance
self._pending_queue = remaining + self._pending_queue[len(results) + len(remaining):]
return results
Solução de problemas
| Sintoma | Causa | Correção |
|---|---|---|
| ERROR_ZERO_BALANCE em cada solicitação | Conta vazia | Adicione fundos em captchaai.com |
| O equilíbrio cai inesperadamente rápido | Chave de API exposta ou código ineficiente | Gire a chave, verifique os registros de uso |
| Saldo mostra positivo mas erro persiste | Atraso de armazenamento em cache/sync | Aguarde 1 minuto, tente novamente |
| Não é possível adicionar fundos | Problema na forma de pagamento | Atualizar forma de pagamento no painel |
Perguntas frequentes
Com que rapidez os fundos aparecem após o pagamento?
A maioria dos métodos de pagamento credita instantaneamente. As transferências bancárias podem levar de 1 a 2 dias úteis.
Posso configurar o reabastecimento automático?
Verifique o painel CaptchaAI para opções de recarga automática. Você também pode criar seu próprio monitoramento com a API de saldo e alertas de pagamento.
CaptchaAI cobra por soluções malsucedidas?
Não. Você só será cobrado por soluções bem-sucedidas que retornem um token ou uma resposta.
Guias Relacionados
Mantenha seu saldo atualizado -deposite em sua conta em CaptchaAI.
