Wortic

Documentação da API de CNPJ

Um endereço, uma resposta em JSON. Copie o exemplo da sua linguagem e rode: não precisa de cadastro nem de chave.

Comece em um minuto

O exemplo busca a empresa pelo CNPJ e mostra a razão social e a situação. Troque o número pelo CNPJ que você quer.

curl https://cnpj.wortic.com/cnpj/37853407000171

Saída esperada: WORTIC LTDA - Ativa

Modelo pronto em Rust

Um cadastro de clientes que se preenche pelo CNPJ: backend em Rust e tela num binário só, com a conferência do CNPJ, a guarda das respostas e o tratamento do limite. Clone, rode cargo run --release e adapte. Ver no GitHub.

No seu framework

A mesma consulta, escrita do jeito de cada pilha. TypeScript, Dart, WordPress, Objective-C e COBOL rodaram contra esta API antes de entrar aqui; React, Next.js e Laravel tiveram tipos e sintaxe conferidos; Vue, Svelte, Angular, Solid, Astro e Remix chamam a mesma função do TypeScript.

TypeScript (navegador, Node, Deno, Bun, borda)
// cnpj.ts: a consulta tipada, igual no navegador, no Node, no Deno, no Bun, no React Native e na borda.
export interface Empresa {
  cnpj: string;
  cnpj_formatado: string;
  razao_social: string;
  nome_fantasia: string;
  situacao: { codigo: number; descricao: string; desde: string };
  abertura: string;
  cnae_principal: { codigo: string; descricao: string };
}

export class LimiteAtingido extends Error {
  readonly esperarSegundos: number;

  constructor(esperarSegundos: number) {
    super(`limite da API: tente de novo em ${esperarSegundos} s`);
    this.esperarSegundos = esperarSegundos;
  }
}

export async function buscarCnpj(cnpj: string, sinal?: AbortSignal): Promise<Empresa> {
  const r = await fetch(`https://cnpj.wortic.com/cnpj/${cnpj.replace(/\D/g, "")}`, { signal: sinal ?? null });
  if (r.status === 402 || r.status === 429) throw new LimiteAtingido(Number(r.headers.get("retry-after") ?? 60));
  if (!r.ok) throw new Error(`CNPJ ${cnpj}: HTTP ${r.status}`);
  return r.json() as Promise<Empresa>;
}
React e React Native
// useEmpresa.ts: React e React Native. A consulta é cancelada se o CNPJ mudar ou o componente sair da tela.
import { useEffect, useState } from "react";
import { buscarCnpj, type Empresa } from "./cnpj.ts";

type Estado = { empresa?: Empresa; erro?: Error; carregando: boolean };

export function useEmpresa(cnpj: string): Estado {
  const [estado, setEstado] = useState<Estado>({ carregando: true });

  useEffect(() => {
    const controle = new AbortController();
    setEstado({ carregando: true });
    buscarCnpj(cnpj, controle.signal)
      .then((empresa) => setEstado({ empresa, carregando: false }))
      .catch((erro: unknown) => {
        if (!controle.signal.aborted) setEstado({ erro: erro as Error, carregando: false });
      });
    return () => controle.abort();
  }, [cnpj]);

  return estado;
}
Next.js (Route Handler)
// app/api/empresa/[cnpj]/route.ts (Next.js App Router): guarda a resposta por um dia no cache do Next.
import { buscarCnpj, LimiteAtingido } from "./cnpj.ts";

export async function GET(_: Request, { params }: { params: Promise<{ cnpj: string }> }): Promise<Response> {
  try {
    return Response.json(await buscarCnpj((await params).cnpj), { headers: { "cache-control": "s-maxage=86400" } });
  } catch (e) {
    if (e instanceof LimiteAtingido) return new Response(null, { status: 429, headers: { "retry-after": String(e.esperarSegundos) } });
    return Response.json({ erro: (e as Error).message }, { status: 404 });
  }
}
Vue, Svelte, Angular, Solid, Astro e Remix
// Todos chamam a mesma buscarCnpj de cnpj.ts, no lugar onde cada framework carrega dados.

