> ## Documentation Index
> Fetch the complete documentation index at: https://docs.judit.io/llms.txt
> Use this file to discover all available pages before exploring further.

# Consulta Síncrona ao Datalake (Hot Storage)

> Consulte instantaneamente o datalake da Judit (Hot Storage) por CPF, CNPJ, OAB ou Nome. Resposta síncrona em milissegundos com dados já indexados — ideal para validações e fluxos em tempo real.

export const EndpointBadges = ({auth = true, billing = "billable", flow = "sync", attachments = false, requiresVault = false}) => <div style={{
  marginTop: "-8px",
  marginBottom: "16px"
}}>
    {auth && <Badge color="gray">🔒 Requer api-key</Badge>}
    {billing === "billable" && <Badge color="yellow">💰 Cobrança por requisição</Badge>}
    {billing === "free" && <Badge color="green">✅ Grátis</Badge>}
    {billing === "on-demand" && <Badge color="purple">⚡ On-demand (preço diferenciado)</Badge>}
    {flow === "async" && <Badge color="blue">⏳ Assíncrono · webhook ou polling</Badge>}
    {flow === "sync" && <Badge color="green">⚡ Síncrono</Badge>}
    {attachments && <Badge color="purple">📎 Suporta with_attachments</Badge>}
    {requiresVault && <Badge color="red">🔑 Cofre de Credenciais</Badge>}
  </div>;

