7 uncensored models, for text, search, speech, images and video.

curl http://127.0.0.1:3001/v1/chat/completions \
  -H "Authorization: Bearer $YOURBRAND_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "qwen3.8-27b-abliterated",
    "messages": [{"role":"user","content":"hello"}]
  }'

const res = await fetch("http://127.0.0.1:3001/v1/chat/completions", {
  method: "POST",
  headers: {
    Authorization: `Bearer ${process.env.YOURBRAND_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    model: "qwen3.8-27b-abliterated",
    messages: [{ role: "user", content: "hello" }],
  }),
});
console.log(await res.json());

import os
import requests

res = requests.post(
    "http://127.0.0.1:3001/v1/chat/completions",
    headers={"Authorization": f"Bearer {os.environ['YOURBRAND_KEY']}"},
    json={
        "model": "qwen3.8-27b-abliterated",
        "messages": [{"role": "user", "content": "hello"}],
    },
)
print(res.json())

using System.Net.Http.Json;

var key = Environment.GetEnvironmentVariable("YOURBRAND_KEY");
using var http = new HttpClient();
http.DefaultRequestHeaders.Add("Authorization", $"Bearer {key}");
var res = await http.PostAsJsonAsync("http://127.0.0.1:3001/v1/chat/completions", new
{
    model = "qwen3.8-27b-abliterated",
    messages = new[] { new { role = "user", content = "hello" } },
});
Console.WriteLine(await res.Content.ReadAsStringAsync());

#include <cpr/cpr.h>
#include <cstdlib>
#include <iostream>

int main() {
  std::string key = std::getenv("YOURBRAND_KEY");
  auto res = cpr::Post(
      cpr::Url{"http://127.0.0.1:3001/v1/chat/completions"},
      cpr::Header{{"Authorization", "Bearer " + key}, {"Content-Type", "application/json"}},
      cpr::Body{R"({
        "model": "qwen3.8-27b-abliterated",
        "messages": [{"role":"user","content":"hello"}]
      })"});
  std::cout << res.text << "\n";
}

require "json"
require "net/http"

res = Net::HTTP.post(
  URI("http://127.0.0.1:3001/v1/chat/completions"),
  {
    model: "qwen3.8-27b-abliterated",
    messages: [{ role: "user", content: "hello" }],
  }.to_json,
  "Authorization" => "Bearer #{ENV['YOURBRAND_KEY']}",
  "Content-Type" => "application/json",
)
puts res.body

package main

import (
	"fmt"
	"io"
	"net/http"
	"os"
	"strings"
)

func main() {
	body := `{
	  "model": "qwen3.8-27b-abliterated",
	  "messages": [{"role":"user","content":"hello"}]
	}`
	req, _ := http.NewRequest("POST", "http://127.0.0.1:3001/v1/chat/completions", strings.NewReader(body))
	req.Header.Set("Authorization", "Bearer "+os.Getenv("YOURBRAND_KEY"))
	req.Header.Set("Content-Type", "application/json")
	res, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer res.Body.Close()
	out, _ := io.ReadAll(res.Body)
	fmt.Println(string(out))
}

curl http://127.0.0.1:3001/v1/chat/completions \
  -H "Authorization: Bearer $YOURBRAND_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "llama4.5-70b-abliterated",
    "messages": [{"role":"user","content":"hello"}]
  }'

const res = await fetch("http://127.0.0.1:3001/v1/chat/completions", {
  method: "POST",
  headers: {
    Authorization: `Bearer ${process.env.YOURBRAND_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    model: "llama4.5-70b-abliterated",
    messages: [{ role: "user", content: "hello" }],
  }),
});
console.log(await res.json());

import os
import requests

res = requests.post(
    "http://127.0.0.1:3001/v1/chat/completions",
    headers={"Authorization": f"Bearer {os.environ['YOURBRAND_KEY']}"},
    json={
        "model": "llama4.5-70b-abliterated",
        "messages": [{"role": "user", "content": "hello"}],
    },
)
print(res.json())

using System.Net.Http.Json;

var key = Environment.GetEnvironmentVariable("YOURBRAND_KEY");
using var http = new HttpClient();
http.DefaultRequestHeaders.Add("Authorization", $"Bearer {key}");
var res = await http.PostAsJsonAsync("http://127.0.0.1:3001/v1/chat/completions", new
{
    model = "llama4.5-70b-abliterated",
    messages = new[] { new { role = "user", content = "hello" } },
});
Console.WriteLine(await res.Content.ReadAsStringAsync());