// Vue 3 (<script setup lang="ts">)
const empresa = ref<Empresa>();
onMounted(async () => (empresa.value = await buscarCnpj(props.cnpj)));

// SvelteKit (src/routes/empresa/[cnpj]/+page.ts)
export const load = async ({ params }) => ({ empresa: await buscarCnpj(params.cnpj) });

// Angular (componente)
empresa = signal<Empresa | undefined>(undefined);
async ngOnInit() { this.empresa.set(await buscarCnpj(this.cnpj)); }

// SolidJS
const [empresa] = createResource(() => props.cnpj, buscarCnpj);

// Astro (frontmatter da página)
const empresa = await buscarCnpj(Astro.params.cnpj!);

// Remix / React Router 7 (loader da rota)
export const loader = ({ params }: LoaderFunctionArgs) => buscarCnpj(params.cnpj!);
Flutter e Dart
// cnpj.dart: Dart e Flutter, só com a biblioteca padrão (dart:io e dart:convert).
import 'dart:convert';
import 'dart:io';

typedef Empresa = ({String razaoSocial, String situacao});

Future<Empresa> buscarCnpj(String cnpj) async {
  final cliente = HttpClient();
  try {
    final pedido = await cliente.getUrl(Uri.https('cnpj.wortic.com', '/cnpj/${cnpj.replaceAll(RegExp(r'\D'), '')}'));
    final resposta = await pedido.close();
    if (resposta.statusCode == 402 || resposta.statusCode == 429) throw HttpException('limite: espere ${resposta.headers.value('retry-after')} s');
    final ficha = jsonDecode(await resposta.transform(utf8.decoder).join()) as Map<String, Object?>;
    return (razaoSocial: ficha['razao_social']! as String, situacao: (ficha['situacao']! as Map)['descricao']! as String);
  } finally {
    cliente.close();
  }
}

Future<void> main() async {
  final empresa = await buscarCnpj('37.853.407/0001-71');
  print('Dart: ${empresa.razaoSocial} - ${empresa.situacao}');
}
Laravel
<?php
// Laravel 12+: o cliente HTTP do framework, com nova tentativa no limite e cache de um dia.
declare(strict_types=1);

use Illuminate\Support\Facades\Cache;
use Illuminate\Support\Facades\Http;

function buscarCnpj(string $cnpj): array
{
    $digitos = preg_replace('/\D/', '', $cnpj);

    return Cache::remember("cnpj:$digitos", now()->addDay(), static fn (): array => Http::baseUrl('https://cnpj.wortic.com')
        ->retry(3, static fn (int $tentativa, Exception $e): int => (int) ($e->response?->header('Retry-After') ?: 1) * 1000)
        ->get("/cnpj/$digitos")
        ->throw()
        ->json());
}
WordPress
<?php
// WordPress: a API HTTP do próprio WordPress, com a resposta guardada num transient por um dia.
declare(strict_types=1);

function wortic_buscar_cnpj(string $cnpj): array|WP_Error
{
    $digitos = preg_replace('/\D/', '', $cnpj);
    $guardado = get_transient("wortic_cnpj_$digitos");
    if (is_array($guardado)) {
        return $guardado;
    }

    $resposta = wp_remote_get("https://cnpj.wortic.com/cnpj/$digitos", ['timeout' => 10]);
    if (is_wp_error($resposta)) {
        return $resposta;
    }
    if (wp_remote_retrieve_response_code($resposta) !== 200) {
        return new WP_Error('cnpj', 'HTTP ' . wp_remote_retrieve_response_code($resposta));
    }

    $ficha = json_decode(wp_remote_retrieve_body($resposta), true, 512, JSON_THROW_ON_ERROR);
    set_transient("wortic_cnpj_$digitos", $ficha, DAY_IN_SECONDS);
    return $ficha;
}
iOS e macOS (Objective-C)
// cnpj.m: iOS e macOS em Objective-C, com NSURLSession. clang -fobjc-arc cnpj.m -framework Foundation -o cnpj
#import <Foundation/Foundation.h>

