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ódigo | Causa provável | Correção |
|---|---|---|
| 401 | Chave ausente ou errada | Verifique o cabeçalho Authorization e que $API_KEY está exportado |
| 400 | JSON malformado ou campo inválido | Valide o corpo com jq . antes de enviar |
429, código rate_limited | Mais de 300 requisições por minuto (60 em uma chave de teste) | Reduza a velocidade do seu loop |
429, código concurrency | Mais de 8 requisições ao mesmo tempo (2 em uma chave de teste) | Execute menos trabalhos em paralelo |
429 com Retry-After: 5 | Sobrecarga temporária | Espere 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).
