PT ▾
Obter chave de API
API sem censura compatível com OpenAI para desenvolvedores.Atualizado

Exemplos de curl para API LLM que você pode copiar e executar

Se você quer testar a API LLM com curl antes de escrever código, as solicitações abaixo bastam. Cada uma aponta para um endpoint compatível com OpenAI, usa o ID do modelo uncensored e roda em um terminal simples.

Painel de terminal enviando um feixe de luz para um cubo de servidor, representando uma solicitação curl para uma API LLM

Configure seu shell e verifique o endpoint

Obtenha uma chave na página de chave de API, depois exporte-a junto com a URL base para não colar segredos em cada comando.

export API_KEY="paste-your-key-here"
export BASE="https://api.uncensoredllmapi.com/v1"

Cada solicitação envia a chave como token bearer no cabeçalho Authorization. Os corpos das solicitações são JSON, então adicione Content-Type: application/json ao POST. O tamanho máximo do corpo é 8 MB, o que só importa se você colar documentos muito grandes no prompt.

Os exemplos usam as aspas simples do shell Unix. No PowerShell do Windows, coloque o JSON em um arquivo e passe-o com --data @body.json para evitar problemas de aspas.

A verificação de sanidade mais barata é um GET que lista os modelos. Confirma a chave e a URL, e não custa nada.

curl -s "$BASE/models" \
  -H "Authorization: Bearer $API_KEY"

O array data na resposta deve incluir o ID uncensored. Um 401 significa que a chave está faltando ou digitada errado. Se o curl não conseguir conectar, verifique o host em $BASE e certifique-se de que termina em /v1 sem caminho extra.

1. Envie uma conclusão de chat

Esta é a solicitação que todo cliente estilo OpenAI envia nos bastidores.

curl -s "https://api.uncensoredllmapi.com/v1/chat/completions" \
  -H "Authorization: Bearer $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "uncensored",
    "messages": [
      {"role": "system", "content": "You are a concise assistant."},
      {"role": "user", "content": "Give me three names for a fantasy tavern."}
    ],
    "temperature": 0.8,
    "max_tokens": 200
  }'

A resposta é JSON. O texto está em choices[0].message.content, e as contagens de tokens estão em usage. Encadeie a saída com jq -r '.choices[0].message.content' se você tiver o jq instalado e quiser apenas o texto. O campo max_tokens é opcional; não o inclua e a conclusão pode usar o que restar da janela de contexto de 100.000 tokens.

O endpoint mais novo POST /v1/responses também está disponível se seu cliente usa esse formato. Para a lista completa de parâmetros, consulte a documentação.

2. Faça streaming da resposta

Adicione "stream": true e diga ao curl para não fazer buffer com -N. Os tokens serão impressos conforme são gerados.

curl -N "$BASE/chat/completions" \
  -H "Authorization: Bearer $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "uncensored",
    "stream": true,
    "messages": [{"role": "user", "content": "Count from one to ten in words."}]
  }'

Cada linha começa com data: e contém um pequeno fragmento JSON com um delta. Os eventos finais trazem uso, e o stream termina com data: [DONE]. Sem -N, o curl espera por um buffer completo, e a saída parece chegar de uma vez só. Note que uma requisição em streaming mantém um slot de concorrência ocupado até o fim.

3. Solicite JSON

Para uma saída que um script vai analisar, ative o modo JSON com response_format. Mencione a palavra JSON no prompt para que o modelo saiba qual formato você espera.

curl -s "$BASE/chat/completions" \
  -H "Authorization: Bearer $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "uncensored",
    "response_format": {"type": "json_object"},
    "messages": [{"role": "user",
      "content": "Return JSON with keys name and level for a fantasy character."}]
  }' | jq -r '.choices[0].message.content | fromjson'

O filtro final fromjson analisa a string dentro de content, então o jq falha claramente se o modelo retornar algo que não seja JSON válido. Isso o torna um teste rápido útil. Mais padrões estão na página de modo JSON.

4. Tente uma chamada de ferramenta

A chamada de ferramentas permite que o modelo peça para seu código executar uma função. Você descreve a função em um array tools, e se o modelo decidir usá-la, a resposta conterá uma entrada tool_calls em vez de texto.

curl -s "$BASE/chat/completions" \
  -H "Authorization: Bearer $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "uncensored",
    "messages": [{"role": "user", "content": "What is the weather in Oslo?"}],
    "tools": [{
      "type": "function",
      "function": {
        "name": "get_weather",
        "description": "Get current weather for a city",
        "parameters": {
          "type": "object",
          "properties": {"city": {"type": "string"}},
          "required": ["city"]
        }
      }
    }],
    "tool_choice": "auto"
  }' | jq '.choices[0].message.tool_calls'

Você deve receber um nome de função e uma string JSON de argumentos. Seu código executa a função, depois envia uma segunda requisição que repete as mensagens anteriores, adiciona a mensagem do assistente com a chamada de ferramenta e adiciona uma mensagem com role: "tool" contendo o resultado. O modelo então escreve a resposta final.