static void buscarCnpj(NSString *cnpj, void (^pronto)(NSDictionary *_Nullable ficha, NSError *_Nullable erro)) {
    NSString *digitos = [[cnpj componentsSeparatedByCharactersInSet:NSCharacterSet.decimalDigitCharacterSet.invertedSet]
        componentsJoinedByString:@""];
    NSURL *url = [NSURL URLWithString:[@"https://cnpj.wortic.com/cnpj/" stringByAppendingString:digitos]];
    [[NSURLSession.sharedSession dataTaskWithURL:url
                               completionHandler:^(NSData *dados, NSURLResponse *resposta, NSError *erro) {
                                   NSInteger status = ((NSHTTPURLResponse *)resposta).statusCode;
                                   if (erro) {
                                       pronto(nil, erro);
                                   } else if (status != 200) {
                                       pronto(nil, [NSError errorWithDomain:@"cnpj.wortic.com" code:status userInfo:nil]);
                                   } else {
                                       pronto([NSJSONSerialization JSONObjectWithData:dados options:0 error:&erro], erro);
                                   }
                               }] resume];
}

int main(void) {
    @autoreleasepool {
        dispatch_semaphore_t fim = dispatch_semaphore_create(0);
        buscarCnpj(@"37.853.407/0001-71", ^(NSDictionary *ficha, NSError *erro) {
            if (erro) NSLog(@"%@", erro);
            else printf("Objective-C: %s - %s\n", [ficha[@"razao_social"] UTF8String], [ficha[@"situacao"][@"descricao"] UTF8String]);
            dispatch_semaphore_signal(fim);
        });
        dispatch_semaphore_wait(fim, DISPATCH_TIME_FOREVER);
    }
}
COBOL
      >>SOURCE FORMAT FREE
*> cnpj.cob: COBOL (GnuCOBOL 3.2+). Busca a ficha pelo curl do sistema e tira a razão social com UNSTRING.
*>   cobc -x -free cnpj.cob -o cnpj && ./cnpj 37853407000171
IDENTIFICATION DIVISION.
PROGRAM-ID. CNPJ.

ENVIRONMENT DIVISION.
INPUT-OUTPUT SECTION.
FILE-CONTROL.
    SELECT RESPOSTA ASSIGN TO "cnpj-resposta.txt" ORGANIZATION LINE SEQUENTIAL.

DATA DIVISION.
FILE SECTION.
FD RESPOSTA.
01 LINHA          PIC X(8192).

WORKING-STORAGE SECTION.
01 CNPJ           PIC X(18).
01 COMANDO        PIC X(200).
01 INICIO         PIC 9(5).
01 RAZAO          PIC X(150).
01 RESTO          PIC X(8192).

PROCEDURE DIVISION.
    ACCEPT CNPJ FROM ARGUMENT-VALUE
    STRING "curl -s https://cnpj.wortic.com/cnpj/" FUNCTION TRIM(CNPJ) " -o cnpj-resposta.txt"
        DELIMITED BY SIZE INTO COMANDO
    CALL "SYSTEM" USING COMANDO

    OPEN INPUT RESPOSTA
    READ RESPOSTA
    CLOSE RESPOSTA

    UNSTRING LINHA DELIMITED BY '"razao_social":"' INTO RESTO RESTO
    UNSTRING RESTO DELIMITED BY '"' INTO RAZAO
    DISPLAY "COBOL: " FUNCTION TRIM(RAZAO)
    STOP RUN.

Os três endereços

EndereçoO que devolve
GET /cnpj/{cnpj}A ficha da empresa: razão social, nome fantasia, situação, abertura, CNAE principal e secundários, natureza jurídica, capital social, porte, Simples, MEI, endereço, telefone e e-mail públicos. Aceita o CNPJ com ou sem pontuação e o CNPJ alfanumérico.
GET /cnpj/{cnpj}/sociosOs sócios: nome, qualificação, data de entrada e faixa etária. O CPF vem sempre mascarado.
GET /empresas?nome=&uf=Até 50 empresas ativas pelo nome (4 letras ou mais). O estado é opcional.

