Cómo automatizar el login en gov.br(y por qué todos los scrapers fallan antes que tú)
gov.br usa hCaptcha, fingerprinting de navegador y bloqueo de IP. Playwright, Selenium y Puppeteer fallan silenciosamente. Este tutorial muestra cómo resolver todo esto con Abrasio y obtener una sesión autenticada — lista para consultas de vehículos, extracción de documentos y llenado de formularios.
El problema que nadie habla abiertamente
Cada semana, algún desarrollador o analista de datos intenta automatizar algo en gov.br y choca con la misma pared invisible. No aparece un aviso claro. No hay mensaje de error explicativo. Selenium simplemente se queda parado en la pantalla de login. Playwright abre la página, escribe el CPF y... nada pasa. El proceso se bloquea antes de que aparezca el hCaptcha.
El problema no es tu código. Es el detector de bots.
gov.br es el SSO (Single Sign-On) que protege más de 1.800 servicios públicos federales y estatales. Para acceder al DETRAN-MG, la Receita Federal, INSS, Meu INSS, el portal de la CNH, SINARM o cualquier sistema que use "Entrar con gov.br" — necesitas pasar por este login primero.
Y las razones para querer automatizar este acceso son completamente legítimas:
- Despachantes y oficinas de transporte que consultan la situación de decenas de vehículos por día
- Empresas de logística que necesitan verificar licencias y puntos de conductores
- Contabilidades que emiten GRU y DARF para múltiples clientes
- Bufetes de abogados que siguen procesos en PROJUDI y tribunales estatales
- Empresas de RRHH que validan información en eSocial
- Proveedores de servicios que emiten facturas en sistemas NFS-e de múltiples municipios
- Desarrolladores que crean herramientas internas para agilizar procesos burocráticos
En todos estos casos, el cuello de botella es el mismo: el login. Una vez autenticado, puedes navegar por cualquier servicio vinculado a gov.br. Pero llegar ahí con automatización convencional es casi imposible — y eso es exactamente lo que vamos a resolver aquí.
Lo que realmente protege gov.br
Antes de mostrar la solución, vale entender qué hay del otro lado. gov.br no usa solo un mecanismo de protección — usa al menos cuatro capas simultáneas:
hCaptcha
hCaptcha es un sistema de verificación similar a reCAPTCHA, pero con un enfoque más avanzado de detección de bots. Analiza el comportamiento del usuario y puede requerir interacciones visuales para confirmar que eres humano.
Fingerprinting de navegador
El Chrome lanzado por Playwright, Selenium o Puppeteer tiene una firma digital diferente a un Chrome real. navigator.webdriver está marcado como true, los strings de WebGL revelan que no hay GPU real, el canvas devuelve valores idénticos entre ejecuciones (sin ruido), y los plugins estándar del usuario están ausentes.
Análisis de IP y geolocalización
Las IPs de datacenters (AWS, GCP, Azure, DigitalOcean) se bloquean automáticamente. gov.br espera IPs residenciales brasileñas. Si intentas desde un servidor o fuera de Brasil, el sistema ya lo sabe antes de que escribas nada.
Análisis comportamental
Velocidad de escritura constante (delay=0 o delay fijo), ratón que va directamente al campo sin movimiento previo, ausencia de scroll, sesión nueva sin cookies anteriores — cualquiera de estos patrones levanta una señal.

Por qué Playwright, Selenium y Puppeteer fallan
Mira lo que pasa cuando usas automatización convencional:
# O que acontece com Playwright puro no gov.br:
from playwright.async_api import async_playwright
async with async_playwright() as p:
browser = await p.chromium.launch(headless=True)
page = await browser.new_page()
await page.goto("https://sso.acesso.gov.br/login")
# Resultado: bloqueio imediato
# O gov.br detecta:
# navigator.webdriver = true → identifica automação
# Headless Chrome fingerprint → sem plugins, sem GPU real
# IP de datacenter → não é IP residencial brasileiro
# Ausência de histórico → novo perfil sem cookies anteriores
# Velocidade de digitação → 0ms entre teclas (robótico)El navegador abre, la página carga, pero hCaptcha ya analizó el fingerprint y tomó la decisión. Sin respuesta visual, sin mensaje de error — el formulario simplemente no avanza.

