Entenda, primeiramente, a diferença entre polling e webhooks; além disso, veja a arquitetura de referência e, consequentemente, configure alertas automáticos para qualquer movimentação processual.
Imagine que você está esperando uma encomenda importante. Você tem duas opções: ligar para a transportadora a cada hora perguntando “chegou?”, ou simplesmente pedir para eles te enviarem uma mensagem quando a entrega for feita.
A primeira opção é o polling. A segunda é o webhook. E essa diferença, que parece simples, tem um impacto enorme na eficiência de sistemas de monitoramento processual — especialmente quando integrados a uma plataforma como a Judit.
Polling: o jeito ineficiente de monitorar
No modelo de polling, o seu sistema fica perguntando para a API periodicamente: “Esse processo teve alguma atualização?” — a cada 5 minutos, a cada hora, a cada dia. Na maior parte dessas consultas, a resposta será “não”. Você está consumindo recursos, pagando por requisições e introduzindo latência sem nenhum motivo.
- Seu sistema consulta a API repetidamente
- 90% das consultas retornam “sem novidades”
- Consome cota de API desnecessariamente
- Latência mínima = intervalo entre consultas
- Escala mal: 1.000 processos = 1.000 chamadas/ciclo
- Infraestrutura ociosa na maior parte do tempo
- A API empurra dados quando algo muda
- 100% das notificações são relevantes
- Zero consumo de cota sem motivo
- Latência mínima = segundos após o evento
- Escala perfeitamente: 10.000 processos, mesmo esforço
- Infraestrutura só ativa quando há dados novos
A Judit é a única API jurídica brasileira que oferece webhooks nativos para monitoramento processual. Isso significa que você pode monitorar dezenas de milhares de processos sem uma única requisição de polling — a API simplesmente te avisa quando algo acontece. Conheça os planos disponíveis para encontrar o que melhor se encaixa no seu volume de monitoramento.
Como funcionam os webhooks na Judit
O fluxo é simples: você cadastra um endereço (URL) no seu sistema que a Judit possa “chamar” quando houver uma atualização. Quando um processo monitorado tem uma nova movimentação — uma decisão, um andamento, uma sentença — a Judit faz uma requisição POST para a sua URL com os dados da atualização. Todos os detalhes técnicos estão disponíveis na documentação oficial.
Passo 1 — Configurando o monitoramento via API
Para iniciar o monitoramento de um CPF, CNPJ ou processo, você usa o endpoint de tracking da Judit. Consulte a documentação para ver todos os parâmetros disponíveis:
import requests import os API_KEY = os.getenv("JUDIT_API_KEY") TRACKING_ENDPOINT = "https://tracking.prod.judit.io/tracking" def iniciar_monitoramento(cpf_cnpj: str, webhook_url: str) -> dict: """Cadastra uma entidade para monitoramento contínuo.""" headers = { "Authorization": f"Bearer {API_KEY}", "Content-Type": "application/json" } payload = { "search_type": "cpf_cnpj", "search_key": cpf_cnpj, "webhook_url": webhook_url, # URL que receberá as notificações "notification_config": { "on_new_lawsuit": True, # Avisa em novos processos "on_movement": True, # Avisa em movimentações "on_decision": True # Avisa em decisões } } response = requests.post(TRACKING_ENDPOINT, headers=headers, json=payload) response.raise_for_status() return response.json() # Exemplo de uso: resultado = iniciar_monitoramento( cpf_cnpj="12345678000190", # CNPJ da empresa monitorada webhook_url="https://meusite.com/webhook/judit" ) print(f"Monitoramento ativado! ID: {resultado['tracking_id']}")
Passo 2 — Criando o endpoint que recebe o webhook
Agora você precisa criar uma rota no seu servidor que receba as notificações da Judit. Aqui está um exemplo completo com Flask (Python) e Express (Node.js):
from flask import Flask, request, jsonify import logging app = Flask(__name__) logging.basicConfig(level=logging.INFO) @app.route("/webhook/judit", methods=["POST"]) def receber_webhook(): """Endpoint que recebe notificações da Judit.""" payload = request.get_json() if not payload: return jsonify({"error": "payload inválido"}), 400 # Identifica o tipo de evento event_type = payload.get("event_type") # "new_lawsuit" | "movement" | "decision" tracking_id = payload.get("tracking_id") entity = payload.get("search_key") # CPF ou CNPJ monitorado logging.info(f"Evento recebido: {event_type} | Entidade: {entity}") # Processa conforme o tipo de evento if event_type == "new_lawsuit": processar_novo_processo(payload) elif event_type == "movement": processar_movimentacao(payload) elif event_type == "decision": processar_decisao(payload) # IMPORTANTE: sempre retorne 200 rapidamente # Processe em background se necessário (fila, celery, etc.) return jsonify({"status": "ok"}), 200 def processar_novo_processo(payload): lawsuit = payload.get("lawsuit", {}) numero_cnj = lawsuit.get("cnj_number") assunto = lawsuit.get("subject") tribunal = lawsuit.get("court") logging.info(f"🚨 NOVO PROCESSO: {numero_cnj} | {assunto} | {tribunal}") # → Aqui você envia email, Slack, WhatsApp, salva no banco, etc. if __name__ == "__main__": app.run(port=5000)
Estrutura do payload que você vai receber
{
"event_type": "new_lawsuit",
"tracking_id": "track_xyz789",
"search_key": "12345678000190", // CNPJ monitorado
"timestamp": "2026-03-10T14:32:00Z",
"lawsuit": {
"cnj_number": "0001234-56.2026.8.26.0100",
"subject": "Cobrança",
"court": "TJSP",
"filing_date": "2026-03-10",
"value": 15000.00,
"parties": [
{ "role": "author", "name": "João Silva", "cpf": "111.222.333-44" },
{ "role": "defendant", "name": "Empresa XYZ LTDA", "cnpj": "12.345.678/0001-90" }
]
}
}Boas práticas para um endpoint de webhook robusto
| Prática | Por quê | Como implementar |
|---|---|---|
| Responda em menos de 5 segundos | A Judit pode considerar falha e reenviar se demorar | Processe em background (Celery, Bull, SQS) |
| Retorne sempre HTTP 200 | Indica que o payload foi recebido com sucesso | Salve na fila e responda antes de processar |
| Trate duplicatas | Reenvios podem ocorrer em caso de falha de rede | Use o tracking_id + timestamp como chave única |
| Proteja o endpoint | Evita que terceiros enviem dados falsos | Valide o IP de origem ou use um token secreto |
| Use HTTPS | Dados processuais são sensíveis | Certificado SSL obrigatório (Let’s Encrypt é gratuito) |
Casos de uso: o que fazer quando o webhook chegar
Uma vez que você recebe o payload da Judit, as possibilidades são infinitas. Os casos mais comuns são:
# 1. Enviar alerta no Slack def notificar_slack(payload): lawsuit = payload['lawsuit'] mensagem = f"""🚨 *Novo processo detectado* • Número: {lawsuit['cnj_number']} • Assunto: {lawsuit['subject']} • Tribunal: {lawsuit['court']} • Valor: R$ {lawsuit['value']:,.2f}""" requests.post(SLACK_WEBHOOK_URL, json={"text": mensagem}) # 2. Salvar no banco de dados def salvar_banco(payload): db.lawsuits.upsert( {"cnj_number": payload['lawsuit']['cnj_number']}, payload['lawsuit'] ) # 3. Atualizar planilha Google Sheets via API # 4. Enviar email para o responsável # 5. Acionar workflow no n8n, Make ou Zapier # 6. Criar tarefa no Asana / Jira para o time jurídico # 7. Enviar mensagem no WhatsApp via Zapi/Twilio
Se você não quer escrever código para o servidor de webhooks, use n8n, Make ou Zapier: configure um trigger “Webhook” nessas plataformas, use a URL gerada como destino no monitoramento da Judit, e conecte visualmente a qualquer destino — Slack, Gmail, Google Sheets, Notion, e muito mais. O próximo artigo desta série cobre esse fluxo em detalhes. Veja também os planos da Judit para entender os limites de notificação de cada tier.
Configure seu primeiro webhook agora
Crie uma conta na Judit, ative o monitoramento de um CNPJ e receba o primeiro alerta em tempo real.