#include <cpr/cpr.h>
#include <cstdlib>
#include <iostream>

int main() {
  std::string key = std::getenv("YOURBRAND_KEY");
  auto res = cpr::Post(
      cpr::Url{"http://127.0.0.1:3001/v1/chat/completions"},
      cpr::Header{{"Authorization", "Bearer " + key}, {"Content-Type", "application/json"}},
      cpr::Body{R"({
        "model": "llama4.5-70b-abliterated",
        "messages": [{"role":"user","content":"hello"}]
      })"});
  std::cout << res.text << "\n";
}

require "json"
require "net/http"

res = Net::HTTP.post(
  URI("http://127.0.0.1:3001/v1/chat/completions"),
  {
    model: "llama4.5-70b-abliterated",
    messages: [{ role: "user", content: "hello" }],
  }.to_json,
  "Authorization" => "Bearer #{ENV['YOURBRAND_KEY']}",
  "Content-Type" => "application/json",
)
puts res.body

package main

import (
	"fmt"
	"io"
	"net/http"
	"os"
	"strings"
)

func main() {
	body := `{
	  "model": "llama4.5-70b-abliterated",
	  "messages": [{"role":"user","content":"hello"}]
	}`
	req, _ := http.NewRequest("POST", "http://127.0.0.1:3001/v1/chat/completions", strings.NewReader(body))
	req.Header.Set("Authorization", "Bearer "+os.Getenv("YOURBRAND_KEY"))
	req.Header.Set("Content-Type", "application/json")
	res, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer res.Body.Close()
	out, _ := io.ReadAll(res.Body)
	fmt.Println(string(out))
}

curl http://127.0.0.1:3001/v1/embeddings \
  -H "Authorization: Bearer $YOURBRAND_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "bge-m4-embed",
    "input": "Where are the servers?"
  }'

const res = await fetch("http://127.0.0.1:3001/v1/embeddings", {
  method: "POST",
  headers: {
    Authorization: `Bearer ${process.env.YOURBRAND_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    model: "bge-m4-embed",
    input: "Where are the servers?",
  }),
});
console.log(await res.json());

import os
import requests

res = requests.post(
    "http://127.0.0.1:3001/v1/embeddings",
    headers={"Authorization": f"Bearer {os.environ['YOURBRAND_KEY']}"},
    json={
        "model": "bge-m4-embed",
        "input": "Where are the servers?",
    },
)
print(res.json())

using System.Net.Http.Json;

var key = Environment.GetEnvironmentVariable("YOURBRAND_KEY");
using var http = new HttpClient();
http.DefaultRequestHeaders.Add("Authorization", $"Bearer {key}");
var res = await http.PostAsJsonAsync("http://127.0.0.1:3001/v1/embeddings", new
{
    model = "bge-m4-embed",
    input = "Where are the servers?",
});
Console.WriteLine(await res.Content.ReadAsStringAsync());

#include <cpr/cpr.h>
#include <cstdlib>
#include <iostream>

int main() {
  std::string key = std::getenv("YOURBRAND_KEY");
  auto res = cpr::Post(
      cpr::Url{"http://127.0.0.1:3001/v1/embeddings"},
      cpr::Header{{"Authorization", "Bearer " + key}, {"Content-Type", "application/json"}},
      cpr::Body{R"({
        "model": "bge-m4-embed",
        "input": "Where are the servers?"
      })"});
  std::cout << res.text << "\n";
}

require "json"
require "net/http"

res = Net::HTTP.post(
  URI("http://127.0.0.1:3001/v1/embeddings"),
  {
    model: "bge-m4-embed",
    input: "Where are the servers?",
  }.to_json,
  "Authorization" => "Bearer #{ENV['YOURBRAND_KEY']}",
  "Content-Type" => "application/json",
)
puts res.body

package main

import (
	"fmt"
	"io"
	"net/http"
	"os"
	"strings"
)

func main() {
	body := `{
	  "model": "bge-m4-embed",
	  "input": "Where are the servers?"
	}`
	req, _ := http.NewRequest("POST", "http://127.0.0.1:3001/v1/embeddings", strings.NewReader(body))
	req.Header.Set("Authorization", "Bearer "+os.Getenv("YOURBRAND_KEY"))
	req.Header.Set("Content-Type", "application/json")
	res, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer res.Body.Close()
	out, _ := io.ReadAll(res.Body)
	fmt.Println(string(out))
}

curl http://127.0.0.1:3001/v1/rerank \
  -H "Authorization: Bearer $YOURBRAND_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "bge-reranker-v3",
    "query": "Where are the servers?",
    "documents": ["The database runs in Quebec.","Slips never expire."]
  }'

const res = await fetch("http://127.0.0.1:3001/v1/rerank", {
  method: "POST",
  headers: {
    Authorization: `Bearer ${process.env.YOURBRAND_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    model: "bge-reranker-v3",
    query: "Where are the servers?",
    documents: ["The database runs in Quebec.", "Slips never expire."],
  }),
});
console.log(await res.json());

