API reference

curl http://localhost:8787/v1/chat/completions \
  -H "Authorization: Bearer sk-guard-a1b2c3..." \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-4o",
    "messages": [{"role": "user", "content": "Say hello"}],
    "max_tokens": 100
  }'

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:8787/v1",
    api_key="sk-guard-a1b2c3...",
)

resp = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "Say hello"}],
    max_tokens=100,
)
print(resp.choices[0].message.content)

import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "http://localhost:8787/v1",
  apiKey: "sk-guard-a1b2c3...",
});

const resp = await client.chat.completions.create({
  model: "gpt-4o",
  messages: [{ role: "user", content: "Say hello" }],
  max_tokens: 100,
});
console.log(resp.choices[0].message.content);

using System.Net.Http.Json;

var client = new HttpClient { BaseAddress = new Uri("http://localhost:8787/v1/") };
client.DefaultRequestHeaders.Authorization =
    new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", "sk-guard-a1b2c3...");

var payload = new {
    model = "gpt-4o",
    messages = new[] { new { role = "user", content = "Say hello" } },
    max_tokens = 100
};
var response = await client.PostAsJsonAsync("chat/completions", payload);
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);

HttpClient client = HttpClient.newHttpClient();
String json = """
    {"model":"gpt-4o","messages":[{"role":"user","content":"Say hello"}],"max_tokens":100}
    """;

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("http://localhost:8787/v1/chat/completions"))
    .header("Authorization", "Bearer sk-guard-a1b2c3...")
    .header("Content-Type", "application/json")
    .POST(HttpRequest.BodyPublishers.ofString(json))
    .build();
HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

body, _ := json.Marshal(map[string]any{
    "model":      "gpt-4o",
    "messages":   []map[string]string{{"role": "user", "content": "Say hello"}},
    "max_tokens": 100,
})
req, _ := http.NewRequest("POST", "http://localhost:8787/v1/chat/completions", bytes.NewReader(body))
req.Header.Set("Authorization", "Bearer sk-guard-a1b2c3...")
req.Header.Set("Content-Type", "application/json")
resp, _ := http.DefaultClient.Do(req)

let client = reqwest::blocking::Client::new();
let resp = client.post("http://localhost:8787/v1/chat/completions")
    .bearer_auth("sk-guard-a1b2c3...")
    .json(&serde_json::json!({
        "model": "gpt-4o",
        "messages": [{"role": "user", "content": "Say hello"}],
        "max_tokens": 100
    }))
    .send()?;

curl http://localhost:8787/v1/embeddings \
  -H "Authorization: Bearer sk-guard-a1b2c3..." \
  -H "Content-Type: application/json" \
  -d '{"model": "text-embedding-3-small", "input": "hello world"}'

resp = client.embeddings.create(
    model="text-embedding-3-small",
    input="hello world",
)
print(len(resp.data[0].embedding))

const resp = await client.embeddings.create({
  model: "text-embedding-3-small",
  input: "hello world",
});
console.log(resp.data[0].embedding.length);

using System.Net.Http.Json;

var client = new HttpClient { BaseAddress = new Uri("http://localhost:8787/v1/") };
client.DefaultRequestHeaders.Authorization =
    new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", "sk-guard-a1b2c3...");

var payload = new { model = "text-embedding-3-small", input = "hello world" };
var response = await client.PostAsJsonAsync("embeddings", payload);
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);

HttpClient client = HttpClient.newHttpClient();
String json = """
    {"model":"text-embedding-3-small","input":"hello world"}
    """;

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("http://localhost:8787/v1/embeddings"))
    .header("Authorization", "Bearer sk-guard-a1b2c3...")
    .header("Content-Type", "application/json")
    .POST(HttpRequest.BodyPublishers.ofString(json))
    .build();
HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

body, _ := json.Marshal(map[string]any{
    "model": "text-embedding-3-small",
    "input": "hello world",
})
req, _ := http.NewRequest("POST", "http://localhost:8787/v1/embeddings", bytes.NewReader(body))
req.Header.Set("Authorization", "Bearer sk-guard-a1b2c3...")
req.Header.Set("Content-Type", "application/json")
resp, _ := http.DefaultClient.Do(req)

