API grátis de consulta CNPJ

curl --silent --show-error --fail-with-body "https://cnpjfy.walisson.dev/api/v1/cnpj/00000000000191" \
  -H "Authorization: Bearer SUA_CHAVE"

# com o jq, só os dois campos (ou erro.mensagem, se a consulta falhar):
curl -s -H "Authorization: Bearer SUA_CHAVE" "https://cnpjfy.walisson.dev/api/v1/cnpj/00000000000191" | jq -r 'if .erro then "Erro: " + .erro.mensagem else .razao_social + " - " + .situacao.descricao end'

# --body mostra só o JSON; --check-status devolve erro no terminal quando o status não é 2xx
http --body --check-status -A bearer -a SUA_CHAVE GET "https://cnpjfy.walisson.dev/api/v1/cnpj/00000000000191"

// A API libera CORS, mas uma chave no front-end público fica visível a qualquer visitante: em produção, chame do seu servidor.
const cnpj = "00000000000191";

try {
  const resposta = await fetch(`https://cnpjfy.walisson.dev/api/v1/cnpj/${cnpj}`, {
    headers: { Authorization: "Bearer SUA_CHAVE" },
  });
  const dados = await resposta.json();
  if (!resposta.ok) throw new Error(dados.erro.mensagem);
  console.log(`${dados.razao_social} - ${dados.situacao.descricao}`);
} catch (e) {
  console.error("Erro:", e.message);
}

// Node 18 ou mais novo: fetch já vem de fábrica. Uso: node consulta.mjs [CNPJ]
const cnpj = process.argv[2] ?? "00000000000191";

try {
  const resposta = await fetch(`https://cnpjfy.walisson.dev/api/v1/cnpj/${encodeURIComponent(cnpj)}`, {
    headers: { Authorization: "Bearer SUA_CHAVE" },
    signal: AbortSignal.timeout(10_000),
  });
  const dados = await resposta.json();
  if (!resposta.ok) throw new Error(dados.erro.mensagem);
  console.log(`${dados.razao_social} - ${dados.situacao.descricao}`);
} catch (e) {
  console.error("Erro:", e.message);
  process.exitCode = 1;
}

// Os tipos abaixo cobrem os campos usados aqui; o schema completo está em /api/v1/openapi.json.
type Empresa = {
  cnpj: string;
  razao_social: string | null;
  situacao: { descricao: string | null; data: string | null };
  capital_social: number | null;
};
type ErroDaApi = { erro: { codigo: string; status: number; mensagem: string; documentacao: string } };

async function consultar(cnpj: string): Promise<Empresa> {
  const resposta = await fetch(`https://cnpjfy.walisson.dev/api/v1/cnpj/${encodeURIComponent(cnpj)}`, {
    headers: { Authorization: "Bearer SUA_CHAVE" },
  });
  const dados: Empresa | ErroDaApi = await resposta.json();
  if ("erro" in dados) throw new Error(dados.erro.mensagem);
  return dados;
}

consultar("00000000000191")
  .then((e) => console.log(`${e.razao_social} - ${e.situacao.descricao}`))
  .catch((e: Error) => {
    console.error("Erro:", e.message);
    process.exitCode = 1;
  });

import requests

resposta = requests.get(
    "https://cnpjfy.walisson.dev/api/v1/cnpj/00000000000191",
    headers={"Authorization": "Bearer SUA_CHAVE"},
    timeout=10,
)
dados = resposta.json()

if not resposta.ok:
    raise SystemExit(f"Erro: {dados['erro']['mensagem']}")

print(dados["razao_social"], "-", dados["situacao"]["descricao"])

<?php
$ch = curl_init("https://cnpjfy.walisson.dev/api/v1/cnpj/00000000000191");
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 10,
    CURLOPT_HTTPHEADER => ["Authorization: Bearer SUA_CHAVE"],
]);
$corpo = curl_exec($ch);

if ($corpo === false) {
    fwrite(STDERR, "Erro: " . curl_error($ch) . "\n");
    exit(1);
}

$status = curl_getinfo($ch, CURLINFO_HTTP_CODE);
$dados = json_decode($corpo, true);

if ($status !== 200) {
    fwrite(STDERR, "Erro: " . $dados["erro"]["mensagem"] . "\n");
    exit(1);
}

echo $dados["razao_social"] . " - " . $dados["situacao"]["descricao"] . "\n";

package main

import (
	"encoding/json"
	"fmt"
	"net/http"
	"os"
	"time"
)

type resposta struct {
	RazaoSocial string `json:"razao_social"`
	Situacao    struct {
		Descricao string `json:"descricao"`
	} `json:"situacao"`
	Erro struct {
		Mensagem string `json:"mensagem"`
	} `json:"erro"`
}