import os
import requests

res = requests.post(
    "http://127.0.0.1:3001/v1/rerank",
    headers={"Authorization": f"Bearer {os.environ['YOURBRAND_KEY']}"},
    json={
        "model": "bge-reranker-v3",
        "query": "Where are the servers?",
        "documents": ["The database runs in Quebec.", "Slips never expire."],
    },
)
print(res.json())

using System.Net.Http.Json;

var key = Environment.GetEnvironmentVariable("YOURBRAND_KEY");
using var http = new HttpClient();
http.DefaultRequestHeaders.Add("Authorization", $"Bearer {key}");
var res = await http.PostAsJsonAsync("http://127.0.0.1:3001/v1/rerank", new
{
    model = "bge-reranker-v3",
    query = "Where are the servers?",
    documents = new[] { "The database runs in Quebec.", "Slips never expire." },
});
Console.WriteLine(await res.Content.ReadAsStringAsync());

#include <cpr/cpr.h>
#include <cstdlib>
#include <iostream>

int main() {
  std::string key = std::getenv("YOURBRAND_KEY");
  auto res = cpr::Post(
      cpr::Url{"http://127.0.0.1:3001/v1/rerank"},
      cpr::Header{{"Authorization", "Bearer " + key}, {"Content-Type", "application/json"}},
      cpr::Body{R"({
        "model": "bge-reranker-v3",
        "query": "Where are the servers?",
        "documents": ["The database runs in Quebec.","Slips never expire."]
      })"});
  std::cout << res.text << "\n";
}

require "json"
require "net/http"

res = Net::HTTP.post(
  URI("http://127.0.0.1:3001/v1/rerank"),
  {
    model: "bge-reranker-v3",
    query: "Where are the servers?",
    documents: ["The database runs in Quebec.", "Slips never expire."],
  }.to_json,
  "Authorization" => "Bearer #{ENV['YOURBRAND_KEY']}",
  "Content-Type" => "application/json",
)
puts res.body

package main

import (
	"fmt"
	"io"
	"net/http"
	"os"
	"strings"
)

func main() {
	body := `{
	  "model": "bge-reranker-v3",
	  "query": "Where are the servers?",
	  "documents": ["The database runs in Quebec.","Slips never expire."]
	}`
	req, _ := http.NewRequest("POST", "http://127.0.0.1:3001/v1/rerank", strings.NewReader(body))
	req.Header.Set("Authorization", "Bearer "+os.Getenv("YOURBRAND_KEY"))
	req.Header.Set("Content-Type", "application/json")
	res, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer res.Body.Close()
	out, _ := io.ReadAll(res.Body)
	fmt.Println(string(out))
}

curl http://127.0.0.1:3001/v1/audio/speech \
  -H "Authorization: Bearer $YOURBRAND_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "kokoro-2-tts",
    "voice": "af_sky",
    "input": "Hello from yourbrand."
  }' \
  -o speech.mp3

import { writeFile } from "node:fs/promises";

