API Documentation

Quick Start

Get your first AI response in under 5 minutes.

1. Get your API key

Sign up with GitHub OAuth — no email verification, no waiting. Your API key is ready instantly on the Dashboard.

2. Install the OpenAI SDK

Token Hacker is fully OpenAI-compatible. Use any existing OpenAI SDK — Python, Node.js, or any language with an OpenAI client library.

3. Make your first request

Set the base URL to Token Hacker, use your API key, and pick a model. That's it — your existing OpenAI code works unchanged.

Python

from openai import OpenAI

client = OpenAI(
    base_url="https://api.aiapisave.xyz/v1",
    api_key="sk-your-api-key",
)

response = client.chat.completions.create(
    model="openai/gpt-4o-mini",
    messages=[
        {"role": "user", "content": "Hello, world!"}
    ],
)

print(response.choices[0].message.content)

Node.js

import OpenAI from 'openai';

const client = new OpenAI({
  baseURL: 'https://api.aiapisave.xyz/v1',
  apiKey: 'sk-your-api-key',
});

const response = await client.chat.completions.create({
  model: 'openai/gpt-4o-mini',
  messages: [
    { role: 'user', content: 'Hello, world!' }
  ],
});

console.log(response.choices[0].message.content);

cURL

curl https://api.aiapisave.xyz/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer sk-your-api-key" \
  -d '{
    "model": "openai/gpt-4o-mini",
    "messages": [{"role": "user", "content": "Hello, world!"}]
  }'

Streaming (Python)

from openai import OpenAI

client = OpenAI(
    base_url="https://api.aiapisave.xyz/v1",
    api_key="sk-your-api-key",
)

# Enable streaming with stream=True
stream = client.chat.completions.create(
    model="openai/gpt-4o-mini",
    messages=[{"role": "user", "content": "Tell me a short story"}],
    stream=True,
)

# Print each token as it arrives
for chunk in stream:
    if chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="")

Streaming (Node.js)

import OpenAI from 'openai';

const client = new OpenAI({
  baseURL: 'https://api.aiapisave.xyz/v1',
  apiKey: 'sk-your-api-key',
});

const stream = await client.chat.completions.create({
  model: 'openai/gpt-4o-mini',
  messages: [{ role: 'user', content: 'Tell me a short story' }],
  stream: true,
});

// Print each token as it arrives
for await (const chunk of stream) {
  process.stdout.write(chunk.choices[0]?.delta?.content || '');
}

Dashboard →

Authentication

All API requests require authentication via Bearer token in the Authorization header. Keep your API key secure — never expose it in client-side code or public repositories.

Get your API key from the Dashboard.

Model Reference

Token Hacker supports 200+ models across all major providers — OpenAI, Anthropic, Google, DeepSeek, Meta, Mistral, and more. Browse the complete catalog on the Models page.

Model IDs follow the pattern provider/model-name. Use this format in the model parameter of your API requests.

Visit the Models page for pricing, context windows, and capabilities for each model.

Streaming

Stream responses token-by-token for real-time output. All models support Server-Sent Events (SSE) streaming — set stream: true in your request and iterate over the response chunks. Streaming dramatically improves perceived latency for user-facing applications.

Python

from openai import OpenAI

client = OpenAI(
    base_url="https://api.aiapisave.xyz/v1",
    api_key="sk-your-api-key",
)

# Enable streaming
stream = client.chat.completions.create(
    model="openai/gpt-4o-mini",
    messages=[{"role": "user", "content": "Write a haiku about coding"}],
    stream=True,
)

# Collect the full response while printing in real-time
full_response = ""
for chunk in stream:
    delta = chunk.choices[0].delta
    if delta.content:
        print(delta.content, end="", flush=True)
        full_response += delta.content

print()  # final newline

Node.js

import OpenAI from 'openai';

const client = new OpenAI({
  baseURL: 'https://api.aiapisave.xyz/v1',
  apiKey: 'sk-your-api-key',
});

const stream = await client.chat.completions.create({
  model: 'openai/gpt-4o-mini',
  messages: [{ role: 'user', content: 'Write a haiku about coding' }],
  stream: true,
});

// Collect the full response while printing in real-time
let fullResponse = '';
for await (const chunk of stream) {
  const content = chunk.choices[0]?.delta?.content || '';
  process.stdout.write(content);
  fullResponse += content;
}
console.log();  // final newline

Function Calling

Let models call your functions to access external data, APIs, and tools. Token Hacker supports the full OpenAI function calling / tool use API. Define your tools, send them with the request, and the model will return structured function call arguments when needed.

Python

from openai import OpenAI
import json

client = OpenAI(
    base_url="https://api.aiapisave.xyz/v1",
    api_key="sk-your-api-key",
)

# Define a weather function tool
tools = [{
    "type": "function",
    "function": {
        "name": "get_weather",
        "description": "Get the current weather for a city",
        "parameters": {
            "type": "object",
            "properties": {
                "city": {
                    "type": "string",
                    "description": "City name, e.g. San Francisco"
                },
                "unit": {
                    "type": "string",
                    "enum": ["celsius", "fahrenheit"],
                    "description": "Temperature unit"
                }
            },
            "required": ["city"]
        }
    }
}]

# Model decides whether to call the function
response = client.chat.completions.create(
    model="openai/gpt-4o-mini",
    messages=[{"role": "user", "content": "What's the weather in Tokyo?"}],
    tools=tools,
    tool_choice="auto",
)

msg = response.choices[0].message
if msg.tool_calls:
    for tool_call in msg.tool_calls:
        func_name = tool_call.function.name
        func_args = json.loads(tool_call.function.arguments)
        print(f"Calling {func_name} with {func_args}")
        
        # Call your actual function here
        # result = your_weather_function(**func_args)
else:
    print(msg.content)

Rate Limits

Rate limits depend on your account tier and current balance. Standard accounts have the following default limits:

• Requests per minute: 60 RPM
• Tokens per minute: 100K TPM
• Concurrent requests: 10

When a rate limit is exceeded, the API returns HTTP 429 Too Many Requests. Implement exponential backoff with jitter to handle this gracefully. Higher-tier team accounts get increased limits.

import time
import random

def call_with_retry(client, max_retries=5, **kwargs):
    """Call the API with exponential backoff on rate limits."""
    for attempt in range(max_retries):
        try:
            return client.chat.completions.create(**kwargs)
        except Exception as e:
            if "429" in str(e):
                # Exponential backoff with jitter
                delay = (2 ** attempt) + random.uniform(0, 1)
                print(f"Rate limited. Retrying in {delay:.1f}s...")
                time.sleep(delay)
                continue
            raise
    raise Exception(f"Failed after {max_retries} retries")

Error Handling

The API returns standard HTTP status codes. Here are the most common ones and how to handle them:

Frequently Asked Questions