<Info>
  **Novo CNPJ (IN 2229/24)**

  A Judit já aceita o novo formato de **CNPJ alfanumérico** em conformidade com a [Instrução Normativa RFB nº 2229/2024](https://normasinternet2.receita.fazenda.gov.br/#/consulta/externa/141102).

  * **Zero esforço:** nenhuma alteração é necessária na sua integração.
  * **Ambiente de teste:** utilize o documento `A1B2C3D4/E5F6-68` para validar o fluxo e receber um processo fictício de resposta.
</Info>

A **Consulta Síncrona ao Hot Storage** retorna, em milissegundos, todos os processos do nosso datalake vinculados a um CPF, CNPJ, OAB, Nome ou CNJ. Não há fila nem espera por tribunal: a resposta vem direto do cache JUDIT.

> 🤖 Endpoint: `POST https://lawsuits.production.judit.io/lawsuits`. A resposta é síncrona (HTTP 200 com o JSON pronto). Esta rota não vai ao tribunal — ela lê o datalake da Judit, então pode haver um pequeno atraso em relação ao estado mais atual do processo. Se precisar de dados atualizados em tempo real, use [POST /requests](/requests/requests) (assíncrono).

<EndpointBadges auth billing="billable" flow="sync" />

## Síncrono vs. assíncrono — qual escolher?

| Característica | Síncrono (Hot Storage)                         | Assíncrono (Requests)                                 |
| -------------- | ---------------------------------------------- | ----------------------------------------------------- |
| **Latência**   | ms (resposta imediata)                         | segundos a minutos                                    |
| **Fonte**      | Datalake JUDIT (cache)                         | Tribunal em tempo real                                |
| **Atualidade** | Última coleta da JUDIT                         | Estado atual do tribunal                              |
| **Webhook**    | Não aplicável                                  | Sim, opcional                                         |
| **Custo**      | Mais barato                                    | Mais caro                                             |
| **Caso ideal** | Validação rápida, dashboards, busca interativa | Diligência, atualização forçada, consulta sob demanda |

## Quando usar

<CardGroup cols={2}>
  <Card title="Validação em tempo real" icon="bolt">
    Onboarding, KYC, autocomplete — sempre que precisar de uma resposta imediata para a UI.
  </Card>

  <Card title="Dashboards interativos" icon="chart-line">
    Dashboards e BI que listam processos vinculados a um cliente sem precisar atualizar o tribunal.
  </Card>

  <Card title="Pré-filtragem de risco" icon="filter">
    Antes de disparar uma consulta assíncrona cara, descubra rapidamente se vale a pena.
  </Card>

  <Card title="Estatísticas e contagens" icon="hashtag">
    Combine com [`/lawsuits/count`](/api-reference/endpoint/crawler/req-count) e [`/lawsuits/synthetic`](/cache-judit/cache-grouped) para análises agregadas.
  </Card>
</CardGroup>

<Warning>
  Todas as consultas síncronas aceitam **filtros** (tribunal, valor da causa, classes, partes, datas, fase). Veja a lista completa em [filtros da consulta histórica](/requests/request-document#payload-da-solicitação) — o mesmo objeto `search_params.filter` se aplica aqui.
</Warning>

## Passo 1: Criar a Consulta Síncrona (POST)

Para iniciar a consulta síncrona, faça uma requisição `POST` enviando o documento desejado.

`POST https://lawsuits.production.judit.io/lawsuits`

### Exemplos de consultas síncronas

<CodeGroup>
  ```json Consulta por CPF theme={null}
  {
      "search": {
          "search_type": "cpf",
          "search_key": "999.999.999-99"
      }
  }
  ```

  ```json Consulta por CNPJ theme={null}
  {
      "search": {
          "search_type": "cnpj",
          "search_key": "99.999.999/9999-99"
      }
  }
  ```

  ```json Consulta por OAB theme={null}
  {
      "search": {
          "search_type": "oab",
          "search_key": "99999RJ"
      }
  }
  ```

  ```json Consulta por Nome theme={null}
  {
      "search": {
          "search_type": "name",
          "search_key": "João Silva"
      }
  }
  ```
</CodeGroup>

<Warning>
  Ao realizar consultas por nome, é possível que existam homônimos. Sempre que possível, prefira CPF, CNPJ ou OAB para garantir maior precisão.
</Warning>

### Parâmetros do Payload

| Parâmetro                     | Tipo   | Obrigatório | Descrição                                                                                                                                                                              |
| :---------------------------- | :----- | :---------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `search.search_type`          | string | **Sim**     | Tipo da entidade buscada: `"cpf"`, `"cnpj"`, `"oab"` ou `"name"`.                                                                                                                      |
| `search.search_key`           | string | **Sim**     | O valor a ser buscado (ex.: `"999.999.999-99"`, `"João Silva"`).                                                                                                                       |
| `search.search_params.filter` | object | Não         | Filtros estruturais (tribunal, valor, classes, partes, datas). Mesma estrutura da [consulta histórica](/requests/request-document#filtros-prévios-da-requisição-search_params-filter). |

### Filtros mais comuns (`search_params.filter`)

A consulta síncrona aceita os mesmos filtros da consulta histórica. Veja exemplos práticos:

<CodeGroup>
  ```json Filtro por tribunal (TJRJ) theme={null}
  {
      "search": {
          "search_type": "cpf",
          "search_key": "999.999.999-99",
          "search_params": {
              "filter": {
                  "tribunals": { "keys": ["TJRJ"], "not_equal": false }
              }
          }
      }
  }
  ```

  ```json Filtro por polo passivo + valor theme={null}
  {
      "search": {
          "search_type": "cnpj",
          "search_key": "00.000.000/0001-00",
          "search_params": {
              "filter": {
                  "side": "Passive",
                  "amount_gte": 50000
              }
          }
      }
  }
  ```

  ```json Filtro por janela de distribuição theme={null}
  {
      "search": {
          "search_type": "cpf",
          "search_key": "999.999.999-99",
          "search_params": {
              "filter": {
                  "distribution_date_gte": "2024-01-01T00:00:00.000Z",
                  "distribution_date_lte": "2024-12-31T23:59:59.000Z"
              }
          }
      }
  }
  ```

  ```json Excluir tribunais theme={null}
  {
      "search": {
          "search_type": "cpf",
          "search_key": "999.999.999-99",
          "search_params": {
              "filter": {
                  "tribunals": { "keys": ["TJSP"], "not_equal": true }
              }
          }
      }
  }
  ```
</CodeGroup>

> Lista completa de tribunais aceitos: veja [Filtros da consulta histórica](/requests/request-document#lista-de-tribunais-aceitos-filtros).

### Exemplo de Requisição (POST)

<CodeGroup>
  ```bash cURL (CPF) theme={null}
  curl --request POST \
    --url 'https://lawsuits.production.judit.io/lawsuits' \
    --header 'Content-Type: application/json' \
    --header 'api-key: '"$JUDIT_API_KEY" \
    --data '{
      "search": {
        "search_type": "cpf",
        "search_key": "999.999.999-99"
      }
    }'
  ```

  ```python Python theme={null}
  import os, requests

  resp = requests.post(
      "https://lawsuits.production.judit.io/lawsuits",
      headers={
          "api-key": os.environ["JUDIT_API_KEY"],
          "Content-Type": "application/json",
      },
      json={
          "search": {"search_type": "cpf", "search_key": "999.999.999-99"},
      },
      timeout=15,
  )
  resp.raise_for_status()
  print(resp.json())
  ```

  ```javascript Node.js theme={null}
  const res = await fetch("https://lawsuits.production.judit.io/lawsuits", {
    method: "POST",
    headers: {
      "api-key": process.env.JUDIT_API_KEY,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      search: { search_type: "cpf", search_key: "999.999.999-99" },
    }),
  });
  console.log(await res.json());
  ```

  ```go Go theme={null}
  package main

  import (
      "bytes"
      "encoding/json"
      "io"
      "net/http"
      "os"
  )

  func main() {
      body, _ := json.Marshal(map[string]any{
          "search": map[string]string{
              "search_type": "cpf",
              "search_key":  "999.999.999-99",
          },
      })
      req, _ := http.NewRequest("POST",
          "https://lawsuits.production.judit.io/lawsuits",
          bytes.NewReader(body))
      req.Header.Set("api-key", os.Getenv("JUDIT_API_KEY"))
      req.Header.Set("Content-Type", "application/json")
      res, _ := http.DefaultClient.Do(req)
      defer res.Body.Close()
      out, _ := io.ReadAll(res.Body)
      println(string(out))
  }
  ```
</CodeGroup>

## Passo 2: Ler a resposta

A resposta vem **no corpo do mesmo POST** (não há polling). Os campos principais:

| Campo                    | Tipo    | Descrição                                                                        |
| :----------------------- | :------ | :------------------------------------------------------------------------------- |
| `has_lawsuits`           | boolean | `true` se foram encontrados processos no datalake.                               |
| `request_id`             | string  | Identificador único da consulta — útil para auditoria.                           |
| `response_data`          | array   | Lista de processos. Cada item segue o [Schema Lawsuit](/schemas/lawsuit-object). |
| `response_data[].phase`  | string  | Fase atual do processo — ver tabela abaixo.                                      |
| `response_data[].status` | string  | Status atual do processo — ver tabela abaixo.                                    |

***

### Exemplo completo de resposta

<Accordion title="Ver exemplo de resposta">
  A resposta dessa requisição será um objeto JSON com os dados retornados:

  ```json theme={null}
  {
      "has_lawsuits": true,
      "request_id": "c37cacba-41b5-4694-919f-4a937f2ea5df",
      "response_data": [
          {
              "code": "9999999-99.9999.9.99.9999",
              "justice": "5",
              "tribunal": "01",
              "instance": 2,
              "distribution_date": "2023-05-18T11:12:59.000Z",
              "tribunal_acronym": "TRT1",
              "secrecy_level": 0,
              "tags": {
                  "is_fallback_source": true,
                  "crawl_id": "28e00227-e41b-4c94-956e-7a0f105eabee"
              },
              "subjects": [
                  { "code": "13656", "name": "DOMÉSTICOS" }
              ],
              "classifications": [
                  { "code": "1009", "name": "RECURSO ORDINÁRIO TRABALHISTA" }
              ],
              "courts": [
                  { "code": "75580", "name": "GAB DES. GLAUCIA ZUCCARI FERNANDES BRAGA" }
              ],
              "parties": [
                  {
                      "name": "Usuário teste",
                      "side": "Active",
                      "person_type": "Autor",
                      "document": "99999999999",
                      "document_type": "CPF",
                      "lawyers": [
                          { "name": "Advogada do Autor", "side": "Active", "person_type": "Advogado" }
                      ]
                  },
                  {
                      "name": "Usuário teste",
                      "side": "Passive",
                      "person_type": "Réu",
                      "document": "99999999999",
                      "document_type": "CPF",
                      "lawyers": [
                          { "name": "Advogado do Réu", "side": "Passive", "person_type": "Advogado" }
                      ]
                  }
              ],
              "steps": [],
              "attachments": [],
              "related_lawsuits": [],
              "crawler": {
                  "source_name": "JTJ - BR - Document / Lawsuit - Auth",
                  "crawl_id": "28e00227-e41b-4c94-956e-7a0f105eabee",
                  "weight": 0,
                  "updated_at": "2024-03-18T19:21:02.466Z"
              },
              "amount": 7685.82,
              "last_step": {
                  "lawsuit_cnj": "9999999-99.9999.9.99.9999",
                  "lawsuit_instance": 2,
                  "step_id": "JZzfEPTs10aeE+vpu+p+bkrz5K7enJhAM5kWattktHk=",
                  "step_date": "2024-03-18T19:21:02.466Z",
                  "private": false,
                  "steps_count": 1
              },
              "name": "Nome do Autor X Nome do Réu"
          }
      ]
  }
  ```
</Accordion>

> Estrutura completa de cada item do array `response_data`: veja [Schema Lawsuit](/schemas/lawsuit-object).

## Erros comuns

| HTTP  | Quando acontece                                                                   | Como tratar                                                                                                       |
| :---- | :-------------------------------------------------------------------------------- | :---------------------------------------------------------------------------------------------------------------- |
| `400` | `search_type` ou `search_key` inválidos / formato incorreto.                      | Validar o documento antes de enviar (ex.: 11 dígitos para CPF, 14 para CNPJ).                                     |
| `401` | API Key ausente ou inválida.                                                      | Conferir o header `api-key`.                                                                                      |
| `404` | Nenhum processo encontrado. A resposta vem com `has_lawsuits: false` mesmo assim. | Tratar como ausência de exposição judicial — não é necessariamente erro.                                          |
| `429` | Rate limit excedido (500 req/min).                                                | Implementar **exponential backoff** lendo `X-RateLimit-Reset`.                                                    |
| `500` | Erro interno transitório.                                                         | Repetir com backoff. Se persistir, abrir ticket no [suporte](https://api.whatsapp.com/send/?phone=5511920501949). |

## Próximos passos

* Para **listar e filtrar** com mais profundidade (filtros avançados, polo, classes): [Consulta Histórica por documento](/requests/request-document).
* Para **agregação** (contagens por tribunal/área/fase): [Consulta Agrupada](/cache-judit/cache-grouped).
* Para forçar **leitura em tempo real** no tribunal: [Consulta Assíncrona](/requests/requests).
