Free Universal AI API. OpenAI-compatible, blazing fast streaming, tool calling, vision, audio transcription, and a terminal sandbox agent. One model everywhere.
https://api.aharbot.qzz.io/v1
| Check | Method | Endpoint |
|---|---|---|
| Health | GET | /health |
| Models | GET | /v1/models |
| Status | GET | /v1/status |
| Chat | POST | /v1/chat/completions |
| Agent | POST | /v1/agent/run |
| Audio | POST | /v1/audio/transcriptions |
One Gemma model handles chat, vision, and tool calling. No provider juggling.
No API key needed. All real keys live inside Railway environment variables only. Fork, deploy, done.
Realtime token-by-token output over Server-Sent Events. Gemma thinking blocks stream as reasoning_content.
Gemma handles OpenAI-style tools natively. Plug your own functions and let the model decide.
Send images as base64 data URIs or public URLs. Same Gemma model understands them — no separate vision model.
AI runs real shell commands, creates files, runs servers, and hands you public download links to anything it built.
Whisper speech-to-text via Groq (whisper-large-v3-turbo). The only part using Groq.
Works directly from browser JavaScript. No proxy needed.
Per-IP, in-memory rate limiting keeps the free tier fair. Default 120 req/min/IP.
Gemma gemma4 via Ollama — chat, vision, and tool calling all in one.
Default model. Chat, vision, tool calling.
Same model, alias kept for clarity. Any request with an image stays on Gemma.
Fast alias. Routes to the same Gemma backend.
Access any Ollama model directly by name.
Chat passthrough. Groq is mainly used for audio transcription.
Always routes to gemma4.
OpenAI-compatible. Copy-paste any example as-is.
curl https://api.aharbot.qzz.io/v1/chat/completions \
-H "Content-Type: application/json" \
-d '{
"model": "ahari",
"stream": true,
"messages": [{"role": "user", "content": "Tell me a fun fact about space"}]
}'
Gemma thinking blocks arrive in the stream as delta.reasoning_content before the final answer.
from openai import OpenAI
client = OpenAI(base_url="https://api.aharbot.qzz.io/v1", api_key="unused")
stream = client.chat.completions.create(
model="ahari",
messages=[{"role": "user", "content": "Write a haiku about APIs"}],
stream=True,
)
for chunk in stream:
print(chunk.choices[0].delta.content or "", end="")
import OpenAI from "openai";
const client = new OpenAI({
baseURL: "https://api.aharbot.qzz.io/v1",
apiKey: "unused",
});
const stream = await client.chat.completions.create({
model: "ahari",
messages: [{ role: "user", content: "Hello!" }],
stream: true,
});
for await (const chunk of stream) {
process.stdout.write(chunk.choices[0]?.delta?.content ?? "");
}
payload, _ := json.Marshal(map[string]any{
"model": "ahari",
"messages": []map[string]string{
{"role": "user", "content": "Say hi!"},
},
})
req, _ := http.NewRequest("POST",
"https://api.aharbot.qzz.io/v1/chat/completions",
bytes.NewReader(payload))
req.Header.Set("Content-Type", "application/json")
resp, err := http.DefaultClient.Do(req)
// ... read resp.Body
const res = await fetch("https://api.aharbot.qzz.io/v1/chat/completions", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({
model: "ahari",
stream: true,
messages: [{ role: "user", content: "Hello!" }],
}),
});
const reader = res.body.getReader();
// decode SSE lines and append chunk.choices[0].delta.content
curl https://api.aharbot.qzz.io/v1/chat/completions \
-H "Content-Type: application/json" \
-d '{
"model": "ahari",
"messages": [{"role": "user", "content": "What is the weather in Paris? Use the weather tool."}],
"tools": [{
"type": "function",
"function": {
"name": "get_weather",
"description": "Get weather for a city",
"parameters": {
"type": "object",
"properties": {"city": {"type": "string"}},
"required": ["city"]
}
}
}]
}'
import base64
from openai import OpenAI
client = OpenAI(base_url="https://api.aharbot.qzz.io/v1", api_key="unused")
b64 = base64.b64encode(open("cat.png", "rb").read()).decode()
resp = client.chat.completions.create(
model="ahari",
messages=[{
"role": "user",
"content": [
{"type": "text", "text": "What is in this image?"},
{"type": "image_url", "image_url": {"url": f"data:image/png;base64,{b64}"}},
],
}],
)
print(resp.choices[0].message.content)
Any request containing an image automatically stays on Gemma — no separate vision model needed.
curl https://api.aharbot.qzz.io/v1/audio/transcriptions \
-F "file=@meeting.m4a" \
-F "model=whisper-large-v3-turbo"
# => {"text": "..."}
from openai import OpenAI
client = OpenAI(base_url="https://api.aharbot.qzz.io/v1", api_key="unused")
with open("meeting.m4a", "rb") as f:
result = client.audio.transcriptions.create(
model="whisper-large-v3-turbo", file=f)
print(result.text)
The AI can run real shell commands, install packages, create files, run servers, and hand you public download links.
curl https://api.aharbot.qzz.io/v1/agent/run \
-H "Content-Type: application/json" \
-d '{
"messages": [{"role": "user", "content":
"Build a tiny HTML page, put a countdown timer in it,
then give me the link to download it"}]
}'
The response is a stream of events:
Set "stream": false to get a single JSON response instead.
| Tool | What it does |
|---|---|
terminal | Run any shell command in the sandbox (with timeout) |
write_file / read_file / list_files | Work with files inside the sandbox |
serve_file | Creates a public download link like /files/hello.py |
web_search | Google Custom Search (needs GOOGLE_API_KEY + GOOGLE_CSE_ID) |
import json, requests
r = requests.post("https://api.aharbot.qzz.io/v1/agent/run", json={
"messages": [{"role": "user", "content":
"Create a python script that prints the first 10 Fibonacci numbers, run it, and give me the download link"}],
}, stream=True)
for line in r.iter_lines():
if line:
print(line.decode())