const res = await fetch("http://127.0.0.1:3001/v1/audio/speech", {
  method: "POST",
  headers: {
    Authorization: `Bearer ${process.env.YOURBRAND_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    model: "kokoro-2-tts",
    voice: "af_sky",
    input: "Hello from yourbrand.",
  }),
});
await writeFile("speech.mp3", Buffer.from(await res.arrayBuffer()));

import os
import requests

res = requests.post(
    "http://127.0.0.1:3001/v1/audio/speech",
    headers={"Authorization": f"Bearer {os.environ['YOURBRAND_KEY']}"},
    json={
        "model": "kokoro-2-tts",
        "voice": "af_sky",
        "input": "Hello from yourbrand.",
    },
)
open("speech.mp3", "wb").write(res.content)

using System.Net.Http.Json;

var key = Environment.GetEnvironmentVariable("YOURBRAND_KEY");
using var http = new HttpClient();
http.DefaultRequestHeaders.Add("Authorization", $"Bearer {key}");
var res = await http.PostAsJsonAsync("http://127.0.0.1:3001/v1/audio/speech", new
{
    model = "kokoro-2-tts",
    voice = "af_sky",
    input = "Hello from yourbrand.",
});
await File.WriteAllBytesAsync("speech.mp3", await res.Content.ReadAsByteArrayAsync());

#include <cpr/cpr.h>
#include <cstdlib>
#include <fstream>

int main() {
  std::string key = std::getenv("YOURBRAND_KEY");
  auto res = cpr::Post(
      cpr::Url{"http://127.0.0.1:3001/v1/audio/speech"},
      cpr::Header{{"Authorization", "Bearer " + key}, {"Content-Type", "application/json"}},
      cpr::Body{R"({
        "model": "kokoro-2-tts",
        "voice": "af_sky",
        "input": "Hello from yourbrand."
      })"});
  std::ofstream("speech.mp3", std::ios::binary) << res.text;
}

require "json"
require "net/http"

res = Net::HTTP.post(
  URI("http://127.0.0.1:3001/v1/audio/speech"),
  {
    model: "kokoro-2-tts",
    voice: "af_sky",
    input: "Hello from yourbrand.",
  }.to_json,
  "Authorization" => "Bearer #{ENV['YOURBRAND_KEY']}",
  "Content-Type" => "application/json",
)
File.binwrite("speech.mp3", res.body)

package main

import (
	"io"
	"net/http"
	"os"
	"strings"
)

func main() {
	body := `{
	  "model": "kokoro-2-tts",
	  "voice": "af_sky",
	  "input": "Hello from yourbrand."
	}`
	req, _ := http.NewRequest("POST", "http://127.0.0.1:3001/v1/audio/speech", strings.NewReader(body))
	req.Header.Set("Authorization", "Bearer "+os.Getenv("YOURBRAND_KEY"))
	req.Header.Set("Content-Type", "application/json")
	res, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer res.Body.Close()
	out, _ := io.ReadAll(res.Body)
	os.WriteFile("speech.mp3", out, 0o644)
}

curl http://127.0.0.1:3001/v1/images/generations \
  -H "Authorization: Bearer $YOURBRAND_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "flux2-dev-uncensored",
    "prompt": "a lighthouse in a storm, oil painting",
    "size": "1024x1024"
  }'

const res = await fetch("http://127.0.0.1:3001/v1/images/generations", {
  method: "POST",
  headers: {
    Authorization: `Bearer ${process.env.YOURBRAND_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    model: "flux2-dev-uncensored",
    prompt: "a lighthouse in a storm, oil painting",
    size: "1024x1024",
  }),
});
console.log(await res.json());

import os
import requests

res = requests.post(
    "http://127.0.0.1:3001/v1/images/generations",
    headers={"Authorization": f"Bearer {os.environ['YOURBRAND_KEY']}"},
    json={
        "model": "flux2-dev-uncensored",
        "prompt": "a lighthouse in a storm, oil painting",
        "size": "1024x1024",
    },
)
print(res.json())

using System.Net.Http.Json;

var key = Environment.GetEnvironmentVariable("YOURBRAND_KEY");
using var http = new HttpClient();
http.DefaultRequestHeaders.Add("Authorization", $"Bearer {key}");
var res = await http.PostAsJsonAsync("http://127.0.0.1:3001/v1/images/generations", new
{
    model = "flux2-dev-uncensored",
    prompt = "a lighthouse in a storm, oil painting",
    size = "1024x1024",
});
Console.WriteLine(await res.Content.ReadAsStringAsync());

#include <cpr/cpr.h>
#include <cstdlib>
#include <iostream>

int main() {
  std::string key = std::getenv("YOURBRAND_KEY");
  auto res = cpr::Post(
      cpr::Url{"http://127.0.0.1:3001/v1/images/generations"},
      cpr::Header{{"Authorization", "Bearer " + key}, {"Content-Type", "application/json"}},
      cpr::Body{R"({
        "model": "flux2-dev-uncensored",
        "prompt": "a lighthouse in a storm, oil painting",
        "size": "1024x1024"
      })"});
  std::cout << res.text << "\n";
}