Descrição completa, campo a campo, em openapi.json. Ele abre direto no Postman, no Insomnia e nos geradores de cliente.

Respostas de erro

CódigoQuandoO que fazer
400 cnpj_invalidoOs dígitos verificadores não conferemConfira o número antes de consultar
400 termo_curtoBusca por nome com menos de 4 letrasPeça mais letras ao usuário
404 nao_encontradoCNPJ válido que não está na baseTrate como "não achei"
402 limite_gratisSem chave, passou de 60 consultas no minuto ou de 2.000 no dia, por IPEspere os segundos do retry-after, ou assine um plano: a resposta traz os planos e os links de compra
402 plano_proRota Pro (/v1/empresas/...) sem chaveAssine o plano Pro e mande a chave no x-api-key
429 bloqueadoIP bloqueado por 1 ou 6 horas por insistir acima do limiteEspere o retry-after, que traz os segundos que faltam, e reduza o ritmo
403 banidoIP banido de vez da API abertaFale com a Wortic
401 chave_invalidaChave de API inválida ou revogadaConfira a chave no cabeçalho x-api-key
429 limite_do_planoCom chave, o limite do plano acabou (no minuto, no dia ou no mês)Espere, ou suba de plano

Limite e bloqueio

Sem chave, são 60 consultas por minuto e 2.000 por dia, por IP. O dia vira à meia-noite de Brasília. Quem passa do limite do minuto ou do dia recebe 402 limite_gratis, com o retry-after em segundos: 60 no minuto, e até a meia-noite no dia.

Cada minuto em que o IP passa do limite do minuto conta uma vez. Com 10 minutos assim, o IP fica bloqueado por 1 hora (429 bloqueado). Depois de 3 bloqueios de 1 hora, o seguinte é de 6 horas. Depois de 3 bloqueios de 6 horas, o IP é banido de vez (403 banido). Passar do limite do dia não conta para esse bloqueio. Quem fica abaixo de 60 por minuto e de 2.000 por dia nunca chega lá.

Para volume maior, use uma chave no cabeçalho x-api-key: vale o limite do seu plano e a escada de bloqueio não se aplica. Fale com a Wortic.

Cabeçalhos das respostas sem chave

x-ratelimit-limit-dia traz o teto diário (2000), x-ratelimit-restante-dia traz quantas consultas ainda cabem hoje, e x-base-cnpj traz o mês da base da Receita, no formato AAAA-MM.

Pagamento por máquina (HTTP 402)

Quem passa do limite grátis ou chama uma rota Pro sem chave recebe 402 Payment Required em dois formatos que agentes de IA entendem: o cabeçalho payment-required (x402 versão 2, com os planos em accepts, valor em centavos e moeda BRL) e o cabeçalho www-authenticate: Payment (MPP). O corpo, em português, lista os planos com o link de compra de cada um. Por enquanto a compra é pelo link; o pagamento direto pela API ainda não está ligado e responde 402 meio_ainda_nao_ligado. Quem trata o 429 precisa tratar também o 402.

Busca Pro: as empresas que você procura

Todas as empresas da Receita que passam nos seus filtros, página por página, em JSON, CSV ou jsonW. Só com chave de plano Pro; cada página conta uma consulta.

curl -H "x-api-key: $WORTIC_CHAVE" \
  "https://cnpj.wortic.com/v1/empresas/busca?cnae=1091102&municipio=4314902&telefone=1&formato=csv" \
  -o padarias-porto-alegre.csv
