Casos de Uso

Automação de portais governamentais com solução CAPTCHA

Automação Python reCAPTCHA v2 Testes BLS CAPTCHA Image OCR
Por Equipe CaptchaAI Brasil
Publicado em Jun 09, 2026
Automação de portais governamentais com solução CAPTCHA
Imagem em destaque indisponível

Os sites governamentais usam CAPTCHAs para proteger formulários, sistemas de agendamento de consultas e portais de registros públicos. Equipes de controle de qualidade, desenvolvedores de tecnologia cívica e profissionais jurídicos precisam de acesso automatizado para testar e operar esses fluxos de trabalho com eficiência.

CAPTCHAs governamentais por categoria

Categoria do portal CAPTCHA comum Sites de exemplo Caso de uso
Visto / imigração BLS, reCAPTCHA v2 Portais BLS, USCIS Marcação de consulta
DMV/veículos motorizados reCAPTCHA v2, imagem Sites estaduais do DMV Renovação de registro
Registros judiciais reCAPTCHA v2 PACER, tribunais estaduais Pesquisa de caso
Autorizações/licenças Imagem CAPTCHA Portais de licenças municipais Arquivamento de aplicativos
Portais fiscais reCAPTCHA v2 IRS, sites fiscais estaduais Arquivando verificações de status
Registros públicos Imagem CAPTCHA, reCAPTCHA Registros do condado Pesquisa de propriedade/deed

Automação de agendamento de visto BLS

Os portais BLS utilizam seu próprio sistema CAPTCHA. CaptchaAI suporta BLS CAPTCHAs com 100% de precisão:

import requests
import time
import base64

CAPTCHAAI_KEY = "YOUR_API_KEY"
CAPTCHAAI_URL = "https://ocr.captchaai.com"


def solve_bls_captcha(captcha_image_url, session):
    """Solve BLS-specific CAPTCHA."""
    # Download CAPTCHA image
    img_resp = session.get(captcha_image_url)
    img_b64 = base64.b64encode(img_resp.content).decode()

    resp = requests.post(f"{CAPTCHAAI_URL}/in.php", data={
        "key": CAPTCHAAI_KEY,
        "method": "base64",
        "body": img_b64,
        "json": 1,
    })
    task_id = resp.json()["request"]

    for _ in range(30):
        time.sleep(3)
        result = requests.get(f"{CAPTCHAAI_URL}/res.php", params={
            "key": CAPTCHAAI_KEY, "action": "get",
            "id": task_id, "json": 1,
        })
        data = result.json()
        if data["request"] != "CAPCHA_NOT_READY":
            return data["request"]

    raise TimeoutError("BLS CAPTCHA timeout")


class BLSAppointmentBooker:
    def __init__(self):
        self.session = requests.Session()
        self.session.headers.update({
            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
            "AppleWebKit/537.36 Chrome/126.0.0.0 Safari/537.36",
        })

    def login(self, portal_url, email, password):
        """Login to BLS portal with CAPTCHA."""
        resp = self.session.get(portal_url)

        # Extract CAPTCHA image URL from page
        import re
        match = re.search(r'src="(/captcha[^"]+)"', resp.text)
        if match:
            captcha_url = portal_url.rstrip("/") + match.group(1)
            captcha_text = solve_bls_captcha(captcha_url, self.session)
        else:
            captcha_text = ""

        login_resp = self.session.post(portal_url, data={
            "email": email,
            "password": password,
            "captcha": captcha_text,
        })
        return login_resp.status_code == 200

    def check_appointment_slots(self, slots_url):
        """Check available appointment slots."""
        resp = self.session.get(slots_url)
        if resp.status_code == 200:
            return resp.json().get("available_slots", [])
        return []

    def book_slot(self, booking_url, slot_id, applicant_data):
        """Book an appointment slot, handling any CAPTCHA."""
        resp = self.session.get(booking_url)

        # Check for CAPTCHA on booking page
        import re
        match = re.search(r'src="(/captcha[^"]+)"', resp.text)
        if match:
            captcha_url = booking_url.rstrip("/") + match.group(1)
            captcha_text = solve_bls_captcha(captcha_url, self.session)
        else:
            captcha_text = ""

        resp = self.session.post(booking_url, data={
            "slot_id": slot_id,
            "captcha": captcha_text,
            **applicant_data,
        })

        return {
            "success": resp.status_code == 200,
            "confirmation": resp.json().get("confirmation_number"),
        }

Pesquisa de registros judiciais

def solve_recaptcha(sitekey, pageurl):
    resp = requests.post(f"{CAPTCHAAI_URL}/in.php", data={
        "key": CAPTCHAAI_KEY,
        "method": "userrecaptcha",
        "googlekey": sitekey,
        "pageurl": pageurl,
        "json": 1,
    })
    task_id = resp.json()["request"]

    for _ in range(60):
        time.sleep(5)
        result = requests.get(f"{CAPTCHAAI_URL}/res.php", params={
            "key": CAPTCHAAI_KEY, "action": "get",
            "id": task_id, "json": 1,
        })
        data = result.json()
        if data["request"] != "CAPCHA_NOT_READY":
            return data["request"]
    raise TimeoutError("Timeout")