let client = reqwest::blocking::Client::new();
let resp = client.post("http://localhost:8787/v1/embeddings")
    .bearer_auth("sk-guard-a1b2c3...")
    .json(&serde_json::json!({
        "model": "text-embedding-3-small",
        "input": "hello world"
    }))
    .send()?;

curl http://localhost:8787/v1/images/generations \
  -H "Authorization: Bearer sk-guard-a1b2c3..." \
  -H "Content-Type: application/json" \
  -d '{"model": "gpt-image-1", "prompt": "a red panda reading a book", "n": 1}'

resp = client.images.generate(
    model="gpt-image-1",
    prompt="a red panda reading a book",
    n=1,
)
print(resp.data[0].b64_json[:32], "...")

const resp = await client.images.generate({
  model: "gpt-image-1",
  prompt: "a red panda reading a book",
  n: 1,
});
console.log(resp.data[0].b64_json?.slice(0, 32), "...");

using System.Net.Http.Json;

var client = new HttpClient { BaseAddress = new Uri("http://localhost:8787/v1/") };
client.DefaultRequestHeaders.Authorization =
    new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", "sk-guard-a1b2c3...");

var payload = new { model = "gpt-image-1", prompt = "a red panda reading a book", n = 1 };
var response = await client.PostAsJsonAsync("images/generations", payload);
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);

HttpClient client = HttpClient.newHttpClient();
String json = """
    {"model":"gpt-image-1","prompt":"a red panda reading a book","n":1}
    """;

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("http://localhost:8787/v1/images/generations"))
    .header("Authorization", "Bearer sk-guard-a1b2c3...")
    .header("Content-Type", "application/json")
    .POST(HttpRequest.BodyPublishers.ofString(json))
    .build();
HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

body, _ := json.Marshal(map[string]any{
    "model":  "gpt-image-1",
    "prompt": "a red panda reading a book",
    "n":      1,
})
req, _ := http.NewRequest("POST", "http://localhost:8787/v1/images/generations", bytes.NewReader(body))
req.Header.Set("Authorization", "Bearer sk-guard-a1b2c3...")
req.Header.Set("Content-Type", "application/json")
resp, _ := http.DefaultClient.Do(req)

let client = reqwest::blocking::Client::new();
let resp = client.post("http://localhost:8787/v1/images/generations")
    .bearer_auth("sk-guard-a1b2c3...")
    .json(&serde_json::json!({
        "model": "gpt-image-1",
        "prompt": "a red panda reading a book",
        "n": 1
    }))
    .send()?;

curl http://localhost:8787/v1/audio/speech \
  -H "Authorization: Bearer sk-guard-a1b2c3..." \
  -H "Content-Type: application/json" \
  -d '{"model": "tts-1", "input": "Hello from FitGuard", "voice": "alloy"}' \
  --output speech.mp3

resp = client.audio.speech.create(
    model="tts-1",
    voice="alloy",
    input="Hello from FitGuard",
)
resp.stream_to_file("speech.mp3")

const resp = await client.audio.speech.create({
  model: "tts-1",
  voice: "alloy",
  input: "Hello from FitGuard",
});
const buffer = Buffer.from(await resp.arrayBuffer());
await fs.promises.writeFile("speech.mp3", buffer);

using System.Net.Http.Json;

var client = new HttpClient { BaseAddress = new Uri("http://localhost:8787/v1/") };
client.DefaultRequestHeaders.Authorization =
    new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", "sk-guard-a1b2c3...");

var payload = new { model = "tts-1", voice = "alloy", input = "Hello from FitGuard" };
var response = await client.PostAsJsonAsync("audio/speech", payload);
await File.WriteAllBytesAsync("speech.mp3", await response.Content.ReadAsByteArrayAsync());