func main() {
	cliente := http.Client{Timeout: 10 * time.Second}
	pedido, _ := http.NewRequest("GET", "https://cnpjfy.walisson.dev/api/v1/cnpj/00000000000191", nil)
	pedido.Header.Set("Authorization", "Bearer SUA_CHAVE")
	res, err := cliente.Do(pedido)
	if err != nil {
		fmt.Fprintln(os.Stderr, "Erro:", err)
		os.Exit(1)
	}
	defer res.Body.Close()

	var dados resposta
	if err := json.NewDecoder(res.Body).Decode(&dados); err != nil {
		fmt.Fprintln(os.Stderr, "Erro:", err)
		os.Exit(1)
	}
	if res.StatusCode != http.StatusOK {
		fmt.Fprintln(os.Stderr, "Erro:", dados.Erro.Mensagem)
		os.Exit(1)
	}
	fmt.Println(dados.RazaoSocial, "-", dados.Situacao.Descricao)
}

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.time.Duration;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

// Java 11 ou mais novo. O JDK não traz leitor de JSON; aqui um regex basta para dois campos.
// Em um projeto de verdade, use Jackson ou Gson.
public class Consulta {
    static String campo(String json, String padrao) {
        Matcher m = Pattern.compile(padrao).matcher(json);
        return m.find() ? m.group(1) : "";
    }

    public static void main(String[] args) throws Exception {
        HttpClient cliente = HttpClient.newBuilder().connectTimeout(Duration.ofSeconds(10)).build();
        HttpRequest pedido = HttpRequest.newBuilder(URI.create("https://cnpjfy.walisson.dev/api/v1/cnpj/00000000000191"))
                .header("Authorization", "Bearer SUA_CHAVE")
                .timeout(Duration.ofSeconds(10)).GET().build();
        HttpResponse<String> resposta = cliente.send(pedido, HttpResponse.BodyHandlers.ofString());

        if (resposta.statusCode() != 200) {
            System.err.println("Erro: " + campo(resposta.body(), "\"mensagem\":\"([^\"]*)\""));
            System.exit(1);
        }
        System.out.println(campo(resposta.body(), "\"razao_social\":\"([^\"]*)\"") + " - "
                + campo(resposta.body(), "\"situacao\":\\{\"descricao\":\"([^\"]*)\""));
    }
}

using System.Text.Json;

using var http = new HttpClient { Timeout = TimeSpan.FromSeconds(10) };
http.DefaultRequestHeaders.Add("Authorization", "Bearer SUA_CHAVE");
var resposta = await http.GetAsync("https://cnpjfy.walisson.dev/api/v1/cnpj/00000000000191");
using var doc = JsonDocument.Parse(await resposta.Content.ReadAsStringAsync());
var raiz = doc.RootElement;

if (!resposta.IsSuccessStatusCode)
{
    Console.Error.WriteLine($"Erro: {raiz.GetProperty("erro").GetProperty("mensagem").GetString()}");
    return 1;
}

Console.WriteLine($"{raiz.GetProperty("razao_social").GetString()} - {raiz.GetProperty("situacao").GetProperty("descricao").GetString()}");
return 0;

require "net/http"
require "json"

# Ruby 3 ou mais novo
resposta = Net::HTTP.get_response(
  URI("https://cnpjfy.walisson.dev/api/v1/cnpj/00000000000191"),
  { "Authorization" => "Bearer SUA_CHAVE" }
)
dados = JSON.parse(resposta.body)

abort("Erro: #{dados["erro"]["mensagem"]}") unless resposta.is_a?(Net::HTTPSuccess)

puts "#{dados["razao_social"]} - #{dados["situacao"]["descricao"]}"

// Cargo.toml:
//   reqwest = { version = "0.12", features = ["blocking", "json"] }
//   serde_json = "1"
use serde_json::Value;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let resposta = reqwest::blocking::Client::new()
        .get("https://cnpjfy.walisson.dev/api/v1/cnpj/00000000000191")
        .bearer_auth("SUA_CHAVE")
        .send()?;
    let ok = resposta.status().is_success();
    let dados: Value = resposta.json()?;

    if !ok {
        eprintln!("Erro: {}", dados["erro"]["mensagem"].as_str().unwrap_or("erro desconhecido"));
        std::process::exit(1);
    }
    println!(
        "{} - {}",
        dados["razao_social"].as_str().unwrap_or(""),
        dados["situacao"]["descricao"].as_str().unwrap_or("")
    );
    Ok(())
}

import java.net.URI
import java.net.http.HttpClient
import java.net.http.HttpRequest
import java.net.http.HttpResponse
import java.time.Duration
import kotlin.system.exitProcess