class CourtRecordSearcher:
    def __init__(self, proxy=None):
        self.session = requests.Session()
        if proxy:
            self.session.proxies = {"http": proxy, "https": proxy}
        self.session.headers.update({
            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
            "AppleWebKit/537.36 Chrome/126.0.0.0 Safari/537.36",
        })

    def search_cases(self, court_url, search_params, sitekey):
        """Search court records with reCAPTCHA handling."""
        # Load search page
        self.session.get(court_url)

        # Solve CAPTCHA
        token = solve_recaptcha(sitekey, court_url)

        # Submit search with token
        resp = self.session.post(court_url, data={
            **search_params,
            "g-recaptcha-response": token,
        })

        if resp.status_code == 200:
            return self._parse_results(resp.text)
        return []

    def _parse_results(self, html):
        from bs4 import BeautifulSoup
        soup = BeautifulSoup(html, "html.parser")
        cases = []
        for row in soup.select("table.results tr")[1:]:
            cols = row.select("td")
            if len(cols) >= 4:
                cases.append({
                    "case_number": cols[0].get_text(strip=True),
                    "parties": cols[1].get_text(strip=True),
                    "date": cols[2].get_text(strip=True),
                    "status": cols[3].get_text(strip=True),
                })
        return cases

Imagem CAPTCHA em portais de permissão

Muitos portais de cidades e condados usam CAPTCHAs de imagem simples:

def solve_image_captcha(image_url, session):
    """Solve image-based CAPTCHA common on local government sites."""
    img = session.get(image_url)
    img_b64 = base64.b64encode(img.content).decode()

    resp = requests.post(f"{CAPTCHAAI_URL}/in.php", data={
        "key": CAPTCHAAI_KEY,
        "method": "base64",
        "body": img_b64,
        "json": 1,
    })
    task_id = resp.json()["request"]

    for _ in range(20):
        time.sleep(3)
        result = requests.get(f"{CAPTCHAAI_URL}/res.php", params={
            "key": CAPTCHAAI_KEY, "action": "get",
            "id": task_id, "json": 1,
        })
        data = result.json()
        if data["request"] != "CAPCHA_NOT_READY":
            return data["request"]

    raise TimeoutError("Image CAPTCHA timeout")

Pesquisa em lote de registros públicos

import csv


def batch_property_lookup(addresses, portal_url, sitekey, output_file):
    """Look up multiple property records, solving CAPTCHA per batch."""
    session = requests.Session()
    session.headers.update({
        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
        "AppleWebKit/537.36 Chrome/126.0.0.0 Safari/537.36",
    })

    results = []
    for i, address in enumerate(addresses):
        try:
            # Solve CAPTCHA every 5th request (or when required)
            if i % 5 == 0:
                token = solve_recaptcha(sitekey, portal_url)

            resp = session.post(portal_url, data={
                "address": address,
                "g-recaptcha-response": token,
            })

            if resp.status_code == 200:
                results.append({
                    "address": address,
                    "data": resp.json(),
                })

            time.sleep(3)  # Be respectful

        except Exception as e:
            results.append({"address": address, "error": str(e)})

    # Save results
    with open(output_file, "w", newline="") as f:
        writer = csv.DictWriter(f, fieldnames=["address", "data", "error"])
        writer.writeheader()
        writer.writerows(results)

    return results

Dicas de gerenciamento de sessão

Os portais governamentais costumam ter tempos limite de sessão curtos:

Tipo de portal Tempo limite da sessão Recomendação
Portais de vistos 5-10 minutos Conclua o fluxo rapidamente
Sites do DMV 15 minutos Atualizar cookie de sessão no meio do caminho
Registros judiciais 20-30 minutos Pesquisas em lote em grupos
Portais fiscais 10-15 minutos Use egress persistente autorizado, mesmo IP
Permitir aplicativos 30 minutos Salve o progresso em cada etapa

Solução de problemas

Problema Causa Correção
Imagem CAPTCHA não carrega Cookie de sessão expirou Iniciar nova sessão
"Sessão expirada" durante o formulário Demorou muito para resolver Pré-resolva ou use uma solução com menor latência
Resposta CAPTCHA errada Imagem distorcida Denunciar imagem ruim via API
Automação de blocos de portal Detecção IP/UA Use egress de rede autorizado + UA real
Erro de validação de formulário após CAPTCHA O token do lado do servidor expirou Resolva o CAPTCHA imediatamente antes de enviar

Perguntas frequentes

Geralmente é permitido automatizar seus próprios formulários e pesquisa de dados. O teste de controle de qualidade para aplicativos de tecnologia cívica é um uso legítimo comum. Verifique sempre os termos de serviço específicos do portal.

Qual tipo de CAPTCHA é mais comum em sites governamentais?

Imagem CAPTCHAs e reCAPTCHA v2. Os sites governamentais muitas vezes ficam para trás na tecnologia CAPTCHA, tornando-os mais simples de resolver.

CaptchaAI pode resolver BLS CAPTCHAs?

Sim — CaptchaAI suporta BLS CAPTCHAs com taxa de precisão de 100% usando o parâmetro method=bls para resolução direta ou method=base64 para resolução baseada em imagem.

Como lidar com formulários governamentais de várias etapas?

Use sessões de proxy fixas para manter o mesmo IP em todo o formulário. Os portais governamentais frequentemente validam a consistência de IP entre as páginas do formulário.

Guias Relacionados

Próximos passos

Os comentários estão desativados para este artigo.