Skip to main content

Documentation Index

Fetch the complete documentation index at: https://juditdocs.mintlify.app/llms.txt

Use this file to discover all available pages before exploring further.

​
Como Obter sua API Key

  1. Entre em contato com nossa equipe comercial
  2. Forneça informações sobre seu caso de uso e volume esperado
  3. Receba sua API Key por email seguro
  4. Configure a chave em sua aplicação
Importante: Sua API Key é única e pessoal. Nunca compartilhe ou exponha publicamente.

​
Configuração da API Key

​
Método de Autenticação

A API Key deve ser enviada no header api-key de todas as requisições: 
GET /requests
Host: requests.prod.judit.io
api-key: sua-api-key-aqui
Content-Type: application/json

​
Exemplos de Configuração

cURL: 
# Definir variável de ambiente
export JUDIT_API_KEY="sua-api-key-aqui"

# Usar em requisições
curl -X GET "https://requests.prod.judit.io/requests" \
  -H "api-key: $JUDIT_API_KEY" \
  -H "Content-Type: application/json"
Python: 
import os
import requests

# Configurar API Key
api_key = os.getenv('JUDIT_API_KEY')

# Headers padrão
headers = {
    'api-key': api_key,
    'Content-Type': 'application/json'
}

# Fazer requisição
response = requests.get(
    'https://requests.prod.judit.io/requests',
    headers=headers
)
JavaScript: 
// Configurar API Key
const apiKey = process.env.JUDIT_API_KEY;

// Headers padrão
const headers = {
    'api-key': apiKey,
    'Content-Type': 'application/json'
};

// Fazer requisição
const response = await fetch('https://requests.prod.judit.io/requests', {
    method: 'GET',
    headers: headers
});

​
Boas Práticas de Segurança

​
1. Use Variáveis de Ambiente

Nunca hardcode sua API Key no código: 
# ❌ ERRADO - Nunca faça isso
api_key = "sk_live_1234567890abcdef"

# ✅ CORRETO - Use variáveis de ambiente
api_key = os.getenv('JUDIT_API_KEY')

​
2. Configure Variáveis de Ambiente

Linux/macOS: 
# No arquivo ~/.bashrc ou ~/.zshrc
export JUDIT_API_KEY="sua-api-key-aqui"

# Ou para sessão atual
export JUDIT_API_KEY="sua-api-key-aqui"
Windows: 
# Command Prompt
set JUDIT_API_KEY=sua-api-key-aqui

# PowerShell
$env:JUDIT_API_KEY="sua-api-key-aqui"
Docker: 
# Dockerfile
ENV JUDIT_API_KEY=""

# docker-compose.yml
environment:
  - JUDIT_API_KEY=${JUDIT_API_KEY}

​
3. Arquivo .env (Desenvolvimento)

# .env
JUDIT_API_KEY=sua-api-key-aqui
JUDIT_BASE_URL=https://requests.prod.judit.io

# Python com python-dotenv
from dotenv import load_dotenv
import os

load_dotenv()
api_key = os.getenv('JUDIT_API_KEY')

​
4. Rotação de Chaves

  • Monitore o uso de sua API Key regularmente
  • Solicite nova chave se suspeitar de comprometimento
  • Implemente rotação automática em ambientes críticos

​
Tratamento de Erros de Autenticação

​
Erro 401 - Unauthorized

{
  "error": "Unauthorized",
  "message": "API key inválida ou ausente",
  "code": "INVALID_API_KEY"
}
Possíveis causas:
  • API Key não fornecida
  • API Key inválida ou expirada
  • Header api-key mal formatado
Como resolver: 
def handle_auth_error(response):
    if response.status_code == 401:
        error_data = response.json()
        
        if error_data.get('code') == 'INVALID_API_KEY':
            print("Erro: API Key inválida")
            print("Verifique se a chave está correta e ativa")
            
        # Log do erro para debugging
        logging.error(f"Erro de autenticação: {error_data}")
        
        return None
    
    return response.json()

​
Erro 403 - Forbidden

{
  "error": "Forbidden",
  "message": "Acesso negado para este recurso",
  "code": "INSUFFICIENT_PERMISSIONS"
}
Possíveis causas:
  • API Key válida mas sem permissão para o recurso
  • Limite de uso excedido
  • Recurso não disponível no seu plano

​
Validação da API Key

​
Teste de Conectividade

import requests

def test_api_key(api_key):
    """Testa se a API Key está válida"""
    headers = {'api-key': api_key}
    
    try:
        response = requests.get(
            'https://requests.prod.judit.io/requests',
            headers=headers,
            params={'page': 1, 'page_size': 1}
        )
        
        if response.status_code == 200:
            print("✅ API Key válida")
            return True
        elif response.status_code == 401:
            print("❌ API Key inválida")
            return False
        else:
            print(f"⚠️ Erro inesperado: {response.status_code}")
            return False
            
    except requests.RequestException as e:
        print(f"❌ Erro de conexão: {e}")
        return False

# Usar a função
api_key = os.getenv('JUDIT_API_KEY')
test_api_key(api_key)

​
Monitoramento de Uso

def check_api_usage(response):
    """Monitora uso da API através dos headers"""
    
    # Rate limit info
    limit = response.headers.get('X-RateLimit-Limit')
    remaining = response.headers.get('X-RateLimit-Remaining')
    reset = response.headers.get('X-RateLimit-Reset')
    
    if limit and remaining:
        usage_percent = ((int(limit) - int(remaining)) / int(limit)) * 100
        
        print(f"Uso da API: {usage_percent:.1f}%")
        print(f"Requisições restantes: {remaining}")
        
        if usage_percent > 80:
            print("⚠️ Próximo do limite de rate limit!")

​
Configuração por Ambiente

​
Desenvolvimento

# config/development.py
import os

API_KEY = os.getenv('JUDIT_API_KEY_DEV')
BASE_URL = 'https://requests.prod.judit.io'
TIMEOUT = 30

​
Produção

# config/production.py
import os

API_KEY = os.getenv('JUDIT_API_KEY_PROD')
BASE_URL = 'https://requests.prod.judit.io'
TIMEOUT = 10
RETRY_ATTEMPTS = 3

​
Classe de Configuração

class JuditConfig:
    def __init__(self, environment='production'):
        self.environment = environment
        self.api_key = self._get_api_key()
        self.base_url = 'https://requests.prod.judit.io'
        
    def _get_api_key(self):
        key_name = f'JUDIT_API_KEY_{self.environment.upper()}'
        api_key = os.getenv(key_name)
        
        if not api_key:
            raise ValueError(f"API Key não encontrada: {key_name}")
            
        return api_key
    
    @property
    def headers(self):
        return {
            'api-key': self.api_key,
            'Content-Type': 'application/json'
        }

# Uso
config = JuditConfig('production')
response = requests.get(f"{config.base_url}/requests", 
    headers=config.headers)

​
Próximos Passos

Suporte: Em caso de problemas com autenticação, entre em contato com nosso suporte técnico.