Documentation

curl https://api.tokenless.store/api/v1/chat/completions \
  -H "Authorization: Bearer $TOKENLESS_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "opus-4.8",
    "messages": [{ "role": "user", "content": "Hello!" }]
  }'

// Run:  npx tsx ask.ts "How many moons does Jupiter have?"
const API_KEY = process.env.TOKENLESS_API_KEY ?? "sk-tk-YOUR_KEY_HERE";
const BASE_URL = "https://api.tokenless.store/api/v1";

// --- set these however you like ---
const MODEL = "opus-4.8";      // any id: fable-5, gpt-5.5, sonnet-5, ...
const REASONING = "";          // "" | low | medium | high | extra | ultra
const prompt = process.argv.slice(2).join(" ") || "Hello!";

const res = await fetch(BASE_URL + "/chat/completions", {
  method: "POST",
  headers: {
    "Authorization": "Bearer " + API_KEY,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    model: MODEL,
    messages: [{ role: "user", content: prompt }],
    ...(REASONING ? { reasoning_effort: REASONING } : {}),
  }),
});

const data = await res.json();
if (!res.ok) throw new Error(data.error?.message ?? ("HTTP " + res.status));
console.log(data.choices[0].message.content);

# Run:  python ask.py "How many moons does Jupiter have?"
import os, sys, json, urllib.request, urllib.error

API_KEY = os.environ.get("TOKENLESS_API_KEY", "sk-tk-YOUR_KEY_HERE")
BASE_URL = "https://api.tokenless.store/api/v1"

# --- set these however you like ---
MODEL = "opus-4.8"        # any id: fable-5, gpt-5.5, sonnet-5, ...
REASONING = ""            # "" | low | medium | high | extra | ultra
prompt = " ".join(sys.argv[1:]) or "Hello!"

body = {"model": MODEL, "messages": [{"role": "user", "content": prompt}]}
if REASONING:
    body["reasoning_effort"] = REASONING

req = urllib.request.Request(
    BASE_URL + "/chat/completions",
    data=json.dumps(body).encode(),
    headers={"Authorization": "Bearer " + API_KEY, "Content-Type": "application/json"},
)
try:
    with urllib.request.urlopen(req) as r:
        print(json.load(r)["choices"][0]["message"]["content"])
except urllib.error.HTTPError as e:
    print("Error:", e.read().decode(), file=sys.stderr)

#!/usr/bin/env bash
# Needs curl + jq.  Run:  ./ask.sh "How many moons does Jupiter have?"
API_KEY="sk-tk-YOUR_KEY_HERE"     # or: API_KEY="$TOKENLESS_API_KEY"
BASE_URL="https://api.tokenless.store/api/v1"

# --- set these however you like ---
MODEL="opus-4.8"                  # any id: fable-5, gpt-5.5, sonnet-5, ...
REASONING=""                      # "" | low | medium | high | extra | ultra
PROMPT="$*"
[ -z "$PROMPT" ] && PROMPT="Hello!"

BODY=$(jq -n --arg m "$MODEL" --arg p "$PROMPT" --arg r "$REASONING" \
  '{model:$m, messages:[{role:"user",content:$p}]} + (if $r=="" then {} else {reasoning_effort:$r} end)')

curl -s "$BASE_URL/chat/completions" \
  -H "Authorization: Bearer $API_KEY" \
  -H "Content-Type: application/json" \
  -d "$BODY" | jq -r '.choices[0].message.content'

Authorization: Bearer sk-tk-xxxxxxxxxxxxxxxxxxxxxxxx

from openai import OpenAI

client = OpenAI(
    base_url="https://api.tokenless.store/api/v1",
    api_key="sk-tk-...",
)

resp = client.chat.completions.create(
    model="opus-4.8",
    messages=[{"role": "user", "content": "Write a haiku about glass."}],
)
print(resp.choices[0].message.content)
print(resp.usage)  # includes prompt/completion tokens and cost

{
  "id": "cmpl_...",
  "object": "chat.completion",
  "created": 1719800000,
  "model": "opus-4.8",
  "choices": [
    {
      "index": 0,
      "message": { "role": "assistant", "content": "Clear panes of morning…" },
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 14, "completion_tokens": 19, "total_tokens": 33,
    "prompt_tokens_details": { "cached_tokens": 0 },
    "cache_creation_input_tokens": 0, "cache_read_input_tokens": 0,
    "cost": 0.000512
  }
}

curl https://api.tokenless.store/api/v1/responses \
  -H "Authorization: Bearer sk-tk-..." \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-5.5",
    "input": "Explain entanglement simply.",
    "reasoning": { "effort": "high" }
  }'

{
  "id": "resp_...",
  "object": "response",
  "created_at": 1719800000,
  "model": "gpt-5.5",
  "status": "completed",
  "output": [
    // a reasoning item appears here only when include_reasoning is set (see below)
    {
      "id": "msg_...", "type": "message", "status": "completed", "role": "assistant",
      "content": [{ "type": "output_text", "text": "Entanglement is…", "annotations": [] }]
    }
  ],
  "output_text": "Entanglement is…",
  "usage": {
    "input_tokens": 12, "input_tokens_details": { "cached_tokens": 0 },
    "output_tokens": 88, "total_tokens": 100,
    "cache_creation_input_tokens": 0, "cache_read_input_tokens": 0,
    "cost": 0.00135
  }
}

