Impacto da resolução DNS no desempenho da API CAPTCHA

A primeira chamada da sua integração com a API CAPTCHA costuma ser a mais lenta — e raramente é culpa do solver. Antes da requisição chegar a ocr.captchaai.com, seu código pode precisar resolver o DNS do host, o que soma de 5 a 200 ms conforme o provedor, o cache e a rede. Esse atraso não aparece nos logs da aplicação, mas entra direto no tempo total de resolução.

Diagnóstico rápido: sintomas, causas e comportamento por ambiente

Antes de otimizar qualquer coisa, confirme que o problema é mesmo DNS:

1. Só a primeira chamada é lenta, as demais são rápidas — cache do sistema operacional; ative keep-alive.
2. Todas as chamadas são lentas (100 ms+ cada) — sem cache de DNS ou resolvedor lento; configure 1.1.1.1 ou 8.8.8.8.
3. Picos de latência aleatórios — o TTL do cache está expirando; aumente o TTL local ou pré-resolva.
4. Cold start de container lento — instância nova sem cache; pré-resolva na inicialização.

Por ambiente de execução:

Quanto o DNS custa em cada chamada da API CAPTCHA

Uma solução de CAPTCHA típica gera de 5 a 7 requisições HTTP (1 envio + 4 a 6 consultas de status). Sem cache de DNS, cada chamada pode pagar o preço de uma nova consulta:

Ponto-chave: com HTTP keep-alive (conexões persistentes), o DNS deixa de ser problema seu — a mesma conexão TCP reaproveita o IP já resolvido. Ele importa quando cada requisição abre uma conexão nova.

Quando o DNS vira gargalo de verdade

A resolução de DNS se torna um gargalo real quando:

• Uma conexão nova por requisição — sem Session (Python) ou agente keep-alive (Node.js)
• Cold start de contêiner ou função serverless — instâncias novas não têm nada em cache
• Provedor de DNS lento — DNS padrão do provedor, sem cache local
• Solução paralela em alto volume — muitos workers subindo ao mesmo tempo

Exemplo prático: uma equipe rodando workers de scraping em contêineres na região sa-east-1 (São Paulo) da AWS viu a primeira chamada de cada contêiner novo perder 150–180 ms com DNS. Com muitos cold starts por hora, isso soma minutos de latência por dia — resolvido pré-resolvendo o host no init do handler.

Otimizando DNS em Python

Comece medindo o comportamento atual do DNS na sua stack:

import socket
import time

# Measure DNS resolution time
hostname = "ocr.captchaai.com"

start = time.time()
ip = socket.getaddrinfo(hostname, 443)
first_resolve = time.time() - start

start = time.time()
ip = socket.getaddrinfo(hostname, 443)
second_resolve = time.time() - start

print(f"First resolve: {first_resolve*1000:.1f}ms")
print(f"Second resolve: {second_resolve*1000:.1f}ms (OS cached)")

Em seguida, pré-resolva o host e mantenha a conexão viva com uma sessão persistente:

import os
import socket
import requests
from urllib3.util.connection import create_connection

API_KEY = os.environ.get("CAPTCHAAI_KEY", "YOUR_API_KEY")

# Pre-resolve the API hostname
CAPTCHAAI_IP = socket.getaddrinfo("ocr.captchaai.com", 443)[0][4][0]
print(f"Resolved ocr.captchaai.com to {CAPTCHAAI_IP}")

# Patch connection to use cached IP
DNS_CACHE = {"ocr.captchaai.com": CAPTCHAAI_IP}

class CachedHTTPAdapter(requests.adapters.HTTPAdapter):
    def send(self, request, **kwargs):
        return super().send(request, **kwargs)

# Use with Session for fastest resolution
session = requests.Session()
session.headers.update({"Connection": "keep-alive"})

# The session already maintains keep-alive, so DNS is resolved once
# For the first request, the OS cache handles subsequent lookups
resp = session.get("https://ocr.captchaai.com/res.php", params={
    "key": API_KEY, "action": "getbalance", "json": "1",
})
print(f"Balance: {resp.json()}")