El bloqueo no es permanente
La solución: Abrasio
Abrasio es un browser service construido específicamente para este tipo de escenario. Combina tres tecnologías para superar estas defensas:
Fingerprint-patched Chromium
Un Chromium modificado donde navigator.webdriver es eliminado, los strings de WebGL y Canvas reciben ruido realista, los headers HTTP son normalizados y los plugins estándar están presentes. La firma digital es de un Chrome real.
IPs residenciales brasileñas
Cada sesión usa una IP residencial en la región BR por defecto. gov.br ve una conexión normal de un ciudadano brasileño, no un servidor.
Simulación de comportamiento humano
Las funciones human_type(), human_wait(), human_scroll() y simulate_reading() replican los patrones de un usuario real: variación en el delay de teclas, movimiento de ratón con curvas de Bézier, pausas aleatorias entre acciones.



Tutorial
Necesitarás una API key de Abrasio. Crea la tuya gratis al final del artículo.
Instalación
Instala el SDK de Abrasio via pip:
pip install abrasioConfigura tu API key como variable de entorno. Puedes encontrarla en tu dashboard de Abrasio:
export ABRASIO_API_KEY=abr_live_sua_chave_aquiNunca pongas tu API key en el código
Login en gov.br
El flujo de login de gov.br tiene tres pasos: CPF → contraseña → código MFA (autenticador o SMS). El código a continuación encapsula este flujo en una función que devuelve las cookies de la sesión autenticada:
"""
Tutorial: Login automatizado no gov.br com Abrasio
Instalação:
pip install abrasio
Configuração:
export ABRASIO_API_KEY=abr_live_sua_chave_aqui
"""
import asyncio
import os
from abrasio import Abrasio
from abrasio.utils import human_type, human_wait
async def login_govbr(cpf: str, senha: str, otp_callback=None) -> list:
"""
Faz login no gov.br e retorna os cookies da sessão autenticada.
Args:
cpf: CPF do cidadão (apenas números)
senha: Senha do acesso gov.br
otp_callback: Função chamada para obter o código OTP.
Se None, solicita via input().
Returns:
Lista de cookies da sessão autenticada.
"""
api_key = os.getenv("ABRASIO_API_KEY")
if not api_key:
raise ValueError("Configure a variável de ambiente ABRASIO_API_KEY")
async with Abrasio(
api_key=api_key,
region="br", # IP brasileiro — obrigatório para o gov.br
device="desktop",
headless=False, # Use True em produção
humanize=True, # Simula comportamento humano (mouse, teclado)
) as browser:
page = await browser.new_page()
# 1. Navegar para o SSO do gov.br
await page.goto(
"https://sso.acesso.gov.br/login",
wait_until="domcontentloaded"
)
await page.wait_for_selector("#accountId")
# 2. Digitar CPF com timing humano (evita detecção por velocidade de digitação)
await human_type(page, cpf, "#accountId")
await page.locator("#enter-account-id").click()
# 3. Aguardar o campo de senha aparecer e digitar
await human_wait(2, 4)
await page.locator("#password").wait_for(state="visible")
await page.keyboard.type(senha, delay=100)
await page.locator("#submit-button").click()
# 4. Fechar o popup de aviso e inserir código OTP/MFA
await page.wait_for_selector(".gdd-close-btn")
await page.locator(".gdd-close-btn").click()
await page.locator("#otpInput").wait_for(state="visible")
# Obter código OTP (via callback ou input interativo)
if otp_callback:
codigo = await otp_callback()
else:
codigo = input("Digite o código MFA do gov.br: ")
await page.keyboard.type(codigo, delay=100)
await page.locator("#enter-offline-2fa-code").click()
# 5. Sessão autenticada — capturar e retornar cookies
cookies = await page.context.cookies()
print(f"✓ Login realizado com sucesso. {len(cookies)} cookies capturados.")
await page.screenshot(path="govbr_sessao.png", full_page=True)
return cookies
if __name__ == "__main__":
import asyncio
async def main():
cookies = await login_govbr(
cpf=input("CPF (apenas números): "),
senha=input("Senha: "),
)
print(f"\nCookies da sessão: {len(cookies)}")
for c in cookies:
print(f" {c['name']}: {c['value'][:30]}...")
asyncio.run(main())Lo que tienes ahora
Ejemplo real: consulta de situación de vehículo
Con la sesión autenticada, mira cómo hacer una consulta de situación de vehículo en el portal ciudadano de Minas Gerais. El mismo patrón se aplica a cualquier otro servicio que use "Entrar con gov.br":
"""
Exemplo: Consulta de situação de veículo no Detran-MG
usando a sessão gov.br já autenticada.
"""
import asyncio
import os
from abrasio import Abrasio
from abrasio.utils import human_wait, human_scroll, human_click, simulate_reading
async def consultar_veiculo(placa: str, chassi: str) -> dict:
"""
Consulta a situação de um veículo no portal cidadão do MG.
Requer autenticação via gov.br (SSO).
Returns:
Dicionário com os dados do veículo retornados pela API do Detran.
"""
api_key = os.getenv("ABRASIO_API_KEY")
async with Abrasio(
api_key=api_key,
region="br",
device="desktop",
headless=False,
humanize=True,
) as browser:
page = await browser.new_page()
# Navegar para o portal cidadão — o gov.br SSO já está em sessão
await page.goto(
"https://cidadao.mg.gov.br/#/login",
wait_until="domcontentloaded"
)
await human_wait(5, 7)
# Aceitar cookies do portal
await page.locator(
"p-button:nth-child(2) > button"
).click()
# Clicar em "Entrar com gov.br"
await page.locator(".govBrBtn").wait_for(state="visible")
await page.locator(".govBrBtn").click()
# Navegar até "Veículos e Condutores (Trânsito)"
await page.wait_for_selector(
"//*[contains(text(), 'Veículos e Condutores (Trânsito)')]"
)
await page.locator(
"//*[contains(text(), 'Veículos e Condutores (Trânsito)')]"
).click()
await human_wait(2, 3)
await simulate_reading(page, 5, 10)
await human_scroll(page, 0, 2000)
# Clicar em "Situação do Veículo"
await human_click(page, "//*[contains(text(), 'Situação do Veículo')]")
await simulate_reading(page, 2, 4)
# Preencher placa e chassi com comportamento humano
await human_click(page, "#placa")
await human_wait(1, 2)
from abrasio.utils import human_type
await human_type(page, placa, "#placa")
await human_type(page, chassi, "#chassi")
# Interceptar a resposta da API antes de clicar em consultar
async with page.expect_response(
lambda r: "veiculos/situacao" in r.url,
timeout=90000
) as response_info:
await simulate_reading(page, 7, 15)
await page.locator("button[type='submit']").click()
response = await response_info.value
dados = await response.json()
if dados.get("mensagem") == "Acesso Negado":
raise PermissionError("Sessão expirada ou acesso negado pelo portal.")
return dados
if __name__ == "__main__":
async def main():
resultado = await consultar_veiculo(
placa="ABC1234",
chassi="9BWXX00X0XX000000",
)
import json
print(json.dumps(resultado, indent=2, ensure_ascii=False))
asyncio.run(main())Sobre el MFA
Lo que puedes construir con esto
La sesión autenticada en gov.br es la clave para una serie de automatizaciones que antes eran imposibles o requerían intervención manual constante:
Consulta en lote de vehículos
Pasa una lista de matrículas y chasis y obtén el estado de cada uno automáticamente. Ideal para despachantes y transportistas.
Verificación de licencia
Consulta puntuación, vigencia y categoría de conductores via DETRAN online. Útil para empresas de logística y flotas.
Emisión de GRU/DARF
Automatiza la generación de guías de pago federal para múltiples clientes, integrando con sistemas contables.
Extracción de certificados
Descarga Certificados Negativos de Deudas, comprobantes del INSS y otros documentos automáticamente, sin intervención humana.
Seguimiento de procesos
Monitorea avances procesales en tribunales y sistemas jurídicos estatales que usan gov.br como autenticación.
Integración con ERPs
Alimenta sistemas internos con datos gubernamentales en tiempo real, eliminando el trabajo manual de consulta y digitación.
Comienza ahora con Abrasio
Crea tu API key gratis y ejecuta el código de este tutorial en menos de 5 minutos.