HttpClient client = HttpClient.newHttpClient();
String json = """
    {"model":"tts-1","voice":"alloy","input":"Hello from FitGuard"}
    """;

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("http://localhost:8787/v1/audio/speech"))
    .header("Authorization", "Bearer sk-guard-a1b2c3...")
    .header("Content-Type", "application/json")
    .POST(HttpRequest.BodyPublishers.ofString(json))
    .build();
HttpResponse<byte[]> response = client.send(request, HttpResponse.BodyHandlers.ofByteArray());
Files.write(Path.of("speech.mp3"), response.body());

body, _ := json.Marshal(map[string]any{
    "model": "tts-1",
    "voice": "alloy",
    "input": "Hello from FitGuard",
})
req, _ := http.NewRequest("POST", "http://localhost:8787/v1/audio/speech", bytes.NewReader(body))
req.Header.Set("Authorization", "Bearer sk-guard-a1b2c3...")
req.Header.Set("Content-Type", "application/json")
resp, _ := http.DefaultClient.Do(req)

let client = reqwest::blocking::Client::new();
let resp = client.post("http://localhost:8787/v1/audio/speech")
    .bearer_auth("sk-guard-a1b2c3...")
    .json(&serde_json::json!({
        "model": "tts-1",
        "voice": "alloy",
        "input": "Hello from FitGuard"
    }))
    .send()?;

curl http://localhost:8787/v1/audio/transcriptions \
  -H "Authorization: Bearer sk-guard-a1b2c3..." \
  -F file=@meeting.mp3 \
  -F model=whisper-1

with open("meeting.mp3", "rb") as f:
    resp = client.audio.transcriptions.create(model="whisper-1", file=f)
print(resp.text)

const resp = await client.audio.transcriptions.create({
  model: "whisper-1",
  file: fs.createReadStream("meeting.mp3"),
});
console.log(resp.text);

using var client = new HttpClient { BaseAddress = new Uri("http://localhost:8787/v1/") };
client.DefaultRequestHeaders.Authorization =
    new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", "sk-guard-a1b2c3...");

using var form = new MultipartFormDataContent();
form.Add(new StreamContent(File.OpenRead("meeting.mp3")), "file", "meeting.mp3");
form.Add(new StringContent("whisper-1"), "model");

var response = await client.PostAsync("audio/transcriptions", form);
Console.WriteLine(await response.Content.ReadAsStringAsync());

String boundary = "----FitGuardBoundary";
Path file = Path.of("meeting.mp3");
String body =
    "--" + boundary + "\r\nContent-Disposition: form-data; name=\"model\"\r\n\r\nwhisper-1\r\n" +
    "--" + boundary + "\r\nContent-Disposition: form-data; name=\"file\"; filename=\"meeting.mp3\"\r\n\r\n";

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("http://localhost:8787/v1/audio/transcriptions"))
    .header("Authorization", "Bearer sk-guard-a1b2c3...")
    .header("Content-Type", "multipart/form-data; boundary=" + boundary)
    .POST(HttpRequest.BodyPublishers.ofByteArray(
        buildMultipartBody(body, file, boundary))) // your own multipart helper
    .build();
HttpResponse<String> response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

var buf bytes.Buffer
mw := multipart.NewWriter(&buf)
mw.WriteField("model", "whisper-1")
part, _ := mw.CreateFormFile("file", "meeting.mp3")
f, _ := os.Open("meeting.mp3")
io.Copy(part, f)
mw.Close()

req, _ := http.NewRequest("POST", "http://localhost:8787/v1/audio/transcriptions", &buf)
req.Header.Set("Authorization", "Bearer sk-guard-a1b2c3...")
req.Header.Set("Content-Type", mw.FormDataContentType())
resp, _ := http.DefaultClient.Do(req)

let client = reqwest::blocking::Client::new();
let form = reqwest::blocking::multipart::Form::new()
    .text("model", "whisper-1")
    .file("file", "meeting.mp3")?;
let resp = client.post("http://localhost:8787/v1/audio/transcriptions")
    .bearer_auth("sk-guard-a1b2c3...")
    .multipart(form)
    .send()?;