L'intera API in un curl
Dimentica per un attimo l'SDK. Ogni esempio qui invia la stessa cosa: un corpo JSON a POST /v1/chat/completions con un token bearer. Se riesci a inviare questo, hai finito. Prendi una chiave dalla pagina di registrazione (il credito di prova non richiede dettagli di pagamento), esportala come API_KEY e esegui questo.
curl https://api.unrestrictedaiapi.com/v1/chat/completions \
-H "Authorization: Bearer $API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "uncensored",
"messages": [{"role": "user", "content": "Write a two-line noir opening set in a laundromat."}],
"max_tokens": 120
}'La risposta è un oggetto in stile OpenAI. Il testo è a choices[0].message.content, e un blocco usage ti dice quanto è costata la chiamata in token. C'è un unico modello, uncensored, quindi il campo model non cambia mai. Puoi confermarlo con GET /v1/models.
curl https://api.unrestrictedaiapi.com/v1/models -H "Authorization: Bearer $API_KEY"Due limiti da memorizzare prima di scrivere codice: la finestra di contesto è di 100.000 token condivisi tra prompt e completamento, e max_tokens ha come valore predefinito 2048 a meno che tu non lo aumenti (fino a 32.000). Se il tuo output si interrompe a metà frase, il valore predefinito è solitamente il colpevole.
Python con httpx
httpx ti offre un client sincrono con timeout ragionevoli e un gemello asincrono quando ne hai bisogno. Imposta il timeout esplicitamente. Le generazioni lunghe possono richiedere del tempo e il valore predefinito di cinque secondi le interromperebbe.
import os
import httpx
resp = httpx.post(
"https://api.unrestrictedaiapi.com/v1/chat/completions",
headers={"Authorization": f"Bearer {os.environ['API_KEY']}"},
json={
"model": "uncensored",
"messages": [
{"role": "system", "content": "You are a blunt, vivid fiction writer."},
{"role": "user", "content": "Pitch a heist where the vault is a night market."},
],
"temperature": 0.9,
"max_tokens": 300,
},
timeout=60.0,
)
resp.raise_for_status()
print(resp.json()["choices"][0]["message"]["content"])raise_for_status() converte qualsiasi 4xx o 5xx in un'eccezione, il che va bene per uno script. Per qualsiasi cosa a esecuzione lunga, avvolgi la chiamata in modo che due stati abbiano un'altra possibilità: 429 (hai raggiunto il limite per chiave di 300 richieste al minuto) e 503 (upstream_busy, che si risolve in pochi secondi). Tutto il resto, inclusi 401, 402 e 403, non si risolve da solo con il retry.
import os
import time
import httpx
def chat(messages, retries=3):
for attempt in range(retries + 1):
r = httpx.post(
"https://api.unrestrictedaiapi.com/v1/chat/completions",
headers={"Authorization": f"Bearer {os.environ['API_KEY']}"},
json={"model": "uncensored", "messages": messages, "max_tokens": 400},
timeout=60.0,
)
if r.status_code in (429, 503) and attempt < retries:
time.sleep(2 ** attempt)
continue
r.raise_for_status()
return r.json()["choices"][0]["message"]["content"]
print(chat([{"role": "user", "content": "Name five cursed objects found in a thrift store."}]))Scambia httpx.post con httpx.AsyncClient().post dentro un async def e avrai la versione async con lo stesso payload.
JavaScript con fetch
Node 18 e versioni successive includono fetch, quindi non c'è nulla da installare. Salva il file come .mjs (o imposta "type": "module") affinché il await di livello superiore funzioni. I browser hanno la stessa API, ma non mettere la chiave nel codice front-end. Inoltra la chiamata attraverso il tuo backend.
const res = await fetch("https://api.unrestrictedaiapi.com/v1/chat/completions", {
method: "POST",
headers: {
Authorization: `Bearer ${process.env.API_KEY}`,
"Content-Type": "application/json",
},
body: JSON.stringify({
model: "uncensored",
messages: [{ role: "user", content: "Describe a villain's morning routine in four bullets." }],
max_tokens: 250,
}),
});
if (!res.ok) {
const err = await res.json().catch(() => ({}));
throw new Error(`HTTP ${res.status}: ${err?.error?.message ?? "unknown error"}`);
}
const data = await res.json();
console.log(data.choices[0].message.content);Nota l'ordine dei controlli. fetch rigetta solo in caso di errore di rete, quindi un 402 o 403 arriva come risposta normale. Verifica res.ok tu stesso e leggi il JSON di errore, che ha sempre la struttura {"error":{"code":...,"message":...}}.
Go con net/http
Go richiede qualche riga in più ma nessuna dipendenza. Definisci solo i campi della struct che leggi; encoding/json ignora il resto. Leggere il corpo in byte prima di controllare lo stato ti permette di stampare il messaggio di errore del server quando qualcosa va storto.
package main
import (
"bytes"
"encoding/json"
"fmt"
"io"
"net/http"
"os"
)
type reply struct {
Choices []struct {
Message struct {
Content string `json:"content"`
} `json:"message"`
} `json:"choices"`
}
func main() {
payload, _ := json.Marshal(map[string]any{
"model": "uncensored",
"messages": []map[string]string{
{"role": "user", "content": "Give me a ghost story in exactly three sentences."},
},
"max_tokens": 200,
})
req, _ := http.NewRequest("POST", "https://api.unrestrictedaiapi.com/v1/chat/completions", bytes.NewReader(payload))
req.Header.Set("Authorization", "Bearer "+os.Getenv("API_KEY"))
req.Header.Set("Content-Type", "application/json")
resp, err := http.DefaultClient.Do(req)
if err != nil {
panic(err)
}
defer resp.Body.Close()
body, _ := io.ReadAll(resp.Body)
if resp.StatusCode != http.StatusOK {
panic(fmt.Sprintf("HTTP %d: %s", resp.StatusCode, body))
}
var out reply
if err := json.Unmarshal(body, &out); err != nil {
panic(err)
}
fmt.Println(out.Choices[0].Message.Content)
}Per la produzione, crea un http.Client{Timeout: 60 * time.Second} e riutilizzalo. Il client di default non ha timeout, il che trasforma una richiesta bloccata in un goroutine bloccato.
PHP con cURL e Ruby con Net::HTTP
L'estensione cURL di PHP è già presente sulla maggior parte degli host. Costruisci il corpo con json_encode, restituisci il trasferimento come stringa, poi leggi lo stato con curl_getinfo. Saltare il controllo dello stato è l'errore classico: un corpo 402 si decodifica felicemente come JSON e il tuo codice fallisce su una chiave choices mancante.
<?php
$payload = json_encode([
"model" => "uncensored",
"messages" => [
["role" => "user", "content" => "Write a villanelle opening about a broken vending machine."],
],
"max_tokens" => 200,
]);
$ch = curl_init("https://api.unrestrictedaiapi.com/v1/chat/completions");
curl_setopt_array($ch, [
CURLOPT_POST => true,
CURLOPT_RETURNTRANSFER => true,
CURLOPT_TIMEOUT => 60,
CURLOPT_HTTPHEADER => [
"Authorization: Bearer " . getenv("API_KEY"),
"Content-Type: application/json",
],
CURLOPT_POSTFIELDS => $payload,
]);
$body = curl_exec($ch);
$status = curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);
if ($body === false || $status !== 200) {
fwrite(STDERR, "HTTP $status: $body\n");
exit(1);
}
$data = json_decode($body, true);
echo $data["choices"][0]["message"]["content"], "\n";Su un host condiviso con un basso max_execution_time, mantieni max_tokens moderato o sposta la chiamata in un worker di coda.
La libreria standard è sufficiente anche qui. ENV.fetch genera un errore immediato se la variabile manca, il che è meglio che inviare un bearer token vuoto e fare debug di un 401 per dieci minuti.
require "net/http"
require "json"
require "uri"
uri = URI("https://api.unrestrictedaiapi.com/v1/chat/completions")
req = Net::HTTP::Post.new(uri)
req["Authorization"] = "Bearer #{ENV.fetch('API_KEY')}"
req["Content-Type"] = "application/json"
req.body = JSON.generate(
model: "uncensored",
messages: [{ role: "user", content: "Invent a tavern rumor that sounds too specific to be fake." }],
max_tokens: 200
)
res = Net::HTTP.start(uri.host, uri.port, use_ssl: true, read_timeout: 60) { |http| http.request(req) }
abort("HTTP #{res.code}: #{res.body}") unless res.is_a?(Net::HTTPSuccess)
puts JSON.parse(res.body).dig("choices", 0, "message", "content")Se in seguito passi a Rails, lo stesso corpo funziona da un job in background. Tieni la chiamata fuori dal ciclo di richiesta; le generazioni sono più lente di una query al database.
Entrambi gli snippet inviano esattamente il corpo che invia quello Python, che è il punto: se un linguaggio funziona e un altro no, confronta il JSON, non il client. Stampa il corpo della richiesta grezza una volta e confrontalo byte per byte. Nove volte su dieci il colpevole è un header Content-Type mancante o un nome del modello digitato con la lettera maiuscola.
Streaming senza libreria
Lo streaming è l'unico punto in cui l'HTTP puro ti chiede un po' di più. Con stream: true il server risponde con eventi server-sent: ogni riga inizia con data: , trasporta un chunk JSON e lo stream termina con data: [DONE]. Un ultimo chunk di usage viene aggiunto automaticamente, quindi ottieni i conteggi dei token anche quando fai streaming. Questo chunk non ha voci choices, motivo per cui il ciclo qui sotto controlla prima di indicizzare.
import json
import os
import httpx
body = {
"model": "uncensored",
"messages": [{"role": "user", "content": "Tell a campfire story about a lighthouse keeper."}],
"stream": True,
"max_tokens": 400,
}
headers = {"Authorization": f"Bearer {os.environ['API_KEY']}"}
with httpx.stream("POST", "https://api.unrestrictedaiapi.com/v1/chat/completions",
headers=headers, json=body, timeout=60.0) as r:
r.raise_for_status()
for line in r.iter_lines():
if not line.startswith("data: "):
continue
data = line[6:]
if data == "[DONE]":
break
chunk = json.loads(data)
if chunk.get("choices"):
print(chunk["choices"][0]["delta"].get("content") or "", end="", flush=True)
print()Lo stesso pattern si porta direttamente. In JavaScript, leggi res.body con un reader e dividi per newline. In Go, avvolgi resp.Body in un bufio.Scanner. In Ruby, passa un blocco a http.request e usa read_body. In PHP, imposta un callback CURLOPT_WRITEFUNCTION. La logica non cambia mai: rimuovi il prefisso, fermati al sentinel, analizza il JSON, stampa il delta.
Test di funzionalità in cinque minuti e verifica del budget
Prima di costruire sopra uno di questi snippet, esegui un rapido controllo di integrità. Primo, chiama /v1/models con la tua chiave; un 200 prova la chiave e il percorso di rete. Secondo, invia la richiesta di chat più piccola possibile con max_tokens impostato a 20. Terzo, rompi qualcosa deliberatamente, come un token bearer vuoto, e conferma che il tuo codice restituisce chiaramente il 401 invece di crashare per un campo mancante.
Poi fai i calcoli una volta per evitare sorprese. I prezzi sono $0,25 per milione di token di input e $1,00 per milione di token di output. Come esempio illustrativo, supponiamo che una richiesta invii 600 token di prompt e riceva 400 token. Questo è 600 x $0,25 / 1.000.000 = $0,00015 in, più 400 x $1,00 / 1.000.000 = $0,0004 out, circa $0,00055 per chiamata. Il credito di prova di $0,50 coprirebbe circa 900 chiamate di questa dimensione. I tuoi prompt reali saranno diversi, quindi leggi il blocco usage su alcune risposte e moltiplica da lì.
Il credito di prova dura sette giorni e non richiede dettagli di pagamento, il che lo rende ottimo per testare tutti e cinque i linguaggi. Se vuoi un caso d'uso a cui puntare, la guida ai contenuti NSFW mostra un esempio completo. Ricorda che una chiave appartiene a un account; se la rigeneri, aggiorna tutti gli script contemporaneamente, perché la vecchia chiave smette di funzionare immediatamente.
Errori uguali in ogni linguaggio
Poiché l'API è HTTP puro, la gestione degli errori è identica indipendentemente dal linguaggio che scegli. Memorizza questa tabella e potrai portare in porto qualsiasi snippet sopra.
| Stato | Significato | Azione |
|---|---|---|
| 400 | Richiesta non valida, come prompt più max_tokens oltre 100k | Riduci il prompt o abbassa max_tokens |
| 401 | Chiave mancante o non valida | Verifica API_KEY; una chiave rigenerata invalida immediatamente quella vecchia |
| 402 | no_credit: saldo esaurito o credito di prova scaduto | Ricarica il credito prepagato |
| 403 | content_blocked | Non riprovare; i contenuti sessuali che coinvolgono minori sono sempre bloccati |
| 429 | Più di 300 richieste al minuto | Riduci la frequenza e riprova |
| 503 | upstream_busy | Riprova tra qualche secondo |
Una volta che le basi funzionano, imposta stream: true per l'output token per token e leggi gli eventi inviati dal server riga per riga. Crea prompt migliori con la guida ai prompt, o collega la stessa chiamata a una piattaforma di chat usando la guida per i bot. I prezzi sono nella pagina dei prezzi.
