API OpenCNPJ

import requests
import time
from typing import Optional, Dict, Any

class OpenCNPJClient:
    def __init__(self, base_url: str = "https://opencnpj.com/api"):
        self.base_url = base_url
        self.session = requests.Session()
        self.session.headers.update({
            'Accept': 'application/json',
            'User-Agent': 'MeuApp/1.0'
        })
        self.session.timeout = 30

    def consultar_cnpj(self, cnpj: str) -> Optional[Dict[str, Any]]:
        """
        Consulta informações de uma empresa pelo CNPJ
        
        Args:
            cnpj (str): CNPJ da empresa (com ou sem formatação)
            
        Returns:
            Dict com informações da empresa ou None se não encontrada
            
        Raises:
            ValueError: Se o CNPJ for inválido
            requests.RequestException: Se houver erro na requisição
        """
        # Remove formatação do CNPJ
        cnpj_limpo = ''.join(filter(str.isdigit, cnpj))
        
        if not self.validar_cnpj(cnpj_limpo):
            raise ValueError("CNPJ inválido")
        
        url = f"{self.base_url}/{cnpj_limpo}"
        
        try:
            response = self.session.get(url)
            
            if response.status_code == 200:
                return response.json()
            elif response.status_code == 404:
                return None
            elif response.status_code == 429:
                # Rate limit - aguarda e tenta novamente
                time.sleep(2)
                response = self.session.get(url)
                if response.status_code == 200:
                    return response.json()
                else:
                    response.raise_for_status()
            else:
                response.raise_for_status()
                
        except requests.RequestException as e:
            raise requests.RequestException(f"Erro na consulta: {e}")

    def obter_info(self) -> Dict[str, Any]:
        """Obtém informações sobre a base de dados"""
        url = f"{self.base_url}/info"
        response = self.session.get(url)
        response.raise_for_status()
        return response.json()

    def validar_cnpj(self, cnpj: str) -> bool:
        """Valida se o CNPJ possui formato correto"""
        return len(cnpj) == 14 and cnpj.isdigit()

# Exemplo de uso
if __name__ == "__main__":
    client = OpenCNPJClient()
    
    try:
        # Consultar empresa
        empresa = client.consultar_cnpj("11.222.333/0001-81")
        
        if empresa:
            print(f"Razão Social: {empresa['razao_social']}")
            print(f"CNAE: {empresa['cnae_fiscal_descricao']}")
            print(f"Situação: {empresa['descricao_situacao_cadastral']}")
        else:
            print("Empresa não encontrada")
            
        # Obter informações da base
        info = client.obter_info()
        print(f"Última atualização: {info['ultima_atualizacao']}")
        
    except ValueError as e:
        print(f"Erro de validação: {e}")
    except requests.RequestException as e:
        print(f"Erro na requisição: {e}")

import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
import java.time.Duration;
import java.util.concurrent.CompletableFuture;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;

public class OpenCNPJClient {
    private final HttpClient httpClient;
    private final ObjectMapper objectMapper;
    private final String baseUrl;

    public OpenCNPJClient() {
        this.baseUrl = "https://opencnpj.com/api";
        this.httpClient = HttpClient.newBuilder()
            .connectTimeout(Duration.ofSeconds(30))
            .build();
        this.objectMapper = new ObjectMapper();
    }

    public JsonNode consultarCNPJ(String cnpj) throws Exception {
        // Remove formatação do CNPJ
        String cnpjLimpo = cnpj.replaceAll("[^0-9]", "");
        
        if (!validarCNPJ(cnpjLimpo)) {
            throw new IllegalArgumentException("CNPJ inválido");
        }

        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create(baseUrl + "/" + cnpjLimpo))
            .header("Accept", "application/json")
            .header("User-Agent", "MeuApp/1.0")
            .timeout(Duration.ofSeconds(30))
            .GET()
            .build();

        try {
            HttpResponse<String> response = httpClient.send(request,
                HttpResponse.BodyHandlers.ofString());

            switch (response.statusCode()) {
                case 200:
                    return objectMapper.readTree(response.body());
                case 404:
                    return null;
                case 429:
                    // Rate limit - aguarda e tenta novamente
                    Thread.sleep(2000);
                    HttpResponse<String> retryResponse = httpClient.send(request,
                        HttpResponse.BodyHandlers.ofString());
                    if (retryResponse.statusCode() == 200) {
                        return objectMapper.readTree(retryResponse.body());
                    }
                    throw new RuntimeException("Rate limit excedido");
                default:
                    throw new RuntimeException("Erro HTTP: " + response.statusCode());
            }
        } catch (Exception e) {
            throw new Exception("Erro na consulta: " + e.getMessage(), e);
        }
    }

    public CompletableFuture<JsonNode> consultarCNPJAsync(String cnpj) {
        return CompletableFuture.supplyAsync(() -> {
            try {
                return consultarCNPJ(cnpj);
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        });
    }

    public JsonNode obterInfo() throws Exception {
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create(baseUrl + "/info"))
            .header("Accept", "application/json")
            .timeout(Duration.ofSeconds(30))
            .GET()
            .build();

        HttpResponse<String> response = httpClient.send(request,
            HttpResponse.BodyHandlers.ofString());

        if (response.statusCode() == 200) {
            return objectMapper.readTree(response.body());
        } else {
            throw new RuntimeException("Erro HTTP: " + response.statusCode());
        }
    }

    private boolean validarCNPJ(String cnpj) {
        return cnpj != null && cnpj.length() == 14 && cnpj.matches("\\d+");
    }

    // Exemplo de uso
    public static void main(String[] args) {
        OpenCNPJClient client = new OpenCNPJClient();

        try {
            // Consulta síncrona
            JsonNode empresa = client.consultarCNPJ("11.222.333/0001-81");
            
            if (empresa != null) {
                System.out.println("Razão Social: " + 
                    empresa.get("razao_social").asText());
                System.out.println("CNAE: " + 
                    empresa.get("cnae_fiscal_descricao").asText());
                
                // Processar sócios (QSA)
                if (empresa.has("QSA") && empresa.get("QSA").isArray()) {
                    System.out.println("Sócios:");
                    empresa.get("QSA").forEach(socio -> {
                        System.out.println("- " + socio.get("nome").asText());
                    });
                }
            } else {
                System.out.println("Empresa não encontrada");
            }

            // Consulta assíncrona
            client.consultarCNPJAsync("11222333000181")
                .thenAccept(result -> {
                    if (result != null) {
                        System.out.println("Consulta assíncrona concluída");
                    }
                })
                .join();

        } catch (Exception e) {
            System.err.println("Erro: " + e.getMessage());
        }
    }
}