Gigatokens API — quickstart

OpenAI-compatible inference API served from the United Kingdom. Base URL https://api.gigatokens.ai/v1. Zero data retention: prompts and completions are never stored.

Authentication

Send your key as Authorization: Bearer gt-…. Keys are issued in your organisation's console or by your Gigatokens contact.

Chat completions

curl https://api.gigatokens.ai/v1/chat/completions \
  -H "Authorization: Bearer $GIGATOKENS_API_KEY" -H "Content-Type: application/json" \
  -d '{"model":"gigatokens/kimi-k3","messages":[{"role":"user","content":"Hello"}],"stream":true}'

Any OpenAI SDK works by changing the base URL:

from openai import OpenAI
client = OpenAI(base_url="https://api.gigatokens.ai/v1", api_key="gt-...")
r = client.chat.completions.create(model="gigatokens/kimi-k3", messages=[{"role": "user", "content": "Hello"}])
print(r.choices[0].message.content, r.usage)

Supported: streaming (SSE, with a final usage chunk), tools/function calling, JSON mode, /v1/completions, /v1/embeddings. Errors follow the OpenAI {"error": {...}} shape.

Models

Live catalogue: GET /v1/models. Reasoning models spend part of max_tokens on hidden reasoning; use max_tokens ≥ 400 (see recommended_min_max_tokens).

Usage and limits

GET /v1/usage?days=30 returns your key's requests, tokens and cost by model, and month-to-date spend against its budget. Rate limits return 429 with Retry-After; exhausted budgets return 402.

Working with the API

Harnesses and SDKs

Everything below was run end-to-end against this API with the official package, using only the base URL and a key (last verified 2026-09-28). Model ids are examples; any catalogue model works.

OpenAI Python SDK

from openai import OpenAI
client = OpenAI(base_url="https://api.gigatokens.ai/v1", api_key="gt-...")
r = client.chat.completions.create(model="gigatokens/kimi-k3",
        messages=[{"role": "user", "content": "Hello"}], max_tokens=400)
print(r.choices[0].message.content, r.usage)

OpenAI Node SDK

import OpenAI from "openai";
const client = new OpenAI({ baseURL: "https://api.gigatokens.ai/v1", apiKey: process.env.GIGATOKENS_API_KEY });
const r = await client.chat.completions.create({ model: "gigatokens/kimi-k3",
  messages: [{ role: "user", content: "Hello" }], max_tokens: 400 });
console.log(r.choices[0].message.content, r.usage);

LangChain (Python, langchain-openai)

from langchain_openai import ChatOpenAI
llm = ChatOpenAI(model="gigatokens/kimi-k3", base_url="https://api.gigatokens.ai/v1", api_key="gt-...", max_tokens=400)
print(llm.invoke("Hello").content)

LangChain.js (@langchain/openai)

import { ChatOpenAI } from "@langchain/openai";
const llm = new ChatOpenAI({ model: "gigatokens/kimi-k3", apiKey: process.env.GIGATOKENS_API_KEY,
  configuration: { baseURL: "https://api.gigatokens.ai/v1" }, maxTokens: 400 });
console.log((await llm.invoke("Hello")).content);

LlamaIndex (OpenAILike)

from llama_index.llms.openai_like import OpenAILike
llm = OpenAILike(model="gigatokens/kimi-k3", api_base="https://api.gigatokens.ai/v1", api_key="gt-...",
                 is_chat_model=True, max_tokens=400)
print(llm.complete("Hello"))

LiteLLM

Use the openai/ prefix so LiteLLM speaks the OpenAI format to the custom base URL.

import litellm
r = litellm.completion(model="openai/gigatokens/kimi-k3", api_base="https://api.gigatokens.ai/v1", api_key="gt-...",
                       messages=[{"role": "user", "content": "Hello"}], max_tokens=400)
print(r.choices[0].message.content)

Pydantic AI

from pydantic_ai import Agent
from pydantic_ai.models.openai import OpenAIChatModel
from pydantic_ai.providers.openai import OpenAIProvider
model = OpenAIChatModel("gigatokens/kimi-k3", provider=OpenAIProvider(base_url="https://api.gigatokens.ai/v1", api_key="gt-..."))
print(Agent(model).run_sync("Hello").output)

Vercel AI SDK (@ai-sdk/openai-compatible)

import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
import { generateText } from "ai";
const gigatokens = createOpenAICompatible({ name: "gigatokens", baseURL: "https://api.gigatokens.ai/v1", apiKey: process.env.GIGATOKENS_API_KEY });
const { text } = await generateText({ model: gigatokens.chatModel("gigatokens/kimi-k3"), prompt: "Hello", maxOutputTokens: 400 });

OpenAI Agents SDK (Python)

Pass a model object, not a model string: the SDK reads the slash in gigatokens/... as a provider prefix.