5. Verifique cabeçalhos e saldo

Adicione -i para ver cabeçalhos de resposta junto com o corpo. Você encontrará X-Request-Id, X-Balance-USD, X-RateLimit-Limit-Requests e X-RateLimit-Limit-Concurrency.

curl -s -i "$BASE/chat/completions" \
  -H "Authorization: Bearer $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"uncensored","messages":[{"role":"user","content":"ping"}],"max_tokens":5}' \
  | grep -i "^x-"

curl -s "$BASE/balance" -H "Authorization: Bearer $API_KEY"

A segunda chamada retorna seu crédito diretamente. Ferramentas compatíveis com OpenAI podem usar GET /v1/dashboard/billing/credit_grants em vez disso. Uma solicitação pequena como a anterior custa uma fração de centavo: com 10 tokens de entrada e 5 tokens de saída, o preço é 10 x 0,15 / 1.000.000 + 5 x 0,50 / 1.000.000 = $0,000004. Consulte a página de preços para ver as tarifas.

Um script de teste rápido reutilizável

Depois de confiar nas chamadas individuais, envolva-as em um script curto que você pode executar após qualquer deploy, rotação de chave ou mudança de rede. Ele falha no primeiro problema, então você vê exatamente qual etapa falhou.

set -euo pipefail
BASE="https://api.uncensoredllmapi.com/v1"

echo "models:"
curl -sf "$BASE/models" -H "Authorization: Bearer $API_KEY" | jq -r '.data[].id'

echo "chat:"
curl -sf "$BASE/chat/completions" \
  -H "Authorization: Bearer $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"uncensored","messages":[{"role":"user","content":"Say ok."}],"max_tokens":5}' \
  | jq -r '.choices[0].message.content'

echo "balance:"
curl -sf "$BASE/balance" -H "Authorization: Bearer $API_KEY"

A flag -f faz o curl sair com erro em falhas HTTP, e set -e para o script ali. Coloque-o em um cron job ou etapa de CI se você executar um serviço sobre esta API e quiser um alerta antecipado quando algo mudar. Mantenha a chave em um armazenamento de segredos ou variável de ambiente, nunca no arquivo do script.

Ao variar a solicitação, altere uma configuração por vez: temperature para aleatoriedade, top_p para amostragem de núcleo, stop para sequências de fim personalizadas e seed para saída repetível. Todos eles são passados para o modelo, então você pode comparar seus efeitos a partir do mesmo histórico de terminal.

Lendo erros do curl

CódigoCausa provávelCorreção
401Chave ausente ou erradaVerifique o cabeçalho Authorization e que $API_KEY está exportado
400JSON malformado ou campo inválidoValide o corpo com jq . antes de enviar
429, código rate_limitedMais de 300 requisições por minuto (60 em uma chave de teste)Reduza a velocidade do seu loop
429, código concurrencyMais de 8 requisições ao mesmo tempo (2 em uma chave de teste)Execute menos trabalhos em paralelo
429 com Retry-After: 5Sobrecarga temporáriaEspere 5 segundos e tente novamente

Adicione -w "\n%{http_code}\n" para imprimir o código de status após o corpo, o que evita que você adivinhe. Os corpos de erro são JSON com uma mensagem e um código, então jq .error os exibe de forma limpa. Se você vir um 429 em um loop, não tente novamente imediatamente; uma pausa de alguns segundos permite que a janela do minuto e as vagas de concorrência sejam liberadas, e um loop de tentativa apertado apenas mantém você acima do limite. Uma chave de teste tem limites mais restritos do que uma chave completa, então um script que funciona após seu primeiro recarregamento pode falhar com crédito de teste se executar trabalhos em paralelo. Quando as requisições estiverem estáveis, passe para um SDK; a mesma URL e o mesmo nome de modelo são mantidos sem alterações. Novas contas podem reivindicar $0,50 de crédito de teste com um clique, suficiente para centenas de pequenas chamadas de teste. Recarregamentos a partir daí começam em $20 e são pagos em cripto (USDT na TRC20 ou USDC na Base).

Perguntas e respostas

Para qual URL envio as solicitações curl?

Use https://api.uncensoredllmapi.com/v1 como base, depois adicione /chat/completions, /responses, /models ou /balance dependendo do que você precisa.

Como testar chamada de funções com curl?

Adicione um array tools com uma definição de função ao corpo da conclusão de chat. Se o modelo decidir chamá-la, a resposta contém tool_calls, e você envia o resultado de volta como uma mensagem com role tool.

Por que o curl não mostra nada até o fim da resposta?

Você provavelmente está fazendo streaming sem a flag -N. Adicione -N para que o curl imprima cada bloco conforme ele chega.

Uma requisição falha custa dinheiro?

Não. Requisições falhas ou recusadas não são cobradas.

Sua chave está a um passo de distância

Crie uma conta, copie a chave e altere a URL base. Essa é toda a configuração.