Se você controla a configuração de DNS do ambiente, use também um resolvedor público de menor latência:

# For systems where you control DNS configuration:
# /etc/resolv.conf (Linux) or system DNS settings
# Recommended: Cloudflare (1.1.1.1) or Google (8.8.8.8)

# In Python, you can also use dnspython for explicit resolution
import dns.resolver

resolver = dns.resolver.Resolver()
resolver.nameservers = ["1.1.1.1", "8.8.8.8"]

answers = resolver.resolve("ocr.captchaai.com", "A")
for answer in answers:
    print(f"Resolved: {answer}")

Otimizando DNS em JavaScript e Node.js

No Node.js, o primeiro passo é o mesmo: medir antes de otimizar.

const dns = require('dns');
const { performance } = require('perf_hooks');

const hostname = 'ocr.captchaai.com';

// First resolution
const start1 = performance.now();
dns.lookup(hostname, (err, address) => {
  const time1 = performance.now() - start1;
  console.log(`First resolve: ${time1.toFixed(1)}ms → ${address}`);

  // Second resolution (OS cached)
  const start2 = performance.now();
  dns.lookup(hostname, (err2, address2) => {
    const time2 = performance.now() - start2;
    console.log(`Second resolve: ${time2.toFixed(1)}ms → ${address2}`);
  });
});

Depois, combine pré-resolução com um agente HTTP keep-alive para eliminar novas consultas:

const dns = require('dns');
const https = require('https');
const axios = require('axios');

const API_KEY = process.env.CAPTCHAAI_KEY || 'YOUR_API_KEY';

// Pre-resolve and cache
let cachedIP = null;

async function preResolve() {
  return new Promise((resolve, reject) => {
    dns.lookup('ocr.captchaai.com', (err, address) => {
      if (err) reject(err);
      cachedIP = address;
      console.log(`Cached IP: ${cachedIP}`);
      resolve(address);
    });
  });
}

// Use keep-alive agent (DNS resolved once per connection)
const agent = new https.Agent({
  keepAlive: true,
  maxSockets: 20,
  keepAliveMsecs: 60000,
});

const api = axios.create({
  baseURL: 'https://ocr.captchaai.com',
  httpsAgent: agent,
  timeout: 30000,
});

(async () => {
  await preResolve();
  const resp = await api.get('/res.php', {
    params: { key: API_KEY, action: 'getbalance', json: '1' },
  });
  console.log(`Balance: ${resp.data}`);
})();

Perguntas frequentes

DNS lento derruba a taxa de sucesso do CAPTCHA?

Não diretamente. O DNS afeta o tempo até a requisição sair do seu servidor, não a forma como o CAPTCHA é resolvido do outro lado. Uma resolução lenta pode disparar um timeout no seu código — parece falha de resolução, mas é latência de rede.

Preciso configurar algo na CaptchaAI para reduzir a latência de DNS?

Não. O DNS é resolvido do seu lado, antes da requisição sair do servidor. Cache, keep-alive e pré-resolução são ajustes no seu código — sem configuração extra na conta CaptchaAI.

Qual resolvedor de DNS público tem a menor latência para quem opera no Brasil?

Cloudflare (1.1.1.1) e Google (8.8.8.8) têm pontos de presença no Brasil e resolvem em menos de 10 ms nas principais regiões. Meça no seu ambiente antes de trocar o resolvedor — a latência varia por operadora.

Cold start em Lambda ou Cloud Functions aumenta mesmo a latência de DNS?

Sim. Uma instância recém-criada não tem nada em cache, e a primeira chamada paga o custo total da consulta. Pré-resolver o host no init do handler remove esse custo das chamadas seguintes.

Próximos passos

Pare de pagar uma latência de DNS que não precisa pagar — obtenha sua chave de API da CaptchaAI e meça o antes e depois no seu próprio pipeline.

Guias relacionados:

• Conexão keep-alive e HTTP/2
• Comparativo de tempos de resolução
• Guia de otimização de latência