ParâmetroValor
cnaeCódigos de 7 dígitos, separados por vírgula (até 50). Vale o CNAE principal.
ufSiglas dos estados: RS,SC.
municipioCódigos IBGE de 7 dígitos (até 100).
raiolat,lon,km: os municípios cujo centro fica a até km do ponto (até 500 km).
caixalat_sul,lon_oeste,lat_norte,lon_leste: a área visível do seu mapa.
porteme, epp, demais ou nao_informado.
situacaoativa (padrão), suspensa, inapta, baixada ou nula.
capital_min, capital_maxCapital social em reais: 150000 ou 1500.50.
abertura_de, abertura_ateData de abertura, AAAA-MM-DD.
classe_rendaClasse de renda do CEP da empresa, de A a E: A,B. Fonte: IBGE, Censo 2022.
idh_minIDH mínimo do CEP da empresa, de 0 a 1: 0.8.
telefone, email1 só com, 0 só sem.
matriz1 só matrizes, 0 só filiais.
limiteEmpresas por página, de 1 a 100 (padrão 20).
cursorO cursor da página anterior, para seguir.
formatojson (padrão, a ficha inteira de cada empresa), csv (para planilha) ou jsw (arquivo jsonW com esquema e conferência SHA-256 de cada bloco).

Informe ao menos um de cnae, uf, municipio, raio ou caixa. A ordem é a do CNPJ, então a mesma busca com o mesmo cursor devolve sempre a mesma página.

Todas as páginas

// TypeScript (Node 22+, ESM)
type Pagina = { empresas: { cnpj: string; razao_social: string }[]; cursor: string | null; mais: boolean };

const url = new URL("https://cnpj.wortic.com/v1/empresas/busca?cnae=1091102&uf=RS&limite=100");
const empresas: Pagina["empresas"] = [];
for (let mais = true; mais;) {
  const r = await fetch(url, { headers: { "x-api-key": process.env.WORTIC_CHAVE! } });
  if (!r.ok) throw new Error((await r.json()).erro.mensagem);
  const p: Pagina = await r.json();
  empresas.push(...p.empresas);
  if ((mais = p.mais)) url.searchParams.set("cursor", p.cursor!);
}
console.log(empresas.length, "padarias no RS");
# Python 3.10+, só a biblioteca padrão
import json, os, sys
from urllib.error import HTTPError
from urllib.parse import urlencode
from urllib.request import Request, urlopen

params = {"cnae": "1091102", "uf": "RS", "limite": 100}
empresas = []
while True:
    pedido = Request(f"https://cnpj.wortic.com/v1/empresas/busca?{urlencode(params)}",
                     headers={"x-api-key": os.environ["WORTIC_CHAVE"]})
    try:
        with urlopen(pedido) as r:
            pagina = json.load(r)
    except HTTPError as erro:
        with erro:
            sys.exit(json.load(erro)["erro"]["mensagem"])
    empresas += pagina["empresas"]
    if not pagina["mais"]:
        break
    params["cursor"] = pagina["cursor"]
print(len(empresas), "padarias no RS")
// Rust. Cargo.toml: ureq = { version = "3", features = ["json"] }, serde_json = "1"
fn main() -> Result<(), Box<dyn std::error::Error>> {
    let chave = std::env::var("WORTIC_CHAVE")?;
    let (mut total, mut cursor) = (0, String::new());
    loop {
        let mut r = ureq::get("https://cnpj.wortic.com/v1/empresas/busca")
            .query("cnae", "1091102").query("uf", "RS").query("limite", "100")
            .query("cursor", &cursor).header("x-api-key", &chave).call()?;
        let p: serde_json::Value = r.body_mut().read_json()?;
        total += p["empresas"].as_array().map_or(0, Vec::len);
        let Some(c) = p["cursor"].as_str().filter(|_| p["mais"] == true) else { break };
        cursor = c.to_owned();
    }
    println!("{total} padarias no RS");
    Ok(())
}

Respostas de erro da busca

CódigoQuando
402 plano_proPedido sem x-api-key: a resposta traz os planos Pro
401 chave_invalidaChave de API inválida ou revogada
403 sem_plano_proChave de plano sem a busca Pro (não gasta consulta)
400 filtro_largoNenhum de cnae, uf, municipio, raio ou caixa
400 <parâmetro>Valor que não vale; a mensagem diz o formato certo

Empresas parecidas com uma

