Como automatizar o login no gov.br(e por que todo scraper falha antes de você)

pip install abrasio

export ABRASIO_API_KEY=sk_live_sua_chave_aqui

"""
Tutorial: Login automatizado no gov.br com Abrasio

Instalação:
    pip install abrasio

Configuração:
    export ABRASIO_API_KEY=sk_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())

"""
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())