curl https://api.tokenless.store/api/v1/messages \
  -H "Authorization: Bearer sk-tk-..." \
  -H "Content-Type: application/json" \
  -d '{
    "model": "opus-4.8",
    "max_tokens": 1024,
    "system": "You are concise.",
    "messages": [{ "role": "user", "content": "Explain entanglement simply." }]
  }'

{
  "id": "msg_...",
  "type": "message",
  "role": "assistant",
  "model": "opus-4.8",
  "content": [
    // { "type": "thinking", "thinking": "…", "signature": "…" }  ← only when thinking is on
    { "type": "text", "text": "Entanglement is…" }
  ],
  "stop_reason": "end_turn",
  "stop_sequence": null,
  "usage": {
    "input_tokens": 16, "output_tokens": 74,
    "cache_creation_input_tokens": 0, "cache_read_input_tokens": 0, "cost": 0.00097
  }
}

from openai import OpenAI

client = OpenAI(
    base_url="https://api.tokenless.store/api/v1",
    api_key="sk-tk-...",
)

tools = [{
    "type": "function",
    "function": {
        "name": "get_weather",
        "description": "Get the current weather for a city",
        "parameters": {
            "type": "object",
            "properties": {"city": {"type": "string"}},
            "required": ["city"],
        },
    },
}]

messages = [{"role": "user", "content": "What's the weather in Paris?"}]

resp = client.chat.completions.create(
    model="opus-4.8",
    messages=messages,
    tools=tools,
    tool_choice="auto",
)

msg = resp.choices[0].message
if msg.tool_calls:                     # finish_reason == "tool_calls"
    call = msg.tool_calls[0]
    result = run_your_tool(call.function.name, call.function.arguments)

    # Send the model's own turn back, then the result keyed by tool_call_id.
    messages.append(msg)
    messages.append({
        "role": "tool",
        "tool_call_id": call.id,
        "content": result,
    })

    final = client.chat.completions.create(
        model="opus-4.8", messages=messages, tools=tools,
    )
    print(final.choices[0].message.content)

{
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": null,
        "tool_calls": [
          {
            "id": "call_abc123",
            "type": "function",
            "function": {
              "name": "get_weather",
              "arguments": "{\"city\":\"Paris\"}"
            }
          }
        ]
      },
      "finish_reason": "tool_calls"
    }
  ]
}

// Messages — pick a level; max_tokens is auto-bumped to fit the budget
{ "model": "opus-4.8", "max_tokens": 2048, "messages": [/* … */],
  "reasoning_effort": "extra" }

// "ultra" — uncapped thinking (bounded only by the model's max output)
{ "model": "opus-4.8", "max_tokens": 2048, "messages": [/* … */],
  "reasoning_effort": "ultra" }

// …or the native Anthropic block, forwarded as-is
{ "model": "opus-4.8", "max_tokens": 8192, "messages": [/* … */],
  "thinking": { "type": "enabled", "budget_tokens": 4096 } }

// Chat Completions / Responses — reasoning for GPT models
{ "model": "gpt-5.5", "messages": [/* … */], "reasoning_effort": "high" }

curl https://api.tokenless.store/api/v1/messages \
  -H "Authorization: Bearer sk-tk-..." \
  -H "Content-Type: application/json" \
  -d '{
    "model": "opus-4.8",
    "max_tokens": 2048,
    "messages": [{ "role": "user", "content": "Prove there are infinitely many primes." }],
    "reasoning_effort": "high",
    "stream": true
  }'
# → content_block (thinking) deltas, then content_block (text) deltas, then message_delta usage

curl https://api.tokenless.store/api/v1/chat/completions \
  -H "Authorization: Bearer sk-tk-..." \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-5.5",
    "messages": [{ "role": "user", "content": "Prove there are infinitely many primes." }],
    "reasoning_effort": "high",
    "include_reasoning": true
  }'

# Non-streaming response carries the reasoning alongside the answer:
# {
#   "choices": [{ "message": {
#     "role": "assistant",
#     "reasoning_content": "…",   ← present when include_reasoning is set
#     "content": "There are infinitely many primes because…"
#   }}], "usage": { … }
# }

const stream = await client.chat.completions.create({
  model: "gpt-5.5",
  messages: [{ role: "user", content: "Stream a story." }],
  stream: true,
  stream_options: { include_usage: true },
});

for await (const chunk of stream) {
  process.stdout.write(chunk.choices[0]?.delta?.content ?? "");
}

{
  "prompt_tokens": 18,
  "completion_tokens": 224,
  "total_tokens": 242,
  "prompt_tokens_details": { "cached_tokens": 0 },
  "cache_creation_input_tokens": 0,
  "cache_read_input_tokens": 0,
  "cost": 0.0028
}