from openai import AsyncOpenAI
from agents import Agent, OpenAIChatCompletionsModel, Runner, set_tracing_disabled
client = AsyncOpenAI(base_url="https://api.gigatokens.ai/v1", api_key="gt-...")
set_tracing_disabled(True)   # tracing would call the OpenAI platform
llm = OpenAIChatCompletionsModel(model="gigatokens/kimi-k3", openai_client=client)
agent = Agent(name="assistant", instructions="Answer briefly.", model=llm)
print(Runner.run_sync(agent, "Hello").final_output)

Aider

Aider speaks to custom OpenAI-compatible endpoints through the openai/ model prefix. Aider needs Python 3.10-3.12.

aider --model openai/gigatokens/kimi-k3 \
      --openai-api-base https://api.gigatokens.ai/v1 --openai-api-key gt-...

Desktop and IDE apps

These apps take an OpenAI-compatible base URL and key in their own settings: base URL https://api.gigatokens.ai/v1, your gt-… key, and a model id from the catalogue (gigatokens/kimi-k3 in the examples).

Cursor

Features that Cursor pins to its own models (for example Tab completion) keep using those; chat and composer use the model you added.

1. Cursor Settings → Models. Under OpenAI API Key paste your gt-… key.
2. Turn on Override OpenAI Base URL, enter https://api.gigatokens.ai/v1 and click Verify.
3. Add model → gigatokens/kimi-k3 (or any catalogue id) and select it in Chat / Composer.

Continue (VS Code, JetBrains)

1. Open ~/.continue/config.yaml (Continue → gear icon → Open config) and add the model below.
2. Reload the window and pick Kimi K3 (Gigatokens) in the model dropdown.

name: Gigatokens
version: 0.0.1
schema: v1
models:
  - name: Kimi K3 (Gigatokens)
    provider: openai
    model: gigatokens/kimi-k3
    apiBase: https://api.gigatokens.ai/v1
    apiKey: gt-...
    roles: [chat, edit, apply]

Cline and Roo Code (VS Code)

1. Extension settings → API Provider: OpenAI Compatible.
2. Base URL https://api.gigatokens.ai/v1 · API Key gt-… · Model ID gigatokens/kimi-k3.
3. Leave Azure off and streaming on. If asked for a context window, use the catalogue value (1,048,576 for Kimi K3).

Zed

1. Add the provider to settings.json as below.
2. Agent panel → settings → Gigatokens → paste the gt-… key when prompted.

{
  "language_models": {
    "openai_compatible": {
      "Gigatokens": {
        "api_url": "https://api.gigatokens.ai/v1",
        "available_models": [
          { "name": "gigatokens/kimi-k3", "display_name": "Kimi K3 (Gigatokens)",
            "max_tokens": 1048576, "max_output_tokens": 131072 }
        ]
      }
    }
  },
  "agent": { "default_model": { "provider": "Gigatokens", "model": "gigatokens/kimi-k3" } }
}

Open WebUI

1. Start it with the two environment variables below; the catalogue appears in the model picker.

docker run -d -p 3000:8080 \
  -e OPENAI_API_BASE_URL=https://api.gigatokens.ai/v1 \
  -e OPENAI_API_KEY=gt-... \
  ghcr.io/open-webui/open-webui:main

OpenCode run end-to-end 2026-09-28

1. Add the provider below to ~/.config/opencode/opencode.json (or opencode.json in the project). No key in the file.
2. Store the key: run opencode auth login, choose Other, enter provider id gigatokens, paste your gt-… key. It is saved in ~/.local/share/opencode/auth.json.
3. Run opencode and pick Kimi K3 (Gigatokens), or non-interactively opencode run --model gigatokens/gigatokens/kimi-k3 "…" (provider id, then the model id).
4. Terminal-only alternative to step 2: add "apiKey": "{env:GIGATOKENS_API_KEY}" to options and export the variable in the shell that starts OpenCode.

{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "gigatokens": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "Gigatokens",
      "options": {
        "baseURL": "https://api.gigatokens.ai/v1"
      },
      "models": {
        "gigatokens/kimi-k3": {
          "name": "Kimi K3 (Gigatokens)"
        },
        "gigatokens/glm-5.3-flash": {
          "name": "GLM 5.3 Flash (Gigatokens)"
        }
      }
    }
  },
  "model": "gigatokens/gigatokens/kimi-k3"
}

If it fails

• Error: Missing API key. Pass it as 'Authorization: Bearer gt-...' — OpenCode sent the request without a key: the environment variable did not reach the process (desktop and GUI apps do not inherit a shell export). Use opencode auth login as in step 2.
• Your API key does not have access to the requested model — the key is restricted to other models. Check the key's Models column in the console and use one of those, or create a key with no model restriction.

Aider run end-to-end 2026-09-28

1. Pass the base URL and key on the command line (or set OPENAI_API_BASE / OPENAI_API_KEY) and use the openai/ prefix on the model id.

aider --model openai/gigatokens/kimi-k3 --openai-api-base https://api.gigatokens.ai/v1 --openai-api-key gt-...

Codex CLI and Claude Code use other wire formats (OpenAI Responses API, Anthropic Messages API); support for them is under evaluation.