// Sem biblioteca de JSON, um regex pega os dois campos. Em um projeto de verdade, use kotlinx.serialization.
fun campo(json: String, padrao: String) = Regex(padrao).find(json)?.groupValues?.get(1) ?: ""

fun main() {
    val cliente = HttpClient.newBuilder().connectTimeout(Duration.ofSeconds(10)).build()
    val pedido = HttpRequest.newBuilder(URI.create("https://cnpjfy.walisson.dev/api/v1/cnpj/00000000000191"))
        .header("Authorization", "Bearer SUA_CHAVE")
        .timeout(Duration.ofSeconds(10)).GET().build()
    val resposta = cliente.send(pedido, HttpResponse.BodyHandlers.ofString())
    val corpo = resposta.body()

    if (resposta.statusCode() != 200) {
        System.err.println("Erro: " + campo(corpo, "\"mensagem\":\"([^\"]*)\""))
        exitProcess(1)
    }
    println(campo(corpo, "\"razao_social\":\"([^\"]*)\"") + " - " + campo(corpo, "\"situacao\":\\{\"descricao\":\"([^\"]*)\""))
}

import Foundation
#if canImport(FoundationNetworking)
import FoundationNetworking  // Linux
#endif

struct Resposta: Decodable {
    struct Situacao: Decodable { let descricao: String? }
    struct Erro: Decodable { let mensagem: String }
    let razao_social: String?
    let situacao: Situacao?
    let erro: Erro?
}

var pedido = URLRequest(url: URL(string: "https://cnpjfy.walisson.dev/api/v1/cnpj/00000000000191")!)
pedido.setValue("Bearer SUA_CHAVE", forHTTPHeaderField: "Authorization")

do {
    let (dados, resposta) = try await URLSession.shared.data(for: pedido)
    let corpo = try JSONDecoder().decode(Resposta.self, from: dados)
    if (resposta as? HTTPURLResponse)?.statusCode != 200 {
        print("Erro:", corpo.erro?.mensagem ?? "erro desconhecido")
        exit(1)
    }
    print(corpo.razao_social ?? "", "-", corpo.situacao?.descricao ?? "")
} catch {
    print("Erro:", error.localizedDescription)
    exit(1)
}

// dart pub add http
import 'dart:convert';
import 'dart:io';

import 'package:http/http.dart' as http;

Future<void> main() async {
  final resposta = await http
      .get(
        Uri.parse('https://cnpjfy.walisson.dev/api/v1/cnpj/00000000000191'),
        headers: {'Authorization': 'Bearer SUA_CHAVE'},
      )
      .timeout(const Duration(seconds: 10));
  final dados = jsonDecode(utf8.decode(resposta.bodyBytes)) as Map<String, dynamic>;

  if (resposta.statusCode != 200) {
    stderr.writeln('Erro: ${dados['erro']['mensagem']}');
    exit(1);
  }
  print('${dados['razao_social']} - ${dados['situacao']['descricao']}');
}

try {
    $dados = Invoke-RestMethod -Uri "https://cnpjfy.walisson.dev/api/v1/cnpj/00000000000191" -TimeoutSec 10 `
        -Headers @{ Authorization = "Bearer SUA_CHAVE" }
    "$($dados.razao_social) - $($dados.situacao.descricao)"
}
catch {
    # em erro HTTP, o corpo (JSON da API) vem em ErrorDetails.Message (PowerShell 7) ou no stream da resposta (5.1)
    $mensagem = $_.Exception.Message
    $corpo = $_.ErrorDetails.Message
    if (-not $corpo -and $_.Exception.Response) {
        $corpo = (New-Object System.IO.StreamReader($_.Exception.Response.GetResponseStream())).ReadToEnd()
    }
    if ($corpo) { try { $mensagem = ($corpo | ConvertFrom-Json).erro.mensagem } catch { } }
    [Console]::Error.WriteLine("Erro: $mensagem")
    exit 1
}

/**
 * Razão social e situação de um CNPJ, pela API do CNPJfy.
 * Na planilha: =CNPJ("00.000.000/0001-91")
 * @param {string} cnpj CNPJ com ou sem máscara.
 * @return {string} Ex.: BANCO DO BRASIL SA - Ativa
 * @customfunction
 */
function CNPJ(cnpj) {
  const limpo = String(cnpj).replace(/[^0-9A-Za-z]/g, "");
  const resposta = UrlFetchApp.fetch("https://cnpjfy.walisson.dev/api/v1/cnpj/" + limpo, {
    headers: { Authorization: "Bearer SUA_CHAVE" },
    muteHttpExceptions: true,
  });
  const dados = JSON.parse(resposta.getContentText());
  if (resposta.getResponseCode() !== 200) return "Erro: " + dados.erro.mensagem;
  return dados.razao_social + " - " + dados.situacao.descricao;
}