Dê o CNPJ de um cliente que deu certo e receba as empresas ativas mais parecidas com ele, com nota de 0 a 100 e o motivo de cada semelhança: ramo, mistura de atividades, porte, regime tributário, natureza jurídica e a economia do município. Uma consulta por pedido.

curl -H "x-api-key: $WORTIC_CHAVE" "https://cnpj.wortic.com/v1/empresas/parecidas?cnpj=37853407000171&k=10"
ParâmetroValor
cnpjO CNPJ da empresa de referência, com ou sem pontuação.
kQuantas empresas, de 1 a 50 (padrão 20).

Nota por pedido

Diga o que pesa para você e receba as melhores empresas do seu filtro, com o quanto cada critério somou na nota. Usa os mesmos filtros da busca e avalia as primeiras empresas do filtro, na ordem do CNPJ: 500, ou o que você pedir em amostra (de 100 a 2.000). Uma consulta por pedido.

curl -H "x-api-key: $WORTIC_CHAVE" \
  "https://cnpj.wortic.com/v1/empresas/avaliar?cnae=1091102&municipio=4314902&pesos=capital:2,contato:1&k=10"
Critério em pesosVale mais quando
capitalO capital social é maior
contatoHá telefone e e-mail públicos
idhO IDH do CEP da empresa é maior
novasA empresa abriu há pouco tempo (até 10 anos)
madurasA empresa tem mais tempo de vida (30 anos ou mais vale o máximo)

Cada peso vai de 0 a 10: pesos=capital:2,contato:1. k vai de 1 a 100 (padrão 20). A resposta diz quantas empresas foram avaliadas e se o filtro coube inteiro na amostra (completo). Com 500 empresas, a nota sai em cerca de 1 segundo.

Rápida porque não tem banco de dados no caminho

A API lê a base da Receita direto de arquivos jsonW, o formato de dados da Wortic. Não há servidor de banco entre o seu pedido e a resposta.

0,24 msmediana para montar uma ficha no servidor (200 CNPJs distintos)
0,20 msmediana da busca por nome no servidor (10 termos)
73.809.379estabelecimentos na base aberta

Medido em 14/11/2026 no próprio servidor, sem contar a rede. A primeira leitura de uma região do arquivo é mais lenta: no mesmo teste, 95% das fichas saíram em até 23,8 ms.

Use jsonW no seu sistema também

O jsonW é grátis para usar no seu produto, em quantos servidores quiser, e conversa com JSON: você converte de um para o outro com um comando. Tem SDK em C, C++, Python, Node.js, PHP, Ruby, Go, Rust, Java, Kotlin e Swift. Se você guarda as respostas desta API para consultar depois, guardar em jsonW deixa a busca rápida sem precisar subir um banco: num arquivo de 1 milhão de linhas, achar um registro pela chave leva 0,196 ms com o índice, contra 142,8 ms varrendo o arquivo (mediana de 200 buscas, jsonW 1.3.13).

Conheça o jsonW em jsonw.org

Conector MCP aberto, sem login

Qualquer agente de IA que fale MCP consulta empresas direto por https://cnpj.wortic.com/mcp. São três ferramentas: consultar_cnpj, listar_socios e buscar_empresa. Vale o mesmo limite e a mesma escada de bloqueio da API. Dentro do MCP, quem passa do limite recebe a mensagem na ferramenta, sem o 402.

{
  "mcpServers": {
    "wortic-cnpj": { "url": "https://cnpj.wortic.com/mcp" }
  }
}

Cole no arquivo de servidores MCP do seu cliente (Claude Desktop, Cursor e outros). O transporte é HTTP com JSON-RPC 2.0.

Com a conta Wortic, dentro do Claude e do ChatGPT

O conector oficial da Wortic traz a consulta de empresas junto com as outras ferramentas da plataforma. Depois de conectar, peça em português: "consulte o CNPJ 37.853.407/0001-71". Veja como conectar.

Para agentes que leem a API por conta própria, o llms.txt traz as rotas, o limite e como citar a fonte.