require "json"
require "net/http"

res = Net::HTTP.post(
  URI("http://127.0.0.1:3001/v1/images/generations"),
  {
    model: "flux2-dev-uncensored",
    prompt: "a lighthouse in a storm, oil painting",
    size: "1024x1024",
  }.to_json,
  "Authorization" => "Bearer #{ENV['YOURBRAND_KEY']}",
  "Content-Type" => "application/json",
)
puts res.body

package main

import (
	"fmt"
	"io"
	"net/http"
	"os"
	"strings"
)

func main() {
	body := `{
	  "model": "flux2-dev-uncensored",
	  "prompt": "a lighthouse in a storm, oil painting",
	  "size": "1024x1024"
	}`
	req, _ := http.NewRequest("POST", "http://127.0.0.1:3001/v1/images/generations", strings.NewReader(body))
	req.Header.Set("Authorization", "Bearer "+os.Getenv("YOURBRAND_KEY"))
	req.Header.Set("Content-Type", "application/json")
	res, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer res.Body.Close()
	out, _ := io.ReadAll(res.Body)
	fmt.Println(string(out))
}

curl http://127.0.0.1:3001/v1/videos \
  -H "Authorization: Bearer $YOURBRAND_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "wan3-14b-video",
    "prompt": "waves breaking on black rocks at dusk",
    "seconds": "4"
  }'

const res = await fetch("http://127.0.0.1:3001/v1/videos", {
  method: "POST",
  headers: {
    Authorization: `Bearer ${process.env.YOURBRAND_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    model: "wan3-14b-video",
    prompt: "waves breaking on black rocks at dusk",
    seconds: "4",
  }),
});
console.log(await res.json());

import os
import requests

res = requests.post(
    "http://127.0.0.1:3001/v1/videos",
    headers={"Authorization": f"Bearer {os.environ['YOURBRAND_KEY']}"},
    json={
        "model": "wan3-14b-video",
        "prompt": "waves breaking on black rocks at dusk",
        "seconds": "4",
    },
)
print(res.json())

using System.Net.Http.Json;

var key = Environment.GetEnvironmentVariable("YOURBRAND_KEY");
using var http = new HttpClient();
http.DefaultRequestHeaders.Add("Authorization", $"Bearer {key}");
var res = await http.PostAsJsonAsync("http://127.0.0.1:3001/v1/videos", new
{
    model = "wan3-14b-video",
    prompt = "waves breaking on black rocks at dusk",
    seconds = "4",
});
Console.WriteLine(await res.Content.ReadAsStringAsync());

#include <cpr/cpr.h>
#include <cstdlib>
#include <iostream>

int main() {
  std::string key = std::getenv("YOURBRAND_KEY");
  auto res = cpr::Post(
      cpr::Url{"http://127.0.0.1:3001/v1/videos"},
      cpr::Header{{"Authorization", "Bearer " + key}, {"Content-Type", "application/json"}},
      cpr::Body{R"({
        "model": "wan3-14b-video",
        "prompt": "waves breaking on black rocks at dusk",
        "seconds": "4"
      })"});
  std::cout << res.text << "\n";
}

require "json"
require "net/http"

res = Net::HTTP.post(
  URI("http://127.0.0.1:3001/v1/videos"),
  {
    model: "wan3-14b-video",
    prompt: "waves breaking on black rocks at dusk",
    seconds: "4",
  }.to_json,
  "Authorization" => "Bearer #{ENV['YOURBRAND_KEY']}",
  "Content-Type" => "application/json",
)
puts res.body

package main

import (
	"fmt"
	"io"
	"net/http"
	"os"
	"strings"
)

func main() {
	body := `{
	  "model": "wan3-14b-video",
	  "prompt": "waves breaking on black rocks at dusk",
	  "seconds": "4"
	}`
	req, _ := http.NewRequest("POST", "http://127.0.0.1:3001/v1/videos", strings.NewReader(body))
	req.Header.Set("Authorization", "Bearer "+os.Getenv("YOURBRAND_KEY"))
	req.Header.Set("Content-Type", "application/json")
	res, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer res.Body.Close()
	out, _ := io.ReadAll(res.Body)
	fmt.Println(string(out))
}