# TokenRex — complete integration guide for AI coding agents

> Integration reference for AI coding agents: language examples, public endpoints, feature recipes and the current enabled model catalog. Provider-native capabilities are not automatically exposed by this API; follow the compatibility notes and reviewed model references below.

## Rules for the agent
- TokenRex is an OpenAI-compatible API gateway. Use the base URLs and endpoints below exactly.
- TokenRex is a product of Asirex Labs Pvt Ltd. Company website: https://asirex.in. TokenRex service policies and support remain at https://tokenrex.ai.
- Ask the user to configure their TokenRex API key (starts with `sk-tr-`, or `sk-tb-` for older keys) privately as a server-side secret named `TOKENREX_API_KEY`. Never request it in public chat, put it in browser code, or commit it. Replace example placeholders with an environment-variable read in the target language.
- Always send an exact model ID from the list at the end. There is no default model. Only Fast is a separate chat variant. Thinking uses request settings on one model ID; image resolutions and media configurations retain their listed IDs.
- Call the API from server code only (server function, API route or backend). For live voice in the browser, proxy through your server so the key stays hidden.
- Billing is prepaid from the user's TokenRex wallet. HTTP 402 means the wallet needs a top-up.

## Base URLs
| What | URL |
| --- | --- |
| REST API (OpenAI-compatible) | https://tokenrex.ai/api/public/v1 |
| Live voice (WebSocket) | wss://tokenrex.ai/api/public/v1/live |
| Live model list + prices (JSON) | https://tokenrex.ai/api/public/v1/models |
| Wallet balance | https://tokenrex.ai/api/public/v1/balance |
| Health check | https://tokenrex.ai/api/public/v1/health |
| Human docs | https://tokenrex.ai/docs |
| Model pages | https://tokenrex.ai/models/{model-slug} |
| Create API keys | https://tokenrex.ai/keys |
| Top up wallet | https://tokenrex.ai/wallet |
| Coding tool guides (Claude Code, Codex, Cursor…) | https://tokenrex.ai/integrations |
| This guide | https://tokenrex.ai/tokenrex-agent-guide.md |

## Authentication
```
Authorization: Bearer $TOKENREX_API_KEY
```
Works with the official OpenAI SDKs (Python, Node, Go, Rust), LangChain, LlamaIndex, Vercel AI SDK and any tool that accepts a custom `base_url`. Each key can be limited to specific models and given a per-minute spending cap.

## All endpoints
| Endpoint | What it does |
| --- | --- |
| `POST /v1/messages` | Native Claude: streaming, remote MCP, function tools, web fetch, search and caching |
| `POST /v1/responses` | Native GPT Responses: stateless history, reasoning and supported tools |
| `POST /v1/chat/completions` | Chat, streaming, vision and function tools |
| `POST /v1/images/generations` | Image generation |
| `POST /v1/images/edits` | Image editing |
| `POST /v1/audio/speech` | Text-to-speech |
| `POST /v1/audio/transcriptions` | Speech-to-text |
| `POST /v1/music` | Music generation (Lyria 3), MP3 out, billed per track |
| `POST /v1/embeddings` | Vector embeddings |
| `POST /v1/decisions` | Typed decisions (classify, score, route) with probabilities |
| `POST /v1/videos` | Start a video job: Veo, Gemini Omni, Seedance 2.5 or Starlight Fast 2 restoration |
| `GET /v1/videos/{id}` | Poll a video job (free) |
| `GET /v1/videos/{id}/content` | Download a finished video (free) |
| `WSS /v1/live` | GPT Live 1 conversation, TokenRex Voice (TTS Beta) and Transcribe (STT); billed per connected second |
| `GET /v1/models` | List all available models and prices |
| `GET /v1/balance` | Remaining wallet balance (paise) |
| `POST /v1/messages` | Anthropic-style messages for Claude models |
| `POST /v1/completions` | Legacy text completions |
| `GET /v1/health` | Health check |

## Language quickstarts, including Windows
Use PowerShell's Invoke-RestMethod on Windows; the cURL example uses macOS/Linux shell quoting. Modern Windows can also include curl.exe, but PowerShell's curl alias on older versions is not interchangeable with Unix cURL syntax. Dependencies are noted in examples where needed; HTTP-capable languages can all use the same JSON contract. These examples are reference code, not a claim that every SDK has been executed against every model.

### cURL (macOS / Linux)
```bash
curl https://tokenrex.ai/api/public/v1/chat/completions \
  -H "Authorization: Bearer YOUR_TOKENREX_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-6-astra",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

### PowerShell (Windows)
```powershell
# Set TOKENREX_API_KEY privately in your environment first.
$headers = @{ Authorization = "Bearer $env:TOKENREX_API_KEY" }
$body = @{
  model = "gpt-6-astra"
  messages = @(@{ role = "user"; content = "Hello!" })
} | ConvertTo-Json -Depth 10

$response = Invoke-RestMethod -Uri "https://tokenrex.ai/api/public/v1/chat/completions" -Method Post -Headers $headers -ContentType "application/json" -Body $body
$response.choices[0].message.content
```

### Python
```python
from openai import OpenAI

client = OpenAI(
    api_key="YOUR_TOKENREX_API_KEY",
    base_url="https://tokenrex.ai/api/public/v1",
)

resp = client.chat.completions.create(
    model="gpt-6-astra",
    messages=[{"role": "user", "content": "Hi"}],
)
print(resp.choices[0].message.content)
```

### Node.js
```javascript
import OpenAI from "openai";

const client = new OpenAI({
  apiKey: "YOUR_TOKENREX_API_KEY",
  baseURL: "https://tokenrex.ai/api/public/v1",
});

const r = await client.chat.completions.create({
  model: "gpt-6-astra",
  messages: [{ role: "user", content: "Hi" }],
});

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

### TypeScript
```typescript
import OpenAI from "openai";

const client = new OpenAI({
  apiKey: "YOUR_TOKENREX_API_KEY",
  baseURL: "https://tokenrex.ai/api/public/v1",
});

type ChatMsg = { role: "user" | "system" | "assistant"; content: string };
const messages: ChatMsg[] = [{ role: "user", content: "Hi" }];

const r = await client.chat.completions.create({
  model: "gpt-6-astra",
  messages,
});

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

### Fetch
```javascript
const res = await fetch("https://tokenrex.ai/api/public/v1/chat/completions", {
  method: "POST",
  headers: {
    "Authorization": "Bearer YOUR_TOKENREX_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    model: "gpt-6-astra",
    messages: [{ role: "user", content: "Hi" }],
  }),
});
const data = await res.json();
console.log(data.choices[0].message.content);
```

### Go
```go
package main

import (
    "context"
    "fmt"
    openai "github.com/sashabaranov/go-openai"
)

func main() {
    cfg := openai.DefaultConfig("YOUR_TOKENREX_API_KEY")
    cfg.BaseURL = "https://tokenrex.ai/api/public/v1"
    client := openai.NewClientWithConfig(cfg)

    resp, err := client.CreateChatCompletion(context.Background(),
        openai.ChatCompletionRequest{
            Model: "gpt-6-astra",
            Messages: []openai.ChatCompletionMessage{
                {Role: "user", Content: "Hi"},
            },
        },
    )
    if err != nil { panic(err) }
    fmt.Println(resp.Choices[0].Message.Content)
}
```

### Kotlin
```kotlin
import okhttp3.*
import okhttp3.MediaType.Companion.toMediaType
import okhttp3.RequestBody.Companion.toRequestBody

val client = OkHttpClient()
val body = """
{
  "model": "gpt-6-astra",
  "messages": [{"role":"user","content":"Hi"}]
}
""".trimIndent().toRequestBody("application/json".toMediaType())

val request = Request.Builder()
  .url("https://tokenrex.ai/api/public/v1/chat/completions")
  .addHeader("Authorization", "Bearer YOUR_TOKENREX_API_KEY")
  .post(body)
  .build()

client.newCall(request).execute().use { res ->
  println(res.body?.string())
}
```

### Swift
```swift
import Foundation

var req = URLRequest(url: URL(string: "https://tokenrex.ai/api/public/v1/chat/completions")!)
req.httpMethod = "POST"
req.addValue("Bearer YOUR_TOKENREX_API_KEY", forHTTPHeaderField: "Authorization")
req.addValue("application/json", forHTTPHeaderField: "Content-Type")

let payload: [String: Any] = [
  "model": "gpt-6-astra",
  "messages": [["role": "user", "content": "Hi"]]
]
req.httpBody = try JSONSerialization.data(withJSONObject: payload)

let (data, _) = try await URLSession.shared.data(for: req)
print(String(data: data, encoding: .utf8) ?? "")
```

### Java
```java
import java.net.URI;
import java.net.http.*;

var client = HttpClient.newHttpClient();
var body = """
{"model":"gpt-6-astra","messages":[{"role":"user","content":"Hi"}]}
""";

var req = HttpRequest.newBuilder()
    .uri(URI.create("https://tokenrex.ai/api/public/v1/chat/completions"))
    .header("Authorization", "Bearer YOUR_TOKENREX_API_KEY")
    .header("Content-Type", "application/json")
    .POST(HttpRequest.BodyPublishers.ofString(body))
    .build();

var res = client.send(req, HttpResponse.BodyHandlers.ofString());
System.out.println(res.body());
```

### C#
```csharp
using System.Net.Http;
using System.Net.Http.Headers;
using System.Text;

var http = new HttpClient();
http.DefaultRequestHeaders.Authorization =
    new AuthenticationHeaderValue("Bearer", "YOUR_TOKENREX_API_KEY");

var body = new StringContent(
  "{\"model\":\"gpt-6-astra\",\"messages\":[{\"role\":\"user\",\"content\":\"Hi\"}]}",
  Encoding.UTF8, "application/json");

var res = await http.PostAsync("https://tokenrex.ai/api/public/v1/chat/completions", body);
Console.WriteLine(await res.Content.ReadAsStringAsync());
```

### PHP
```php
<?php
$ch = curl_init("https://tokenrex.ai/api/public/v1/chat/completions");
curl_setopt_array($ch, [
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_POST => true,
  CURLOPT_HTTPHEADER => [
    "Authorization: Bearer YOUR_TOKENREX_API_KEY",
    "Content-Type: application/json",
  ],
  CURLOPT_POSTFIELDS => json_encode([
    "model" => "gpt-6-astra",
    "messages" => [["role" => "user", "content" => "Hi"]],
  ]),
]);
echo curl_exec($ch);
```

### Ruby
```ruby
require "net/http"
require "json"
require "uri"

uri = URI("https://tokenrex.ai/api/public/v1/chat/completions")
req = Net::HTTP::Post.new(uri, {
  "Authorization" => "Bearer YOUR_TOKENREX_API_KEY",
  "Content-Type" => "application/json",
})
req.body = { model: "gpt-6-astra",
             messages: [{ role: "user", content: "Hi" }] }.to_json

res = Net::HTTP.start(uri.host, uri.port, use_ssl: true) { |h| h.request(req) }
puts res.body
```

### Rust
```rust
use serde_json::json;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = reqwest::Client::new();
    let res = client
        .post("https://tokenrex.ai/api/public/v1/chat/completions")
        .bearer_auth("YOUR_TOKENREX_API_KEY")
        .json(&json!({
            "model": "gpt-6-astra",
            "messages": [{"role": "user", "content": "Hi"}]
        }))
        .send().await?
        .text().await?;
    println!("{}", res);
    Ok(())
}
```

### Dart
```dart
// dart pub add http
import 'dart:convert';
import 'dart:io';
import 'package:http/http.dart' as http;

Future<void> main() async {
  final response = await http.post(
    Uri.parse("https://tokenrex.ai/api/public/v1/chat/completions"),
    headers: {'Authorization': 'Bearer ${Platform.environment["TOKENREX_API_KEY"]}', 'Content-Type': 'application/json'},
    body: jsonEncode({'model': 'gpt-6-astra', 'messages': [{'role': 'user', 'content': 'Hi'}]}),
  );
  print(response.body);
}
```

### C
```c
// Compile: cc main.c -lcurl -o tokenrex
#include <curl/curl.h>
#include <stdlib.h>
#include <stdio.h>

int main(void) {
  const char *key = getenv("TOKENREX_API_KEY");
  if (!key) return 1;
  char auth[4096];
  snprintf(auth, sizeof(auth), "Authorization: Bearer %s", key);
  curl_global_init(CURL_GLOBAL_DEFAULT);
  CURL *client = curl_easy_init();
  if (!client) return 1;
  struct curl_slist *headers = NULL;
  headers = curl_slist_append(headers, auth);
  headers = curl_slist_append(headers, "Content-Type: application/json");
  curl_easy_setopt(client, CURLOPT_URL, "https://tokenrex.ai/api/public/v1/chat/completions");
  curl_easy_setopt(client, CURLOPT_HTTPHEADER, headers);
  curl_easy_setopt(client, CURLOPT_POSTFIELDS, "{\"model\":\"gpt-6-astra\",\"messages\":[{\"role\":\"user\",\"content\":\"Hi\"}]}");
  CURLcode result = curl_easy_perform(client);
  curl_slist_free_all(headers);
  curl_easy_cleanup(client);
  curl_global_cleanup();
  return result == CURLE_OK ? 0 : 1;
}
```

### C++
```cpp
// Install cpr and nlohmann/json; link cpr::cpr.
#include <cpr/cpr.h>
#include <nlohmann/json.hpp>
#include <cstdlib>
#include <iostream>

int main() {
  const char* key = std::getenv("TOKENREX_API_KEY");
  if (!key) return 1;
  nlohmann::json body = {{"model", "gpt-6-astra"},
    {"messages", {{{"role", "user"}, {"content", "Hi"}}}}};
  auto response = cpr::Post(cpr::Url{"https://tokenrex.ai/api/public/v1/chat/completions"},
    cpr::Bearer{key}, cpr::Header{{"Content-Type", "application/json"}},
    cpr::Body{body.dump()});
  std::cout << response.text;
}
```

### R
```r
# install.packages(c("httr2", "jsonlite"))
library(httr2)
response <- request("https://tokenrex.ai/api/public/v1/chat/completions") |>
  req_auth_bearer_token(Sys.getenv("TOKENREX_API_KEY")) |>
  req_body_json(list(model = "gpt-6-astra", messages = list(list(role = "user", content = "Hi")))) |>
  req_perform()
print(resp_body_json(response))
```

### Perl
```perl
use strict;
use warnings;
use HTTP::Tiny;
use JSON::PP;
my $response = HTTP::Tiny->new->post("https://tokenrex.ai/api/public/v1/chat/completions", {
  headers => { Authorization => "Bearer $ENV{TOKENREX_API_KEY}", "Content-Type" => "application/json" },
  content => encode_json({ model => "gpt-6-astra", messages => [{ role => "user", content => "Hi" }] })
});
print $response->{content};
```

### Elixir
```elixir
# Add {:req, "~> 0.5"} to mix.exs dependencies.
response = Req.post!("https://tokenrex.ai/api/public/v1/chat/completions",
  headers: [{"authorization", "Bearer " <> System.fetch_env!("TOKENREX_API_KEY")}],
  json: %{model: "gpt-6-astra", messages: [%{role: "user", content: "Hi"}]}
)
IO.inspect(response.body)
```

### Julia
```julia
# Install HTTP and JSON3 with Julia's package manager.
using HTTP, JSON3
headers = ["Authorization" => "Bearer " * ENV["TOKENREX_API_KEY"], "Content-Type" => "application/json"]
body = JSON3.write(Dict("model" => "gpt-6-astra", "messages" => [Dict("role" => "user", "content" => "Hi")]))
response = HTTP.post("https://tokenrex.ai/api/public/v1/chat/completions", headers, body)
println(String(response.body))
```

### Lua
```lua
-- Install LuaSec and lua-cjson with LuaRocks.
local https = require("ssl.https")
local ltn12 = require("ltn12")
local json = require("cjson")
local body = json.encode({model = "gpt-6-astra", messages = {{role = "user", content = "Hi"}}})
local result = {}
local _, status = https.request({
  url = "https://tokenrex.ai/api/public/v1/chat/completions", method = "POST",
  headers = { ["Authorization"] = "Bearer " .. assert(os.getenv("TOKENREX_API_KEY")),
    ["Content-Type"] = "application/json", ["Content-Length"] = tostring(#body) },
  source = ltn12.source.string(body), sink = ltn12.sink.table(result)
})
print(status, table.concat(result))
```

### Scala
```scala
// Scala 3 / JDK 17+
import java.net.URI
import java.net.http.{HttpClient, HttpRequest, HttpResponse}

@main def tokenrex(): Unit = {
  val body = """{"model":"gpt-6-astra","messages":[{"role":"user","content":"Hi"}]}"""
  val request = HttpRequest.newBuilder(URI.create("https://tokenrex.ai/api/public/v1/chat/completions"))
    .header("Authorization", "Bearer " + sys.env("TOKENREX_API_KEY"))
    .header("Content-Type", "application/json")
    .POST(HttpRequest.BodyPublishers.ofString(body)).build()
  println(HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString()).body())
}
```

### Clojure
```clojure
;; Add clj-http and cheshire to project dependencies.
(require '[clj-http.client :as http] '[cheshire.core :as json])
(println (:body (http/post "https://tokenrex.ai/api/public/v1/chat/completions"
  {:headers {"Authorization" (str "Bearer " (System/getenv "TOKENREX_API_KEY"))}
   :content-type :json
   :body (json/generate-string {:model "gpt-6-astra" :messages [{:role "user" :content "Hi"}]})})))
```

## Discovery, health and safe integration checklist
1. Request GET https://tokenrex.ai/api/public/v1/health to check service availability.
2. Request GET https://tokenrex.ai/api/public/v1/models with your Bearer key; choose an enabled exact model ID and inspect current prices.
3. Request GET https://tokenrex.ai/api/public/v1/balance with your Bearer key before expensive work.
4. Send a minimal request to the endpoint for that model's category. Validate HTTP status before parsing JSON; speech and video content may be binary.
5. For streaming chat, parse SSE data frames incrementally, stop at [DONE], and retain the final usage event. Abort the connection when the user cancels.
6. For tool calls, validate names and arguments against your allowlist, obtain permission for consequential actions, execute in your own app, then append the assistant tool call and matching tool result before the next turn. TokenRex does not execute your tools.
7. Do not blindly retry charged POST requests. Back off on 429 using the response's retry guidance; report 401/403/402 and invalid input clearly. For video, retain the job ID, poll its status, and fetch /videos/{id}/content only after completion.
8. Tool-specific setup methods and compatibility limits: https://tokenrex.ai/integrations. Native /v1/responses and /v1/messages are listed below; a custom base URL does not imply Batch, Google-native or unrestricted hosted-tool support.

## Pricing, limits and errors
- Every model uses its current TokenRex usage price after the model discount (₹96 = $1). Read the live catalog rather than assuming market and charged prices match. Charges come from the wallet in paise when a request completes.
- Chat and embeddings: per input/output token. OpenAI images: per text-input, image-input and image-output token. Gemini images and music: per image / per track. Video and live voice: per second.
- Charged REST responses expose `x-tokenrex-cost-paise` where applicable. Discovery, polling, failures and WebSocket events do not all use this header. Fractional-paise charges are rounded up; display currency does not change wallet billing.
- Rate limit: the per-minute spending cap set on the key. Over it returns 429 with the seconds to wait. No tokens-per-minute limit.

| Code | Meaning |
| --- | --- |
| 400 | A setting this model does not accept (e.g. an unsupported size or quality) |
| 401 | Invalid or revoked API key |
| 402 | Wallet balance too low — top up on the Wallet page |
| 403 | This key is not allowed to use this model |
| 429 | Per-minute spending cap reached — wait the number of seconds shown |
| 5xx | Upstream provider error — failed requests are not charged |

## Chat models: one model, adjustable thinking
Keep one standard or Fast model ID; thinking is a separate request setting, never a new model. Read thinking_efforts from GET /v1/models. OpenAI Chat Completions uses reasoning_effort; Responses uses reasoning.effort. Max is Responses-only on the seven verified GPT families and unavailable on their Fast versions. Verified Claude families (Sonnet 5, Opus 5, Opus 5.5 and Fable 5.1, standard or Fast) accept max through output_config.effort on Messages; Haiku has no Max. Claude Messages uses thinking.type=adaptive plus output_config.effort; Haiku uses thinking.type=enabled with budget_tokens below max_tokens. Preserve thinking signatures and complete tool/result history. Gemini verified families accept low/medium/high through reasoning_effort on the OpenAI-compatible chat endpoint; do not claim Google-native endpoints or unverified budgets are exposed. Fast uses the exact listed -fast ID and its live rates; thinking never changes the per-token rate, but actual reasoning usage changes the bill. Do not generate -low/-high/-xhigh/-max model IDs for new integrations. Unsupported or conflicting settings return 400; do not silently ignore them.
```jsonc
// OpenAI Chat Completions: keep the model ID unchanged
{ "model": "gpt-6-luna", "reasoning_effort": "high", "stream": true,
  "messages": [{ "role": "user", "content": "Review this design." }] }

// OpenAI Responses: Max on an eligible model, same ID
{ "model": "gpt-6-astra", "reasoning": { "effort": "max", "summary": "auto" },
  "stream": true, "store": false, "input": "Review this design." }

// Claude adaptive thinking: POST /v1/messages (Sonnet 5, Opus 5, Opus 5.5
// and Fable 5.1 accept effort up to "max"; Haiku uses a budget instead)
{ "model": "claude-sonnet-5", "thinking": { "type": "adaptive" },
  "output_config": { "effort": "max" }, "max_tokens": 8192, "stream": true,
  "messages": [{ "role": "user", "content": "Review this design." }] }

// Claude Haiku: native token budget, not adaptive thinking
{ "model": "claude-haiku-4-5", "thinking": { "type": "enabled", "budget_tokens": 4000 },
  "max_tokens": 8192, "stream": true,
  "messages": [{ "role": "user", "content": "Review this design." }] }

// Verified Gemini families: Chat Completions reasoning_effort
{ "model": "gemini-3.8-flash", "reasoning_effort": "low", "stream": true,
  "messages": [{ "role": "user", "content": "Review this design." }] }
```
- Vision: send images inside `messages` as `image_url` parts. PDFs are supported on chat models.
- Your own function `tools` work on supported models. Built-in web search is available on GPT, Claude and Gemini chat models (see Web search below). Other hosted provider tools (code interpreter, file search) are not available.

## Jev Armour (Beta): automatic thinking-level selection
- Add `"armour": true` to `POST /v1/chat/completions` or `POST /v1/responses` (streaming and non-streaming). Off by default.
- Jev (a fast decision model) reads the task and picks the thinking level (low/medium/high/xhigh/max) before your chosen model runs. Send only the model ID — no thinking setting needed.
- Only levels the selected model supports are ever chosen; Max is never auto-picked on Chat Completions for GPT models (use /v1/responses for Max).
- Every response includes an `armour` block: `{ status: "ok", thinking: "high", auto: true, beta: true }`. An explicit `reasoning_effort`/`reasoning.effort` always wins over the automatic pick.
- If Jev is unreachable, the request proceeds at the default level with `armour.status: "unavailable"`; it never silently blocks. Armour checks are free during the beta.
- Use cases: mixed workloads where some messages are trivial and others need deep reasoning — support chats, coding assistants and agent pipelines get per-request thinking without hardcoding a level.
- Jev only judges the task text (newest 8,000 characters); it does not inspect raw images/PDFs, moderate content, rewrite prompts or switch models. Models without adjustable thinking answer directly with no Jev call.
- Full Jev Armour guide: https://tokenrex.ai/features/jev-armour. API details: https://tokenrex.ai/docs#jev-armour.

## Image models: quality, size, resolution
| Model | Quality | Size / resolution | Aspect ratio | Formats | Transparent | Editing | Price (market → TokenRex) |
| --- | --- | --- | --- | --- | --- | --- | --- |
| `gpt-image-2.6-sunburst` | Auto / Low / Medium / High / XHigh / Max | Auto or custom WIDTHxHEIGHT | Raster 1:3 to 3:1 | PNG / JPEG / WebP / animated GIF | Yes | Yes (references, mask or markup) | $5 text in · $8 image in · $30 image out per 1M tokens → $3.50 text in / $21.00 image out / $5.60 image in per 1M tokens |
| `gpt-image-2.6-flare` | Auto / Low / Medium / High / XHigh / Max | Auto or custom WIDTHxHEIGHT | Raster 1:3 to 3:1 | PNG / JPEG / WebP / animated GIF | Yes | Yes (references, mask or markup) | $5 text in · $8 image in · $30 image out per 1M tokens → $3.50 text in / $21.00 image out / $5.60 image in per 1M tokens |
| `gpt-image-2.5-sunburst` | Low / Medium / High / XHigh / Max | Flexible (size param) | Flexible (1:3 to 3:1) | PNG / JPEG / WebP | Yes | Yes (multiple references, mask) | $5 text in · $8 image in · $30 image out per 1M tokens → $3.50 text in / $21.00 image out / $5.60 image in per 1M tokens |
| `gpt-image-2.5-flare` | Low / Medium / High / XHigh / Max | Flexible (size param) | Flexible (1:3 to 3:1) | PNG / JPEG / WebP | Yes | Yes (multiple references, mask) | $5 text in · $8 image in · $30 image out per 1M tokens → $3.50 text in / $21.00 image out / $5.60 image in per 1M tokens |
| `gpt-image-2` | Low / Medium / High | Flexible (size param) | Flexible (1:3 to 3:1) | PNG / JPEG / WebP | No | Yes (multiple references, mask) | $5 text in · $8 image in · $30 image out per 1M tokens → $3.50 text in / $21.00 image out / $5.60 image in per 1M tokens |
| `gpt-image-1-mini` | Low / Medium / High | 1024² / 1024×1536 / 1536×1024 | Limited | PNG / JPEG / WebP | No | Yes | $2 text in · $2.50 image in · $8 image out per 1M tokens → $1.40 text in / $5.60 image out / $1.75 image in per 1M tokens |
| `gemini-3-pro-image` | Fixed | 1K (default) · 2K · 4K versions | 10 ratios (image_config.aspect_ratio) | PNG | No | Yes (multiple references) | $0.134 at 1K/2K · $0.24 at 4K per image → $0.0938 per image |
| `gemini-3.1-flash-image` | Fixed | 1K (default) · 2K · 4K versions | 14 ratios (image_config.aspect_ratio) | PNG | No | Yes (multiple references) | $0.067 at 1K · $0.101 at 2K · $0.151 at 4K per image → $0.047 per image |
| `gemini-3.1-flash-lite-image` | Fixed | 1K only | Default only | PNG / JPEG | No | Yes | $0.0336 per image → $0.0236 per image |

- OpenAI quality: `quality` = `low` | `medium` | `high` (GPT Image 2.5 and 2.6 Flare and Sunburst also `xhigh` | `max`). Lower quality costs far less.
- OpenAI size: `size` such as `1024x1024`, `1536x1024`, `1024x1536`; custom sizes must be multiples of 16.
- Format: `output_format` = `png` | `jpeg` | `webp`, optional `output_compression` 0–100. Transparent: `background: "transparent"` with PNG/WebP (Flare, Sunburst).
- Gemini resolution is picked by model ID: base = 1K, `-2k` = 2K, `-4k` = 4K. Aspect ratio: `"image_config": {"aspect_ratio": "16:9"}`.
- Editing: `POST /v1/images/edits` with the source image.

## GPT Image 2.6: GIF, complexity and markup
- Exact IDs: gpt-image-2.6-flare and gpt-image-2.6-sunburst. Six qualities: auto, low, medium, high, xhigh, max. Complexity low/medium/high is separate; default high; no separate complexity fee.
- output_format: png/jpeg/webp/gif. GIF: frame_count 2–16 (default 9), frame_duration_ms 20–2000 (default 200, rounded to 10ms). Prefer size auto; 1024x1024 frames were refused in TokenRex tests while auto and 768x768 worked. No mask, streaming, partial_images or compression on GIF.
- Multipart edits: original image or ordered image[]; optional matching transparent PNG markup or PNG mask, never both. Preserve the original; follow-up edits resend the previous output and preservation instructions.
- Playground GIF jobs: POST /v1/images/jobs with operation_id UUID and GIF settings, or multipart for editing; returns 202 id. Poll GET /v1/images/jobs?id=ID&model=MODEL_ID. Reopening/polling is free and never regenerates.
- Standard market per 1M: $5 text input, $8 image input, $30 output. Read live discounted TokenRex rates. Official cached $1.25 text / $2 image are reference only: TokenRex cache discounts are not verified; normal input rates apply. No cached output.
- SVG is documented upstream but unavailable through this service. No exact-version independent benchmark scores verified; never inherit 2.5 scores.

## Video models: resolution, duration, quality
| Model | Resolutions | Durations | Notes |
| --- | --- | --- | --- |
| `veo-3.1` | 720p, 1080p, 4k | 4, 6 or 8 s (1080p/4k must be 8 s) | Highest quality |
| `veo-3.1-fast` | 720p, 1080p, 4k | 4, 6 or 8 s (1080p/4k must be 8 s) | Faster, cheaper |
| `veo-3.1-lite` | 720p, 1080p | 4, 6 or 8 s (1080p must be 8 s) | Cheapest Veo; no 4k |
| `gemini-omni-1.1-flash` | 360p, 720p, 1080p, 4k | 3–10 s | Only model with 360p |

- The rules below apply to Veo and Gemini Omni only. `seedance-2.5` and `starlight-fast-2` use the native controls in the next section.
- Body: `model`, `prompt` (required), `duration_seconds`, `resolution` (default 720p), `aspect_ratio` (e.g. `16:9`, `9:16`), `negative_prompt`, `seed`, `generate_audio`, `image` (base64 or data URL for image-to-video).
- Billed per second × resolution multiplier: 360p ×0.4, 720p ×1, 1080p ×1.5, 4k ×2.5. Charged when the job starts; polling is free; failed jobs are not charged.
- Flow: `POST /v1/videos` → poll `GET /v1/videos/{id}` until `status` is `completed` or `failed` → download `GET /v1/videos/{id}/content`.

## Seedance 2.5, Seedream 5 Pro and Starlight Fast 2 (native controls)
These models take their own native controls inside `input` (preferred) or flat beside `model` — never both. Unknown fields are refused with 400 and nothing is charged.

### Create a Seedance 2.5 video — `seedance-2.5` (POST /v1/videos)
- prompt — up to 25,000 characters; optional when reference media is sent (one of them is required).
- duration — whole seconds 4–30, or -1 for Auto. For edits use -1; to extend, describe the continuation and request the new seconds.
- resolution — 480p or 720p (no 1080p). aspect_ratio — 16:9, 4:3, 1:1, 3:4, 9:16, 21:9 or adaptive.
- image (first frame) and last_frame_image (needs image) — public URL or base64 data URL; first/last-frame jobs use the adaptive shape.
- reference_images (≤30, ordered), reference_videos (≤10 public HTTPS URLs, 30 s combined), reference_audios (≤10, 30 s combined).
- generate_audio, watermark — booleans. fps is fixed at 24 and output_format at mp4. seed is accepted but does not guarantee the same video.
- camera_fixed is accepted but has no effect. use_virtual_avatar does not bypass real-person or deepfake rules.

```json
{
  "model": "seedance-2.5",
  "input": {
    "prompt": "A ceramic teacup on a table. Slow cinematic push-in, gentle steam.",
    "duration": 4,
    "resolution": "480p",
    "aspect_ratio": "16:9",
    "generate_audio": true,
    "fps": 24,
    "output_format": "mp4",
    "watermark": false
  },
  "stream": false
}
```
- Pricing: cost = seconds × rate. Requests with reference videos use the reference-video rate instead of (not on top of) the generation rate. Auto length holds 30 seconds and settles on the real length reported.

### Create a Seedream 5 Pro image — `seedream-5-pro` (POST /v1/images/generations)
- prompt — required.
- image — one URL/data URL or an ordered list of 1–10; all are kept in order. Editing requires at least one.
- size — 1K, 2K or WIDTHxHEIGHT (for example 1536x864). watermark — boolean.
- Always one JPEG (n omitted or 1). Not supported: quality, masks, transparency, output format, GIF/SVG, seed, negative prompt.
- POST /v1/images/edits accepts the same JSON or multipart (model, prompt, size, watermark, repeated image[] files).

```json
{
  "model": "seedream-5-pro",
  "input": {
    "prompt": "An editorial tea poster. Exact headline: TIFFIN TEA.",
    "size": "2K",
    "watermark": false
  },
  "stream": false
}
```
- Pricing: cost = $0.045 + $0.03 × reference images (text only $0.045, one reference $0.075, ten $0.345). Same price for 1K and 2K; no token, size or watermark fees.

### Restore a video with Starlight Fast 2 — `starlight-fast-2` (POST /v1/videos)
- All fields are required and must describe the real file: video_uri (public HTTPS), source_container, source_width, source_height, frame_count, frame_rate.
- start_index and end_index — zero-based, inclusive, end ≥ start. Source up to 600 seconds.
- target_resolution — 1920x1080 or 3840x2160 tier; shape and frame rate are kept (768×512 at 8 fps → 1920×1280 or 3240×2160). upscaling_factor — 1 only.
- Restoration only: no prompt, sound, new scenes or frame interpolation.

```json
{
  "model": "starlight-fast-2",
  "input": {
    "video_uri": "https://YOUR_PUBLIC_MEDIA_HOST/source.mp4",
    "source_container": "mp4",
    "source_width": 768,
    "source_height": 512,
    "frame_count": 16,
    "frame_rate": 8,
    "start_index": 0,
    "end_index": 15,
    "target_resolution": "1920x1080",
    "upscaling_factor": 1
  },
  "stream": false
}
```
- Pricing: frames = end_index − start_index + 1; units = ceil(frames ÷ frames per unit); cost = units × $0.12 (300 frames: $0.72 at 1080p, $1.56 at 4K). Units reported by the provider take precedence.

Seedream edit with ordered references:
```json
{
  "model": "seedream-5-pro",
  "input": {
    "prompt": "Keep the layout. Change the headline colour to teal.",
    "image": [
      "https://example.com/poster.jpg",
      "https://example.com/palette.png"
    ],
    "size": "2K",
    "watermark": false
  },
  "stream": false
}
```

### Polling, download and long jobs
```bash
# 1. Check the job (free — polling never charges)
curl https://tokenrex.ai/api/public/v1/videos/VIDEO_ID \
  -H "Authorization: Bearer $TOKENREX_API_KEY"
# → {"id":"video_…","status":"queued|in_progress|completed|failed","progress":40,"created_at":…,"expires_at":…}

# 2. When status is "completed", download the MP4
curl -L -o result.mp4 https://tokenrex.ai/api/public/v1/videos/VIDEO_ID/content \
  -H "Authorization: Bearer $TOKENREX_API_KEY"
```
- Save the returned id as soon as POST /v1/videos answers; the job keeps running if your app or browser closes.
- Poll GET /v1/videos/{id} every 5–30 seconds with the same API key. Seedance usually needs minutes; Starlight restoration can take hours.
- Polling and downloads never charge again — the job is settled once, when it first reports completed or failed.
- Do not resend a create request after a timeout: a second request is a second paid job.

### Errors
- `400 invalid_request_error` — A control is missing, out of range or not supported (unknown fields are refused, never ignored). Nothing is charged.
- `402 insufficient_balance` — Your wallet cannot cover the hold. Nothing is sent to the model.
- `status "failed" (for example moderation_blocked)` — The model refused or could not finish. The hold is released and nothing is charged.
- `409 job_failed on /content` — The job failed, so there is no file to download.
- `410 expired` — The result passed its expires_at time and can no longer be downloaded. Save files before then.
- `502 outcome_unknown` — The connection broke while creating the job, so TokenRex cannot tell whether it started. It is never retried automatically; check your wallet history before sending again.

Market list prices in USD before the TokenRex discount; your wallet is charged in its own currency using TokenRex's standard conversion. A hold is placed before the job starts, settled once when it finishes, and released if it fails. No cache discounts apply.

## GPT Live 1: conversation and TokenRex speech modes
- gpt-live-1-transcribe (STT) and gpt-live-1-voice (TTS, Beta) are TokenRex-modified instruction-based modes of the main GPT Live 1, not separately trained OpenAI models. Only Voice is labelled Beta.
- Use /v1/live?model=EXACT_ID, not /audio/speech or /audio/transcriptions. Mute all playback for Transcribe, read session.input_transcript.delta, and expose attempted output. Voice receives audio without a microphone and accepts tokenrex.speak after session.started. Exact reading and model silence are not guaranteed.
- All connected time including silence and waiting is billed. Close explicitly; never auto-reconnect or replay. Keep final usage. Same Live rate, not character billing or a cheaper standalone STT rate.
- gpt-live-1: $0.00058 per second; $0.035 per minute equivalent; 15s minimum ($0.00875). https://tokenrex.ai/models/gpt-live-1
- gpt-live-1-transcribe: $0.00058 per second; $0.035 per minute equivalent; 15s minimum ($0.00875). https://tokenrex.ai/models/gpt-live-1-transcribe
- gpt-live-1-voice: $0.00058 per second; $0.035 per minute equivalent; 15s minimum ($0.00875). https://tokenrex.ai/models/gpt-live-1-voice

### gpt-live-1-transcribe connection
```javascript
// Run only after the user explicitly clicks Start.
// Your server must proxy this connection and keep TOKENREX_API_KEY private.
// Upstream: wss://tokenrex.ai/api/public/v1/live?model=gpt-live-1-transcribe
const ws = new WebSocket("wss://YOUR_APP_HOST/live?model=gpt-live-1-transcribe");
const pc = new RTCPeerConnection();
pc.createDataChannel("oai-events");
const mic = await navigator.mediaDevices.getUserMedia({ audio: true });
mic.getTracks().forEach(track => pc.addTrack(track, mic));
// Do not attach incoming audio to a speaker: this mode is transcription-only.
pc.ontrack = () => {};
await pc.setLocalDescription(await pc.createOffer());
await new Promise(resolve => pc.iceGatheringState === "complete" ? resolve() :
  pc.addEventListener("icegatheringstatechange", () => {
    if (pc.iceGatheringState === "complete") resolve();
  }));
await new Promise((resolve, reject) => {
  if (ws.readyState === WebSocket.OPEN) resolve();
  else { ws.onopen = resolve; ws.onerror = reject; }
});
let heartbeat;
ws.onmessage = async ({ data }) => {
  const event = JSON.parse(data);
  if (event.type === "gateway.session.created") {
    await pc.setRemoteDescription({ type: "answer", sdp: event.transport.sdp });
    heartbeat = setInterval(() => ws.send(JSON.stringify({ type: "gateway.heartbeat" })), 1000);
  }
  if (event.type === "session.input_transcript.delta") console.log(event.delta);
  // Expose attempted output as a warning; instructions cannot guarantee silence.
  if (event.type === "session.output_transcript.delta") console.warn("Unexpected output", event.delta);
  if (event.type === "session.usage.updated") console.log("Billed seconds", event.usage.seconds);
  if (event.type === "tokenrex.error") console.error(event.error.message);
};
ws.send(JSON.stringify({
  type: "session.start",
  session: { audio: { output: { voice: "marin" } } },
  tools: [], transport: { type: "webrtc", sdp: pc.localDescription.sdp },
}));

function stop() {
  clearInterval(heartbeat);
  ws.send(JSON.stringify({ type: "session.close" }));
  mic.getTracks().forEach(track => track.stop());
  pc.close();
  // Keep the socket until the final usage event; never reconnect automatically.
}
```

### gpt-live-1-voice connection
```javascript
// Run only after the user explicitly clicks Start.
// Your server must proxy this connection and keep TOKENREX_API_KEY private.
// Upstream: wss://tokenrex.ai/api/public/v1/live?model=gpt-live-1-voice
const ws = new WebSocket("wss://YOUR_APP_HOST/live?model=gpt-live-1-voice");
const pc = new RTCPeerConnection();
pc.createDataChannel("oai-events");
// Receive audio only: do not capture a microphone for text reading.
pc.addTransceiver("audio", { direction: "recvonly" });
const audio = new Audio();
audio.autoplay = true;
pc.ontrack = (event) => {
  audio.srcObject = event.streams[0];
  audio.play().catch(() => showEnableAudio(() => audio.play()));
}; // showEnableAudio renders your explicit playback-unlock button.
await pc.setLocalDescription(await pc.createOffer());
await new Promise(resolve => pc.iceGatheringState === "complete" ? resolve() :
  pc.addEventListener("icegatheringstatechange", () => {
    if (pc.iceGatheringState === "complete") resolve();
  }));
await new Promise((resolve, reject) => {
  if (ws.readyState === WebSocket.OPEN) resolve();
  else { ws.onopen = resolve; ws.onerror = reject; }
});
let heartbeat;
ws.onmessage = async ({ data }) => {
  const event = JSON.parse(data);
  if (event.type === "gateway.session.created") {
    await pc.setRemoteDescription({ type: "answer", sdp: event.transport.sdp });
    heartbeat = setInterval(() => ws.send(JSON.stringify({ type: "gateway.heartbeat" })), 1000);
  }
  // Call speakText from your Send button after session.started.
  if (event.type === "session.output_transcript.delta") console.log(event.delta);
  if (event.type === "session.usage.updated") console.log("Billed seconds", event.usage.seconds);
  if (event.type === "tokenrex.error") console.error(event.error.message);
};
ws.send(JSON.stringify({
  type: "session.start",
  session: { audio: { output: { voice: "marin" } } },
  tools: [], transport: { type: "webrtc", sdp: pc.localDescription.sdp },
}));
function speakText(text) {
  // 1–1,500 characters; send only on explicit action, not automatic retries.
  ws.send(JSON.stringify({ type: "tokenrex.speak", text }));
}
function stop() {
  clearInterval(heartbeat);
  ws.send(JSON.stringify({ type: "session.close" }));
  audio.pause();
  pc.close();
  // Keep the socket until the final usage event; never reconnect automatically.
}
```
- Model `gpt-live-1`, audio only (use a chat model for images/vision). Full-duplex: listens and speaks at once, handles interruptions.
- Connect to `wss://tokenrex.ai/api/public/v1/live`, send `session.start` with instructions, voice, your tools and a WebRTC offer; send `gateway.heartbeat` every second (the call ends after 5 s without one).
- Voice is billed per second. Tools are defined and executed by your app (`tokenrex.tool.request` → `tokenrex.tool.result`).
- Full example in the Live voice section below, and all voices at https://tokenrex.ai/models/gpt-live-1

## Web search (GPT, Claude, Gemini)
- Turn on the provider's built-in web search per request. It is off unless you ask for it. Jev and media models cannot search.
- `POST /v1/chat/completions`: add `"web_search_options": {}` (optional `"max_uses"` 1–10, default 5) or a tool `{"type":"web_search"}`. GPT and Claude responses report `usage.web_search_requests`.
- `POST /v1/messages` (Claude): add the tool `{"type":"web_search_20250305","name":"web_search","max_uses":5}`; max_uses is capped at 10. Usage reports `server_tool_use.web_search_requests`.
| Provider | Price per search | How searches are counted |
| --- | --- | --- |
| GPT (OpenAI) | $7 per 1,000 searches (30% off the $10 market rate) | Each web search call the model makes is billed, as reported by OpenAI. |
| Claude (Anthropic) | $7 per 1,000 searches (30% off the $10 market rate) | Each web search Claude runs is billed, as reported by Anthropic. |
| Gemini (Google) | $9.8 per 1,000 searches (30% off the $14 market rate) | Gemini does not report its search count, so each request with search turned on is billed as one search. |
- Normal token charges also apply. Search results are added to the input, often 8K–16K input tokens per searched GPT or Claude request, billed at the model's input rate. Gemini searches are billed from the first one; no free monthly allowance applies.

```bash
curl https://tokenrex.ai/api/public/v1/chat/completions -H "Authorization: Bearer $TOKENREX_API_KEY" -H "Content-Type: application/json" -d '{
  "model": "gpt-6-luna",
  "web_search_options": {"max_uses": 3},
  "messages": [{"role":"user","content":"What changed in the latest Gemini API release? Cite sources."}]
}'
```

## Advanced options (JSON, sampling, Claude extras, Responses, media)
- Chat Completions accepts `response_format` (`json_object` or strict `json_schema`) on GPT, Gemini and Claude, plus `temperature`, `top_p`, `stop`, `seed`, `n`, `logprobs`, `top_logprobs`, `frequency_penalty`, `presence_penalty`, `parallel_tool_calls`, `prompt_cache_key` and a specific `tool_choice` ({"type":"function","function":{"name":"..."}}). A model that does not accept a setting (for example GPT-6 Astra and `temperature`) returns a clear 400; nothing is silently dropped. GPT requests served via Responses (or with web search) reject `stop`, `seed`, `n`>1, `logprobs` and penalties with 400.
- More controls: embeddings `dimensions`/`encoding_format`; transcription `language`, `prompt`, `response_format`, `timestamp_granularities[]`; OpenAI speech `speed`, `instructions`, `response_format`; OpenAI image-edit PNG `mask`; Claude document `citations`; `/v1/responses` `prompt_cache_key`. Unsupported values return the model's 400.
- Claude native Messages features, model restrictions and MCP costs are detailed below. Do not interpret an accepted beta header as universal model eligibility.
- `POST /v1/responses`: OpenAI Responses API for GPT models (Codex-style tools). Send `model`, `input`, `instructions`, `tools`, `tool_choice`, `reasoning`, `max_output_tokens`, `stream`. Storage is off: resend history instead of `previous_response_id`. Same wallet billing as chat.
- Gemini Omni video: `images` (up to 10 reference images), `video` (base64 or data URL) with `task: "edit"` (duration must equal the clip, 0.1s precision) or `task: "extend"` (billed for new seconds only). Omni does not accept `negative_prompt`, `seed` or `generate_audio` - describe them in the prompt.
- Gemini text-to-speech: all 30 Gemini voices (Zephyr, Puck, Charon, Kore ... Sulafat). An unknown voice returns a 400 with the full list.
- Music: lyrics and wanted length go inside `input`; separate `lyrics`/`duration` fields return a 400. Image models: `seed`, `negative_prompt` and streamed partial images are not available yet (clear 400).

## Prompt caching: input, writes and output
- Eligible repeated prefixes may be cached; a cache hit is not guaranteed. Minimum prefix length and cache lifetime vary by model. Keep stable instructions/documents first and the changing question last.
- OpenAI and Gemini use eligible prompt prefixes automatically. Claude /v1/chat/completions requests get cache markers added automatically; native /v1/messages requests should include their own cache_control blocks.
| Token type | Billing |
| --- | --- |
| Fresh input | Normal input rate |
| Cached input | The exact model’s listed cached-input rate for gateway-reported cache reads; normal input rate if no separate rate is listed |
| Cache write | The listed write rate for gateway-reported cache creation; otherwise no separate write fee |
| Cached output | Not offered; generated output is billed at the standard output rate |
- Read actual usage: chat usage.prompt_tokens_details.cached_tokens; Responses usage.input_tokens_details.cached_tokens; Claude usage.cache_read_input_tokens and usage.cache_creation_input_tokens. Do not assume a cache hit based on repeated text alone.
- Chat total input includes cached input; do not add cached tokens to prompt_tokens again. Native Claude input_tokens, cache reads and cache creation are separate input categories.
- Streaming chat requests: add stream_options: { include_usage: true } to inspect the final usage event where supported.

### Native Claude cache example
```bash
curl https://tokenrex.ai/api/public/v1/messages -H "Authorization: Bearer $TOKENREX_API_KEY" -H "Content-Type: application/json" -d '{
  "model": "claude-fable-5-1", "max_tokens": 1024,
  "system": [{"type":"text","text":"Your long reusable instructions and reference document…","cache_control":{"type":"ephemeral"}}],
  "messages": [{"role":"user","content":"Answer this new question using the reference."}]
}'
```
The short placeholder above illustrates request structure only; it is not long enough to guarantee caching. Resend the same eligible prefix with a different final question and inspect actual usage.
Full caching reference and live per-model rates: https://tokenrex.ai/docs#prompt-caching

## GPT-6 Astra Fast
- Only Fast is a separate chat model ID; reasoning is a request setting. Select only versions listed in the enabled catalog below; use their live prices rather than assuming every family supports the same suffixes. Fast billing follows the serving tier actually used.
- Billing follows the tier actually served: if a reply is served on standard (for example tool calls, which need the Responses path), you pay the normal Astra price.

## Every feature with code

### Native Claude compatibility and costs
| Feature | Usage and restrictions |
| --- | --- |
| Remote MCP | Native /v1/messages: mcp_servers plus mcp_toolset. Supply your own remote HTTPS server and its authorization; local stdio servers cannot be reached directly. |
| Custom function tools | Define name, description and input_schema. Your app validates and executes tool_use, then returns matching tool_result blocks. |
| Web search | Add a web_search tool; max_uses is capped at 10. Actual searches are billed at $10 per 1,000 at market rate, less the current TokenRex discount, plus model tokens. |
| Web fetch | Add web_fetch_20250910. TokenRex adds no separate fetch fee; fetched content uses input tokens. |
| Images and PDFs | Use native image/document content blocks with URL or base64 sources on eligible models. These are inputs, not generated images or files. |
| Thinking and Fast | Keep one standard or Fast model ID. Native adaptive thinking uses thinking.type=adaptive and output_config.effort; Sonnet 5, Opus 5, Opus 5.5 and Fable 5.1 (standard or Fast) accept effort max, while Haiku uses thinking.type=enabled with budget_tokens below max_tokens and has no Max. Fast alone is a separate listed model. Fable 5.1 and Opus 5.5 accept only auto tool choice. |
| Structured output | Use output_config.format with type json_schema and a schema on eligible models. Sampling and thinking options remain model-specific. |
| Compaction | Native context_management.edits with type compact_20260112 and compact-2026-01-12 beta. Eligibility is model-specific; preserve returned conversation blocks. |
| Long context | context-1m-2025-08-07 is an accepted beta header, not a promise that every Claude model has 1M context. Check exact-model limits and current availability. |
| US serving | inference_geo accepts us or global. Only reported US serving for Sonnet 5 and Opus 5/5.5 applies the 1.1× token factor; Haiku has no verified US premium. |
| Fast mode | Opus 5 and Opus 5.5 accept Anthropic's own fast switch: keep the normal model id, send speed: "fast" and the anthropic-beta header fast-mode-2026-02-01. It bills exactly like the separate -fast id (for example claude-opus-5-5-fast); replies not served fast bill at the standard price. Without the switch the model stays standard. |
| Prompt caching | Mark stable blocks with cache_control. Read live exact-model read/write rates; ttl: 1h uses the listed 1-hour write rate (2× normal input), not the 5-minute rate. |
| Not included | No hosted file search, computer use or unrestricted code execution. Remote MCP in the API is not a Playground connection manager or a TokenRex MCP server. |

MCP has no additional TokenRex connector fee, but tool definitions, tool results and model output consume tokens. The remote service may charge separately. Web search adds its actual search fee; web fetch does not add a search fee. Cache reads and writes use the exact model’s live rates; cached output is not offered. Fast and reported US serving can change token costs. Wallet charges are rounded up to whole paise; repeated model/tool rounds are separate billable requests.

**Copy for AI — Claude implementation checklist**
Implement a server-side Claude integration using TokenRex at https://tokenrex.ai/api/public/v1/messages. Read TOKENREX_API_KEY from a private environment variable and choose an enabled exact short Claude model ID from GET https://tokenrex.ai/api/public/v1/models. Never put credentials in browser code or prompts.
For remote MCP, ask for the user's actual HTTPS MCP server URL and authorize that service with least-privilege credentials. Never invent a server URL or reuse a TokenRex key as the remote service token. Send mcp_servers [{type:"url",name:"workspace",url:configuredUrl,authorization_token:remoteToken}] and tools [{type:"mcp_toolset",mcp_server_name:"workspace",default_config:{enabled:false},configs:{approved_read_tool:{enabled:true}}}]. Use anthropic-beta: mcp-client-2025-11-20. Replace approved_read_tool with a real tool name verified from that server; allowlist read tools first and require confirmation for sensitive actions. This API flow is not a Playground connection manager.
Use stream:true and parse Messages SSE incrementally through message_stop, including text, thinking and tool events. Preserve assistant blocks and thinking signatures verbatim. Custom tool_use needs app execution and a matching tool_result; remote MCP is provider-executed and its result blocks must be preserved, not executed twice. Honor cancellation and show safe upstream errors; do not retry denials/refusals or insufficient-credit failures. Back off with bounded attempts only for 429/transient 5xx.
Use native image/document blocks for images/PDFs, output_config.format for supported JSON schemas, thinking:{type:"adaptive"} with output_config.effort on eligible Claude models (Sonnet 5, Opus 5, Opus 5.5 and Fable 5.1, standard or Fast, accept effort values up to max; Haiku has no Max), or thinking:{type:"enabled",budget_tokens:4000} with max_tokens:8192 on Haiku. Increase/decrease the effort or budget without changing the model ID. Only Fast is a separate model ID. Use auto tool choice for Fable 5.1 and Opus 5.5. Check exact-model limits before enabling long-context or compaction. Retain complete supported conversation history; do not claim unsupported hosted tools work.
Budget with live model rates and actual usage: input_tokens, output_tokens, cache_read_input_tokens, cache_creation_input_tokens and cache_creation.ephemeral_1h_input_tokens. Native input categories are separate; do not double-count them. Use server_tool_use.web_search_requests for search fees, $10/1,000 Claude searches plus tokens. MCP has no additional TokenRex connector fee, but tool definitions, tool results and model output consume tokens. The remote service may charge separately. Web search adds its actual search fee; web fetch does not add a search fee. Cache reads and writes use the exact model’s live rates; cached output is not offered. Fast and reported US serving can change token costs. Wallet charges are rounded up to whole paise; repeated model/tool rounds are separate billable requests.
Verify the chosen model and the authorized remote MCP server with a real read-only request before claiming success. Report unverified or blocked capabilities honestly.

### Claude & remote MCP
Connect an authorized remote MCP service through native Claude Messages. Examples need your real HTTPS server, its credentials and a verified read-only tool name. Availability depends on the selected model and remote service; no live MCP connection is claimed by these examples.

Suggested models: `claude-sonnet-5`, `claude-opus-5-5`, `claude-fable-5-1`, `claude-haiku-4-5`

**Server JavaScript**
```javascript
const body = {
  "model": "claude-sonnet-5",
  "max_tokens": 2048,
  "stream": true,
  "messages": [
    {
      "role": "user",
      "content": "Use the approved read-only tool to summarize my project. Cite the records you used."
    }
  ],
  "mcp_servers": [
    {
      "type": "url",
      "name": "workspace",
      "url": "YOUR_REMOTE_HTTPS_MCP_URL",
      "authorization_token": "YOUR_REMOTE_SERVICE_TOKEN"
    }
  ],
  "tools": [
    {
      "type": "mcp_toolset",
      "mcp_server_name": "workspace",
      "default_config": {
        "enabled": false
      },
      "configs": {
        "approved_read_tool": {
          "enabled": true
        }
      }
    }
  ]
};
body.mcp_servers[0].url = process.env.REMOTE_MCP_URL;
body.mcp_servers[0].authorization_token = process.env.REMOTE_MCP_TOKEN;
// Replace approved_read_tool with a real tool from your server.
const response = await fetch("https://tokenrex.ai/api/public/v1/messages", {
  method: "POST",
  headers: { Authorization: `Bearer ${process.env.TOKENREX_API_KEY}`,
    "Content-Type": "application/json", "anthropic-beta": "mcp-client-2025-11-20" },
  body: JSON.stringify(body),
});
if (!response.ok) throw new Error(await response.text());
// Forward this SSE body to your streaming parser; read until message_stop.
for await (const chunk of response.body) process.stdout.write(chunk);
```

**Windows PowerShell**
```powershell
$body = @'
{
  "model": "claude-sonnet-5",
  "max_tokens": 2048,
  "stream": true,
  "messages": [
    {
      "role": "user",
      "content": "Use the approved read-only tool to summarize my project. Cite the records you used."
    }
  ],
  "mcp_servers": [
    {
      "type": "url",
      "name": "workspace",
      "url": "YOUR_REMOTE_HTTPS_MCP_URL",
      "authorization_token": "YOUR_REMOTE_SERVICE_TOKEN"
    }
  ],
  "tools": [
    {
      "type": "mcp_toolset",
      "mcp_server_name": "workspace",
      "default_config": {
        "enabled": false
      },
      "configs": {
        "approved_read_tool": {
          "enabled": true
        }
      }
    }
  ]
}
'@ | ConvertFrom-Json
$body.mcp_servers[0].url = $env:REMOTE_MCP_URL
$body.mcp_servers[0].authorization_token = $env:REMOTE_MCP_TOKEN
# Replace approved_read_tool with a verified read-only tool name.
$path = Join-Path ([IO.Path]::GetTempPath()) ([IO.Path]::GetRandomFileName())
try {
  [IO.File]::WriteAllText($path, ($body | ConvertTo-Json -Depth 20))
  curl.exe -N "https://tokenrex.ai/api/public/v1/messages" -H "Authorization: Bearer $env:TOKENREX_API_KEY" -H "Content-Type: application/json" -H "anthropic-beta: mcp-client-2025-11-20" --data-binary "@$path"
} finally { Remove-Item $path -ErrorAction SilentlyContinue }
```

### Simple chat completion
Basic Q&A / assistant reply — the most common call. Works with every GPT / Gemini text model.

Suggested models: `gpt-5.5`, `gpt-5.4-mini`, `gemini-3.6-flash`, `gemini-3.1-pro-preview`

**cURL**
```bash
curl https://tokenrex.ai/api/public/v1/chat/completions \
  -H "Authorization: Bearer YOUR_TOKENREX_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-6-astra",
    "messages": [
      {"role": "system", "content": "You are a helpful assistant."},
      {"role": "user",   "content": "Explain quantum computing in 2 lines for a 12-year-old."}
    ]
  }'
```

**Python**
```python
from openai import OpenAI

client = OpenAI(api_key="YOUR_TOKENREX_API_KEY", base_url="https://tokenrex.ai/api/public/v1")

r = client.chat.completions.create(
    model="gpt-6-astra",
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user",   "content": "Explain quantum computing in 2 lines for a 12-year-old."},
    ],
)
print(r.choices[0].message.content)
```

**Node.js**
```javascript
import OpenAI from "openai";

const client = new OpenAI({ apiKey: "YOUR_TOKENREX_API_KEY", baseURL: "https://tokenrex.ai/api/public/v1" });

const r = await client.chat.completions.create({
  model: "gpt-6-astra",
  messages: [
    { role: "system", content: "You are a helpful assistant." },
    { role: "user",   content: "Explain quantum computing in 2 lines for a 12-year-old." },
  ],
});
console.log(r.choices[0].message.content);
```

### Live streaming (token-by-token)
Type-writer effect — perfect for chatbots. Set `stream: true` and read the SSE data frames.

Suggested models: `gpt-5.5`, `gpt-5.4-mini`, `gemini-3.6-flash`

**Python**
```python
from openai import OpenAI

client = OpenAI(api_key="YOUR_TOKENREX_API_KEY", base_url="https://tokenrex.ai/api/public/v1")

with client.chat.completions.stream(
    model="gpt-6-astra",
    messages=[{"role": "user", "content": "Write a short poem about the ocean."}],
) as stream:
    for event in stream:
        if event.type == "content.delta":
            print(event.delta, end="", flush=True)
```

**Node.js**
```javascript
import OpenAI from "openai";

const client = new OpenAI({ apiKey: "YOUR_TOKENREX_API_KEY", baseURL: "https://tokenrex.ai/api/public/v1" });

const stream = await client.chat.completions.create({
  model: "gpt-6-astra",
  stream: true,
  messages: [{ role: "user", content: "Write a short poem about the ocean." }],
});

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

**cURL**
```bash
curl -N https://tokenrex.ai/api/public/v1/chat/completions \
  -H "Authorization: Bearer YOUR_TOKENREX_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-6-astra",
    "stream": true,
    "messages": [{"role":"user","content":"Write a short poem about the ocean."}]
  }'
```

### Vision — analyse an image
Send an image URL (or base64 data URL) as part of the user message. Use a vision-capable model.

Suggested models: `gpt-5.5`, `gpt-5.4-mini`, `gemini-3.1-pro-preview`, `gemini-3.6-flash`

**Python**
```python
from openai import OpenAI

client = OpenAI(api_key="YOUR_TOKENREX_API_KEY", base_url="https://tokenrex.ai/api/public/v1")

r = client.chat.completions.create(
    model="gpt-6-astra",
    messages=[{
        "role": "user",
        "content": [
            {"type": "text", "text": "What is in this image? Describe it in one paragraph."},
            {"type": "image_url", "image_url": {"url": "https://YOUR_PUBLIC_IMAGE_HOST/photo.jpg"}},
        ],
    }],
)
print(r.choices[0].message.content)
```

**Node.js**
```javascript
import OpenAI from "openai";
const client = new OpenAI({ apiKey: "YOUR_TOKENREX_API_KEY", baseURL: "https://tokenrex.ai/api/public/v1" });

const r = await client.chat.completions.create({
  model: "gpt-6-astra",
  messages: [{
    role: "user",
    content: [
      { type: "text", text: "What is in this image? Describe it in one paragraph." },
      { type: "image_url", image_url: { url: "https://YOUR_PUBLIC_IMAGE_HOST/photo.jpg" } },
    ],
  }],
});
console.log(r.choices[0].message.content);
```

### Structured JSON output
Extract structured data with a supported strict json_schema. Prompt-only JSON is not schema-enforced; native Claude uses output_config.format.

Suggested models: `gpt-5.5`, `gpt-5.4-mini`, `gemini-3.6-flash`

**Python**
```python
from openai import OpenAI
client = OpenAI(api_key="YOUR_TOKENREX_API_KEY", base_url="https://tokenrex.ai/api/public/v1")

r = client.chat.completions.create(
    model="gpt-6-astra",
    messages=[
        {"role": "system", "content": "Reply ONLY with JSON: {name,email,city}."},
        {"role": "user",   "content": "Hi, I'm Ravi from Mumbai — ravi@example.com"},
    ],
)
print(r.choices[0].message.content)  # {"name":"Ravi","email":"...","city":"Mumbai"}
```

**Node.js**
```javascript
const r = await client.chat.completions.create({
  model: "gpt-6-astra",
  messages: [
    { role: "system", content: "Reply ONLY with JSON: {name,email,city}." },
    { role: "user",   content: "Hi, I'm Ravi from Mumbai — ravi@example.com" },
  ],
});
console.log(JSON.parse(r.choices[0].message.content));
```

### Image generation
Text → image. Returns a base64 image or URL you can save/display.

Suggested models: `gpt-image-2.6-sunburst`, `gpt-image-2.6-flare`, `gpt-image-2.5-sunburst`, `gpt-image-2.5-flare`, `gemini-3-pro-image`

**cURL**
```bash
curl https://tokenrex.ai/api/public/v1/images/generations \
  -H "Authorization: Bearer YOUR_TOKENREX_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-image-2.5-sunburst",
    "prompt": "A cinematic sunset over the Himalayas, ultra-detailed, 4k",
    "size": "1024x1024"
  }'
```

**Python**
```python
import requests, base64
r = requests.post(
    "https://tokenrex.ai/api/public/v1/images/generations",
    headers={"Authorization": "Bearer YOUR_TOKENREX_API_KEY"},
    json={
        "model": "gpt-image-2.5-sunburst",
        "prompt": "A cinematic sunset over the Himalayas, 4k",
        "size": "1024x1024",
    },
).json()
img_b64 = r["data"][0]["b64_json"]
open("out.png","wb").write(base64.b64decode(img_b64))
```

**Node.js**
```javascript
import fs from "node:fs";

const r = await fetch("https://tokenrex.ai/api/public/v1/images/generations", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_TOKENREX_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    model: "gpt-image-2.5-sunburst",
    prompt: "A cinematic sunset over the Himalayas",
    size: "1024x1024",
  }),
}).then(r => r.json());

fs.writeFileSync("out.png", Buffer.from(r.data[0].b64_json, "base64"));
```

### Text-to-Speech (TTS)
Text → MP3 audio. Download the file, or add "stream_format": "sse" (OpenAI models) to get audio chunks live as they are made — playback can start in under a second.

Suggested models: `gpt-4o-mini-tts`, `gemini-2.5-pro-tts`, `gemini-3.1-flash-tts-preview`

**cURL**
```bash
curl https://tokenrex.ai/api/public/v1/audio/speech \
  -H "Authorization: Bearer YOUR_TOKENREX_API_KEY" \
  -H "Content-Type: application/json" \
  -o hello.mp3 \
  -d '{
    "model": "gpt-4o-mini-tts",
    "voice": "alloy",
    "input": "Hello! Welcome to TokenRex."
  }'
```

**Python**
```python
from openai import OpenAI
client = OpenAI(api_key="YOUR_TOKENREX_API_KEY", base_url="https://tokenrex.ai/api/public/v1")

with client.audio.speech.with_streaming_response.create(
    model="gpt-4o-mini-tts",
    voice="alloy",
    input="Hello! Welcome to TokenRex.",
) as resp:
    resp.stream_to_file("hello.mp3")
```

**Live stream (SSE)**
```bash
curl -N https://tokenrex.ai/api/public/v1/audio/speech \
  -H "Authorization: Bearer YOUR_TOKENREX_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-4o-mini-tts",
    "voice": "ash",
    "input": "Namaste! Yeh live streaming audio hai.",
    "stream_format": "sse"
  }'
# Each line: data: {"type":"speech.audio.delta","audio":"<base64 mp3 chunk>"}
# Ends with: data: {"type":"speech.audio.done", ...}
```

### Speech-to-Text (STT)
Audio file → transcript. Upload MP3/WAV/M4A and get plain text, or send stream=true to receive the words live as transcript.text.delta events. Hindi and Hinglish work.

Suggested models: `gpt-transcribe`, `gpt-4o-transcribe`, `gpt-4o-mini-transcribe`

**cURL**
```bash
curl https://tokenrex.ai/api/public/v1/audio/transcriptions \
  -H "Authorization: Bearer YOUR_TOKENREX_API_KEY" \
  -F file="@hello.mp3" \
  -F model="gpt-4o-mini-transcribe"
```

**Python**
```python
from openai import OpenAI
client = OpenAI(api_key="YOUR_TOKENREX_API_KEY", base_url="https://tokenrex.ai/api/public/v1")

with open("hello.mp3", "rb") as f:
    r = client.audio.transcriptions.create(model="gpt-4o-mini-transcribe", file=f)
print(r.text)
```

**Live stream (SSE)**
```bash
curl -N https://tokenrex.ai/api/public/v1/audio/transcriptions \
  -H "Authorization: Bearer YOUR_TOKENREX_API_KEY" \
  -F file="@hello.mp3" \
  -F model="gpt-4o-transcribe" \
  -F stream=true
# Words arrive live: data: {"type":"transcript.text.delta","delta":"Namaste"}
# Ends with:         data: {"type":"transcript.text.done","text":"..."}
```

### Music generation (Lyria 3)
Text (or an image) → 48 kHz stereo MP3 music. Lyria 3 Clip makes 30-second clips and loops ($0.04/clip); Lyria 3 Pro makes full songs up to ~3 minutes with verses, choruses, bridges and timed lyrics ($0.08/song) at market price. Control genre, BPM, key/scale, mood, instruments, vocals and arrangement through the prompt; supply custom lyrics with [Verse]/[Chorus] tags. Full capability list: tokenrex.ai/models/google--lyria-3-pro-preview

Suggested models: `lyria-3-clip-preview`, `lyria-3-pro-preview`

**cURL**
```bash
curl https://tokenrex.ai/api/public/v1/music \
  -H "Authorization: Bearer YOUR_TOKENREX_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "lyria-3-clip-preview",
    "input": "An upbeat Bollywood-style pop track with sitar, tabla and a catchy female vocal hook."
  }' \
  --output track.mp3
```

**Python**
```python
import requests
r = requests.post("https://tokenrex.ai/api/public/v1/music",
    headers={"Authorization": "Bearer YOUR_TOKENREX_API_KEY"},
    json={"model": "lyria-3-pro-preview",
          "input": "A soulful Hindi ballad with piano, strings and emotional vocals, about 2 minutes."})
r.raise_for_status()
open("song.mp3", "wb").write(r.content)
```

**JavaScript**
```javascript
const r = await fetch("https://tokenrex.ai/api/public/v1/music", {
  method: "POST",
  headers: { Authorization: "Bearer YOUR_TOKENREX_API_KEY", "Content-Type": "application/json" },
  body: JSON.stringify({
    model: "lyria-3-clip-preview",
    input: "Lo-fi hip hop loop, chill study beats, vinyl crackle, 30 seconds.",
    // optional: image: "data:image/png;base64,..." — set the mood from a picture
  }),
});
const blob = await r.blob(); // MP3 audio
document.querySelector("audio").src = URL.createObjectURL(blob);
```

### Video generation (Veo 3.1)
Text → video. Start a job with POST /v1/videos, then poll GET /v1/videos/{id} until it's ready.

Suggested models: `veo-3.1`, `veo-3.1-fast`, `veo-3.1-lite`

**cURL**
```bash
# 1) create the job (wallet is charged per second up-front)
curl https://tokenrex.ai/api/public/v1/videos \
  -H "Authorization: Bearer YOUR_TOKENREX_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "veo-3.1-lite",
    "prompt": "A cinematic drone shot over the Himalayas at golden hour",
    "duration_seconds": 6,
    "resolution": "720p"
  }'

# 2) poll until status = completed (polling is free)
curl https://tokenrex.ai/api/public/v1/videos/VIDEO_ID \
  -H "Authorization: Bearer YOUR_TOKENREX_API_KEY"
```

**Python**
```python
import requests, time

H = {"Authorization": "Bearer YOUR_TOKENREX_API_KEY"}
job = requests.post("https://tokenrex.ai/api/public/v1/videos", headers=H, json={
    "model": "veo-3.1-fast",
    "prompt": "A cinematic drone shot over the Himalayas at golden hour",
    "duration_seconds": 6,
    "resolution": "720p",
}).json()

while True:
    r = requests.get(f"https://tokenrex.ai/api/public/v1/videos/{job['id']}", headers=H).json()
    if r.get("status") in ("completed", "failed"):
        print(r)
        break
    time.sleep(5)
```

**Node.js**
```javascript
const H = { Authorization: "Bearer YOUR_TOKENREX_API_KEY", "Content-Type": "application/json" };

const job = await fetch("https://tokenrex.ai/api/public/v1/videos", {
  method: "POST",
  headers: H,
  body: JSON.stringify({
    model: "veo-3.1-lite",
    duration_seconds: 8,
    resolution: "1080p",
  }),
}).then((r) => r.json());

let out;
do {
  await new Promise((r) => setTimeout(r, 5000));
  out = await fetch(`https://tokenrex.ai/api/public/v1/videos/${job.id}`, { headers: H }).then((r) => r.json());
} while (out.status !== "completed" && out.status !== "failed");
console.log(out);
```

### Live voice & tools (GPT Live 1)
GPT Live 1 powers two-way audio conversation. TokenRex also builds Voice (TTS, Beta) and Transcribe (STT) modes on this same model; they are not separately trained OpenAI models. All use live per-second session billing with a 15-second minimum, including silence. Read current prices and minute equivalents on each model page. Customer-authorized conversation tools are billed separately.

Suggested models: `gpt-live-1`, `gpt-live-1-transcribe`, `gpt-live-1-voice`

**Browser JS**
```javascript
// 1) microphone + WebRTC offer
const mic = await navigator.mediaDevices.getUserMedia({ audio: true });
const pc = new RTCPeerConnection();
mic.getTracks().forEach((t) => pc.addTrack(t, mic));
pc.createDataChannel("oai-events");
const audio = new Audio(); audio.autoplay = true;
pc.ontrack = (e) => (audio.srcObject = e.streams[0]);
await pc.setLocalDescription(await pc.createOffer());
await new Promise((r) => pc.iceGatheringState === "complete" ? r() :
  pc.addEventListener("icegatheringstatechange", () => pc.iceGatheringState === "complete" && r()));

// 2) connect to TokenRex (use a server-side proxy in production to hide your key)
const ws = new WebSocket("wss://tokenrex.ai/api/public/v1/live?model=gpt-live-1&key=YOUR_TOKENREX_API_KEY");
ws.onopen = () => ws.send(JSON.stringify({
  type: "session.start",
  session: {
    instructions: "You are a friendly assistant. Use customer tools when needed and ask for confirmation before sensitive actions.",
    audio: { output: { voice: "marin" } },
  },
  tools: [
    { name: "get_weather", description: "Current weather from my app's weather service" },
    { name: "web_search", description: "Current web results from my app's search service" },
    { name: "browser_action", description: "A user-approved browser action executed by my app" },
  ],
  transport: { type: "webrtc", sdp: pc.localDescription.sdp },
}));

// 3) apply the answer + send a heartbeat every second (call ends after 5s without one)
let hb;
ws.onmessage = async (m) => {
  const ev = JSON.parse(m.data);
  if (ev.type === "gateway.session.created") {
    await pc.setRemoteDescription({ type: "answer", sdp: ev.transport.sdp });
    hb = setInterval(() => ws.send(JSON.stringify({ type: "gateway.heartbeat" })), 1000);
  }
  if (ev.type === "session.usage.updated") console.log("seconds:", ev.usage.seconds);
  // Your app chooses and executes the right tool. TokenRex never controls
  // the computer or calls third-party APIs without your app's permission.
  if (ev.type === "tokenrex.tool.request") {
    const result = await runMyApprovedTool(ev.transcript); // weather/search/browser/etc.
    ws.send(JSON.stringify({
      type: "tokenrex.tool.result",
      call_id: ev.call_id,
      name: result.name,
      output: result.output,
    }));
  }
  if (ev.type === "tokenrex.error") console.error(ev.error.message);
};

// 4) Camera or screen vision uses a separate TokenRex vision request.
// Capture only after the user grants permission and clicks your visible control.
async function shareVisualContext(dataUrl, source = "screen") {
  const vision = await fetch("https://tokenrex.ai/api/public/v1/chat/completions", {
    method: "POST",
    headers: { Authorization: "Bearer YOUR_TOKENREX_API_KEY", "Content-Type": "application/json" },
    body: JSON.stringify({
      model: "gpt-6-astra",
      messages: [{ role: "user", content: [
        { type: "text", text: "Describe visible text, controls and objects accurately. Do not guess hidden details." },
        { type: "image_url", image_url: { url: dataUrl } },
      ] }],
    }),
  }).then((r) => r.json());
  ws.send(JSON.stringify({
    type: "tokenrex.context.append",
    source,
    content: vision.choices[0].message.content,
  }));
}

// 5) hang up
function endCall() {
  clearInterval(hb);
  ws.send(JSON.stringify({ type: "session.close" }));
  mic.getTracks().forEach((t) => t.stop());
  pc.close();
}
```

### Embeddings (vector search)
Text → number array. Store in Postgres / Pinecone for semantic search.

Suggested models: `text-embedding-3-small`, `text-embedding-3-large`

**Python**
```python
from openai import OpenAI
client = OpenAI(api_key="YOUR_TOKENREX_API_KEY", base_url="https://tokenrex.ai/api/public/v1")

r = client.embeddings.create(
    model="text-embedding-3-small",
    input=["hello world", "TokenRex rocks"],
)
print(len(r.data[0].embedding))  # 1536
```

**Node.js**
```javascript
const r = await client.embeddings.create({
  model: "text-embedding-3-small",
  input: ["hello world", "TokenRex rocks"],
});
console.log(r.data[0].embedding.length); // 1536
```

### Typed decisions (classify / score / route)
Text in → typed answers with probabilities. Perfect for moderation, ticket routing and ranking.

Suggested models: `jev-1.13`

**cURL**
```bash
curl https://tokenrex.ai/api/public/v1/decisions \
  -H "Authorization: Bearer YOUR_TOKENREX_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "jev-1.13",
    "state": "Customer says: my order never arrived and I want a refund.",
    "questions": {
      "category": {
        "type": "choice",
        "instructions": "Classify the support ticket.",
        "criteria": {
          "refund": "Wants money back",
          "shipping": "Delivery problem",
          "technical": "Product not working",
          "other": "Anything else"
        }
      },
      "urgent": {
        "type": "noul",
        "instructions": "Is this urgent?",
        "criteria": { "true": "Needs action today", "false": "Can wait" }
      },
      "severity": {
        "type": "score",
        "instructions": "Rate severity.",
        "criteria": ["Minor annoyance", "Moderate issue", "Severe issue"]
      }
    }
  }'
```

**Python**
```python
import requests

r = requests.post("https://tokenrex.ai/api/public/v1/decisions",
    headers={"Authorization": "Bearer YOUR_TOKENREX_API_KEY"},
    json={
        "model": "jev-1.13",
        "state": "Customer says: my order never arrived and I want a refund.",
        "questions": {
            "category": {
                "type": "choice",
                "instructions": "Classify the support ticket.",
                "criteria": {
                    "refund": "Wants money back",
                    "shipping": "Delivery problem",
                    "technical": "Product not working",
                    "other": "Anything else",
                },
            },
            "urgent": {
                "type": "noul",
                "instructions": "Is this urgent?",
                "criteria": {"true": "Needs action today", "false": "Can wait"},
            },
        },
    }).json()

print(r["answers"]["category"]["choice"])       # refund
print(r["answers"]["category"]["probabilities"])
print(r["answers"]["urgent"]["noul"])            # 0.0 - 1.0
```

**Node.js**
```javascript
const r = await fetch("https://tokenrex.ai/api/public/v1/decisions", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_TOKENREX_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    model: "jev-1.13",
    state: "Customer says: my order never arrived and I want a refund.",
    questions: {
      category: {
        type: "choice",
        instructions: "Classify the support ticket.",
        criteria: {
          refund: "Wants money back",
          shipping: "Delivery problem",
          technical: "Product not working",
          other: "Anything else",
        },
      },
      severity: {
        type: "score",
        instructions: "Rate severity.",
        criteria: ["Minor annoyance", "Moderate issue", "Severe issue"],
      },
    },
  }),
}).then((res) => res.json());

console.log(r.answers.category.choice, r.answers.severity.score);
```

### Check wallet balance
Read your remaining TokenRex wallet balance in real-time.

Suggested models: 

**cURL**
```bash
curl https://tokenrex.ai/api/public/v1/balance \
  -H "Authorization: Bearer YOUR_TOKENREX_API_KEY"
```

**Python**
```python
import requests
r = requests.get("https://tokenrex.ai/api/public/v1/balance",
    headers={"Authorization": "Bearer YOUR_TOKENREX_API_KEY"}).json()
print(r)  # { currency: "INR", balance_paise: 500000, ... }
```

## Every available model (87)
Prices are per 1M tokens unless the unit says otherwise. Market price → TokenRex price.

### chat (49)
| Model ID | Name | Price | Cached input / 1M | Cache write / 1M | Cached output | Web search | Best for | Details |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
| `chat-latest` | ChatGPT Latest | $3.50 in / $21.00 out per 1M tokens | $0.35 per 1M tokens | No extra fee | Not offered; standard output rate | $7.00 per 1K searches | Chat, writing, coding and reasoning tasks | https://tokenrex.ai/models/chat-latest |
| `claude-fable-5-1` | Claude Fable 5.1 | $7.00 in / $35.00 out per 1M tokens | $0.175 per 1M tokens | $8.75 per 1M tokens | Not offered; standard output rate | $7.00 per 1K searches | Chat, writing, coding and reasoning tasks | https://tokenrex.ai/models/claude-fable-5-1 |
| `claude-haiku-4-5` | Claude Haiku 4.5 | $0.70 in / $3.50 out per 1M tokens | $0.07 per 1M tokens | $0.875 per 1M tokens | Not offered; standard output rate | $7.00 per 1K searches | Fast, low-cost replies and high-volume everyday tasks | https://tokenrex.ai/models/claude-haiku-4-5 |
| `claude-opus-5` | Claude Opus 5 | $3.50 in / $17.50 out per 1M tokens | $0.35 per 1M tokens | $4.38 per 1M tokens | Not offered; standard output rate | $7.00 per 1K searches | Complex reasoning, multi-step analysis and difficult coding | https://tokenrex.ai/models/claude-opus-5 |
| `claude-opus-5-5` | Claude Opus 5.5 | $2.80 in / $14.00 out per 1M tokens | $0.14 per 1M tokens | $3.50 per 1M tokens | Not offered; standard output rate | $7.00 per 1K searches | Complex reasoning, multi-step analysis and difficult coding | https://tokenrex.ai/models/claude-opus-5-5 |
| `claude-opus-5-5-fast` | Claude Opus 5.5 Fast | $5.60 in / $28.00 out per 1M tokens | $0.28 per 1M tokens | $7.00 per 1M tokens | Not offered; standard output rate | $7.00 per 1K searches | Complex reasoning, multi-step analysis and difficult coding | https://tokenrex.ai/models/claude-opus-5-5-fast |
| `claude-opus-5-fast` | Claude Opus 5 Fast | $7.00 in / $35.00 out per 1M tokens | $0.70 per 1M tokens | $8.75 per 1M tokens | Not offered; standard output rate | $7.00 per 1K searches | Complex reasoning, multi-step analysis and difficult coding | https://tokenrex.ai/models/claude-opus-5-fast |
| `claude-sonnet-5` | Claude Sonnet 5 | $1.40 in / $7.00 out per 1M tokens | $0.14 per 1M tokens | $1.75 per 1M tokens | Not offered; standard output rate | $7.00 per 1K searches | Chat, writing, coding and reasoning tasks | https://tokenrex.ai/models/claude-sonnet-5 |
| `gemini-3-flash-preview` | Gemini 3 Flash | $0.35 in / $2.10 out per 1M tokens | $0.035 per 1M tokens | No extra fee | Not offered; standard output rate | $9.80 per 1K searches | Fast, low-cost replies and high-volume everyday tasks | https://tokenrex.ai/models/gemini-3-flash-preview |
| `gemini-3.1-flash-lite` | Gemini 3.1 Flash Lite | $0.175 in / $1.05 out per 1M tokens | $0.0175 per 1M tokens | No extra fee | Not offered; standard output rate | $9.80 per 1K searches | Fast, low-cost replies and high-volume everyday tasks | https://tokenrex.ai/models/gemini-3.1-flash-lite |
| `gemini-3.1-flash-lite-fast` | Gemini 3.1 Flash Lite Fast | $0.315 in / $1.89 out per 1M tokens | $0.0315 per 1M tokens | No extra fee | Not offered; standard output rate | $9.80 per 1K searches | Fast, low-cost replies and high-volume everyday tasks | https://tokenrex.ai/models/gemini-3.1-flash-lite-fast |
| `gemini-3.1-pro-preview` | Gemini 3.1 Pro | $1.40 in / $8.40 out per 1M tokens | $0.14 per 1M tokens | No extra fee | Not offered; standard output rate | $9.80 per 1K searches | Complex reasoning, multi-step analysis and difficult coding | https://tokenrex.ai/models/gemini-3.1-pro-preview |
| `gemini-3.5-flash` | Gemini 3.5 Flash | $1.05 in / $6.30 out per 1M tokens | $0.105 per 1M tokens | No extra fee | Not offered; standard output rate | $9.80 per 1K searches | Fast, low-cost replies and high-volume everyday tasks | https://tokenrex.ai/models/gemini-3.5-flash |
| `gemini-3.6-flash` | Gemini 3.6 Flash | $0.525 in / $2.63 out per 1M tokens | $0.0525 per 1M tokens | No extra fee | Not offered; standard output rate | $9.80 per 1K searches | Fast, low-cost replies and high-volume everyday tasks | https://tokenrex.ai/models/gemini-3.6-flash |
| `gemini-3.7-flash` | Gemini 3.7 Flash | $0.525 in / $2.63 out per 1M tokens | $0.0525 per 1M tokens | No extra fee | Not offered; standard output rate | $9.80 per 1K searches | Fast, low-cost replies and high-volume everyday tasks | https://tokenrex.ai/models/gemini-3.7-flash |
| `gemini-3.8-flash` | Gemini 3.8 Flash | $0.525 in / $2.63 out per 1M tokens | $0.0525 per 1M tokens | No extra fee | Not offered; standard output rate | $9.80 per 1K searches | Fast, low-cost replies and high-volume everyday tasks | https://tokenrex.ai/models/gemini-3.8-flash |
| `gemini-4-argon` | Gemini 4 Argon | $1.40 in / $7.00 out per 1M tokens | $0.07 per 1M tokens | No extra fee | Not offered; standard output rate | $9.80 per 1K searches | Long-horizon coding, agents and million-token documents | https://tokenrex.ai/models/gemini-4-argon |
| `gpt-5` | GPT-5 | $0.875 in / $7.00 out per 1M tokens | $0.0875 per 1M tokens | No extra fee | Not offered; standard output rate | $7.00 per 1K searches | Chat, writing, coding and reasoning tasks | https://tokenrex.ai/models/gpt-5 |
| `gpt-5-fast` | GPT-5 Fast | $1.75 in / $14.00 out per 1M tokens | $0.175 per 1M tokens | No extra fee | Not offered; standard output rate | $7.00 per 1K searches | Fast, low-cost replies and high-volume everyday tasks | https://tokenrex.ai/models/gpt-5-fast |
| `gpt-5-mini` | GPT-5 Mini | $0.175 in / $1.40 out per 1M tokens | $0.0175 per 1M tokens | No extra fee | Not offered; standard output rate | $7.00 per 1K searches | Fast, low-cost replies and high-volume everyday tasks | https://tokenrex.ai/models/gpt-5-mini |
| `gpt-5-mini-fast` | GPT-5 Mini Fast | $0.315 in / $2.52 out per 1M tokens | $0.0315 per 1M tokens | No extra fee | Not offered; standard output rate | $7.00 per 1K searches | Fast, low-cost replies and high-volume everyday tasks | https://tokenrex.ai/models/gpt-5-mini-fast |
| `gpt-5-nano` | GPT-5 Nano | $0.035 in / $0.28 out per 1M tokens | $0.0035 per 1M tokens | No extra fee | Not offered; standard output rate | $7.00 per 1K searches | Fast, low-cost replies and high-volume everyday tasks | https://tokenrex.ai/models/gpt-5-nano |
| `gpt-5.2` | GPT-5.2 | $1.22 in / $9.80 out per 1M tokens | $0.123 per 1M tokens | No extra fee | Not offered; standard output rate | $7.00 per 1K searches | Chat, writing, coding and reasoning tasks | https://tokenrex.ai/models/gpt-5.2 |
| `gpt-5.2-fast` | GPT-5.2 Fast | $2.45 in / $19.60 out per 1M tokens | $0.245 per 1M tokens | No extra fee | Not offered; standard output rate | $7.00 per 1K searches | Fast, low-cost replies and high-volume everyday tasks | https://tokenrex.ai/models/gpt-5.2-fast |
| `gpt-5.4` | GPT-5.4 | $1.75 in / $10.50 out per 1M tokens | $0.175 per 1M tokens | No extra fee | Not offered; standard output rate | $7.00 per 1K searches | Chat, writing, coding and reasoning tasks | https://tokenrex.ai/models/gpt-5.4 |
| `gpt-5.4-fast` | GPT-5.4 Fast | $3.50 in / $21.00 out per 1M tokens | $0.35 per 1M tokens | No extra fee | Not offered; standard output rate | $7.00 per 1K searches | Fast, low-cost replies and high-volume everyday tasks | https://tokenrex.ai/models/gpt-5.4-fast |
| `gpt-5.4-mini` | GPT-5.4 Mini | $0.525 in / $3.15 out per 1M tokens | $0.0525 per 1M tokens | No extra fee | Not offered; standard output rate | $7.00 per 1K searches | Fast, low-cost replies and high-volume everyday tasks | https://tokenrex.ai/models/gpt-5.4-mini |
| `gpt-5.4-mini-fast` | GPT-5.4 Mini Fast | $1.05 in / $6.30 out per 1M tokens | $0.105 per 1M tokens | No extra fee | Not offered; standard output rate | $7.00 per 1K searches | Fast, low-cost replies and high-volume everyday tasks | https://tokenrex.ai/models/gpt-5.4-mini-fast |
| `gpt-5.4-nano` | GPT-5.4 Nano | $0.14 in / $0.875 out per 1M tokens | $0.014 per 1M tokens | No extra fee | Not offered; standard output rate | $7.00 per 1K searches | Fast, low-cost replies and high-volume everyday tasks | https://tokenrex.ai/models/gpt-5.4-nano |
| `gpt-5.4-pro` | GPT-5.4 Pro | $21.00 in / $126.00 out per 1M tokens | $2.10 per 1M tokens | No extra fee | Not offered; standard output rate | $7.00 per 1K searches | Complex reasoning, multi-step analysis and difficult coding | https://tokenrex.ai/models/gpt-5.4-pro |
| `gpt-5.5` | GPT-5.5 | $3.50 in / $21.00 out per 1M tokens | $0.35 per 1M tokens | No extra fee | Not offered; standard output rate | $7.00 per 1K searches | Chat, writing, coding and reasoning tasks | https://tokenrex.ai/models/gpt-5.5 |
| `gpt-5.5-fast` | GPT-5.5 Fast | $8.75 in / $52.50 out per 1M tokens | $0.875 per 1M tokens | No extra fee | Not offered; standard output rate | $7.00 per 1K searches | Fast, low-cost replies and high-volume everyday tasks | https://tokenrex.ai/models/gpt-5.5-fast |
| `gpt-5.5-pro` | GPT-5.5 Pro | $21.00 in / $126.00 out per 1M tokens | $2.10 per 1M tokens | No extra fee | Not offered; standard output rate | $7.00 per 1K searches | Complex reasoning, multi-step analysis and difficult coding | https://tokenrex.ai/models/gpt-5.5-pro |
| `gpt-5.6-luna` | GPT-5.6 Luna | $0.14 in / $0.84 out per 1M tokens | $0.014 per 1M tokens | No extra fee | Not offered; standard output rate | $7.00 per 1K searches | Fast, low-cost replies and high-volume everyday tasks | https://tokenrex.ai/models/gpt-5.6-luna |
| `gpt-5.6-luna-fast` | GPT-5.6 Luna Fast | $0.28 in / $1.68 out per 1M tokens | $0.028 per 1M tokens | No extra fee | Not offered; standard output rate | $7.00 per 1K searches | Fast, low-cost replies and high-volume everyday tasks | https://tokenrex.ai/models/gpt-5.6-luna-fast |
| `gpt-5.6-sol` | GPT-5.6 Sol | $2.80 in / $14.00 out per 1M tokens | $0.28 per 1M tokens | No extra fee | Not offered; standard output rate | $7.00 per 1K searches | Chat, writing, coding and reasoning tasks | https://tokenrex.ai/models/gpt-5.6-sol |
| `gpt-5.6-sol-fast` | GPT-5.6 Sol Fast | $5.60 in / $28.00 out per 1M tokens | $0.56 per 1M tokens | No extra fee | Not offered; standard output rate | $7.00 per 1K searches | Fast, low-cost replies and high-volume everyday tasks | https://tokenrex.ai/models/gpt-5.6-sol-fast |
| `gpt-5.6-terra` | GPT-5.6 Terra | $1.40 in / $8.40 out per 1M tokens | $0.14 per 1M tokens | No extra fee | Not offered; standard output rate | $7.00 per 1K searches | Chat, writing, coding and reasoning tasks | https://tokenrex.ai/models/gpt-5.6-terra |
| `gpt-5.6-terra-fast` | GPT-5.6 Terra Fast | $2.80 in / $16.80 out per 1M tokens | $0.28 per 1M tokens | No extra fee | Not offered; standard output rate | $7.00 per 1K searches | Fast, low-cost replies and high-volume everyday tasks | https://tokenrex.ai/models/gpt-5.6-terra-fast |
| `gpt-6-astra` | GPT-6 Astra | $7.00 in / $35.00 out per 1M tokens | $0.70 per 1M tokens | $8.75 per 1M tokens | Not offered; standard output rate | $7.00 per 1K searches | Chat, writing, coding and reasoning tasks | https://tokenrex.ai/models/gpt-6-astra |
| `gpt-6-astra-fast` | GPT-6 Astra Fast | $14.00 in / $70.00 out per 1M tokens | $1.40 per 1M tokens | $17.50 per 1M tokens | Not offered; standard output rate | $7.00 per 1K searches | Fast, low-cost replies and high-volume everyday tasks | https://tokenrex.ai/models/gpt-6-astra-fast |
| `gpt-6-luna` | GPT-6 Luna | $0.07 in / $0.35 out per 1M tokens | $0.007 per 1M tokens | No extra fee | Not offered; standard output rate | $7.00 per 1K searches | Fast, low-cost replies and high-volume everyday tasks | https://tokenrex.ai/models/gpt-6-luna |
| `gpt-6-luna-fast` | GPT-6 Luna Fast | $0.14 in / $0.70 out per 1M tokens | $0.014 per 1M tokens | No extra fee | Not offered; standard output rate | $7.00 per 1K searches | Fast, low-cost replies and high-volume everyday tasks | https://tokenrex.ai/models/gpt-6-luna-fast |
| `gpt-6-sol` | GPT-6 Sol | $1.40 in / $7.00 out per 1M tokens | $0.14 per 1M tokens | No extra fee | Not offered; standard output rate | $7.00 per 1K searches | Chat, writing, coding and reasoning tasks | https://tokenrex.ai/models/gpt-6-sol |
| `gpt-6-sol-fast` | GPT-6 Sol Fast | $2.80 in / $14.00 out per 1M tokens | $0.28 per 1M tokens | No extra fee | Not offered; standard output rate | $7.00 per 1K searches | Fast, low-cost replies and high-volume everyday tasks | https://tokenrex.ai/models/gpt-6-sol-fast |
| `gpt-6.1-sol` | GPT-6.1 Sol | $1.40 in / $7.00 out per 1M tokens | $0.07 per 1M tokens | $1.75 per 1M tokens | Not offered; standard output rate | $7.00 per 1K searches | Near-flagship agentic coding and computer use at a lower price | https://tokenrex.ai/models/gpt-6.1-sol |
| `gpt-6.1-sol-fast` | GPT-6.1 Sol Fast | $2.80 in / $14.00 out per 1M tokens | $0.14 per 1M tokens | $3.50 per 1M tokens | Not offered; standard output rate | $7.00 per 1K searches | Fast, low-cost replies and high-volume everyday tasks | https://tokenrex.ai/models/gpt-6.1-sol-fast |
| `gpt-6.1-terra` | GPT-6.1 Terra | $0.70 in / $3.50 out per 1M tokens | $0.035 per 1M tokens | $0.875 per 1M tokens | Not offered; standard output rate | $7.00 per 1K searches | Visual reasoning, document analysis and clear writing | https://tokenrex.ai/models/gpt-6.1-terra |
| `gpt-6.1-terra-fast` | GPT-6.1 Terra Fast | $1.40 in / $7.00 out per 1M tokens | $0.07 per 1M tokens | $1.75 per 1M tokens | Not offered; standard output rate | $7.00 per 1K searches | Visual reasoning, document analysis and clear writing | https://tokenrex.ai/models/gpt-6.1-terra-fast |

### decision (1)
| Model ID | Name | Price | Cached input / 1M | Cache write / 1M | Cached output | Web search | Best for | Details |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
| `jev-1.13` | Jev 1.13 | $0.0295 per 1M tokens | Not applicable | Not applicable | Not offered; standard output rate | Not applicable | Classification, scoring and routing with probabilities | https://tokenrex.ai/models/jev-1.13 |

### embedding (4)
| Model ID | Name | Price | Cached input / 1M | Cache write / 1M | Cached output | Web search | Best for | Details |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
| `gemini-embedding-001` | Gemini Embedding 001 | $0.105 per 1M tokens | Not applicable | Not applicable | Not offered; standard output rate | Not applicable | Semantic search, RAG and clustering | https://tokenrex.ai/models/gemini-embedding-001 |
| `gemini-embedding-2` | Gemini Embedding 2 | $0.14 per 1M tokens | Not applicable | Not applicable | Not offered; standard output rate | Not applicable | Semantic search, RAG and clustering | https://tokenrex.ai/models/gemini-embedding-2 |
| `text-embedding-3-large` | Text Embedding 3 Large | $0.091 per 1M tokens | Not applicable | Not applicable | Not offered; standard output rate | Not applicable | Semantic search, RAG and clustering | https://tokenrex.ai/models/text-embedding-3-large |
| `text-embedding-3-small` | Text Embedding 3 Small | $0.014 per 1M tokens | Not applicable | Not applicable | Not offered; standard output rate | Not applicable | Semantic search, RAG and clustering | https://tokenrex.ai/models/text-embedding-3-small |

### image (14)
| Model ID | Name | Price | Cached input / 1M | Cache write / 1M | Cached output | Web search | Best for | Details |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
| `gemini-3-pro-image` | Gemini 3 Pro Image | $0.0938 per image | Not applicable | Not applicable | Not offered; standard output rate | Not applicable | Generating and editing images from text prompts | https://tokenrex.ai/models/gemini-3-pro-image |
| `gemini-3-pro-image-2k` | Gemini 3 Pro Image 2K | $0.0938 per image | Not applicable | Not applicable | Not offered; standard output rate | Not applicable | Sharp 2K images for web and social media | https://tokenrex.ai/models/gemini-3-pro-image-2k |
| `gemini-3-pro-image-4k` | Gemini 3 Pro Image 4K | $0.168 per image | Not applicable | Not applicable | Not offered; standard output rate | Not applicable | High-resolution 4K images for print and large displays | https://tokenrex.ai/models/gemini-3-pro-image-4k |
| `gemini-3.1-flash-image` | Gemini 3.1 Flash Image | $0.047 per image | Not applicable | Not applicable | Not offered; standard output rate | Not applicable | Generating and editing images from text prompts | https://tokenrex.ai/models/gemini-3.1-flash-image |
| `gemini-3.1-flash-image-2k` | Gemini 3.1 Flash Image 2K | $0.0707 per image | Not applicable | Not applicable | Not offered; standard output rate | Not applicable | Sharp 2K images for web and social media | https://tokenrex.ai/models/gemini-3.1-flash-image-2k |
| `gemini-3.1-flash-image-4k` | Gemini 3.1 Flash Image 4K | $0.106 per image | Not applicable | Not applicable | Not offered; standard output rate | Not applicable | High-resolution 4K images for print and large displays | https://tokenrex.ai/models/gemini-3.1-flash-image-4k |
| `gemini-3.1-flash-lite-image` | Gemini 3.1 Flash Lite Image | $0.0236 per image | Not applicable | Not applicable | Not offered; standard output rate | Not applicable | Generating and editing images from text prompts | https://tokenrex.ai/models/gemini-3.1-flash-lite-image |
| `gpt-image-1-mini` | GPT Image 1 Mini | $1.40 text in / $5.60 image out / $1.75 image in per 1M tokens | Not applicable | Not applicable | Not offered; standard output rate | Not applicable | Generating and editing images from text prompts | https://tokenrex.ai/models/gpt-image-1-mini |
| `gpt-image-2` | GPT Image 2 | $3.50 text in / $21.00 image out / $5.60 image in per 1M tokens | Not applicable | Not applicable | Not offered; standard output rate | Not applicable | Generating and editing images from text prompts | https://tokenrex.ai/models/gpt-image-2 |
| `gpt-image-2.5-flare` | GPT Image 2.5 Flare | $3.50 text in / $21.00 image out / $5.60 image in per 1M tokens | Not applicable | Not applicable | Not offered; standard output rate | Not applicable | Generating and editing images from text prompts | https://tokenrex.ai/models/gpt-image-2.5-flare |
| `gpt-image-2.5-sunburst` | GPT Image 2.5 Sunburst | $3.50 text in / $21.00 image out / $5.60 image in per 1M tokens | Not applicable | Not applicable | Not offered; standard output rate | Not applicable | Generating and editing images from text prompts | https://tokenrex.ai/models/gpt-image-2.5-sunburst |
| `gpt-image-2.6-flare` | GPT Image 2.6 Flare | $3.50 text in / $21.00 image out / $5.60 image in per 1M tokens | Not applicable | Not applicable | Not offered; standard output rate | Not applicable | Generating and editing images from text prompts | https://tokenrex.ai/models/gpt-image-2.6-flare |
| `gpt-image-2.6-sunburst` | GPT Image 2.6 Sunburst | $3.50 text in / $21.00 image out / $5.60 image in per 1M tokens | Not applicable | Not applicable | Not offered; standard output rate | Not applicable | Generating and editing images from text prompts | https://tokenrex.ai/models/gpt-image-2.6-sunburst |
| `seedream-5-pro` | Seedream 5 Pro | $0.0315 per image | Not applicable | Not applicable | Not offered; standard output rate | Not applicable | Poster-style images and reference-guided edits with up to 10 ordered references | https://tokenrex.ai/models/seedream-5-pro |

### live (3)
| Model ID | Name | Price | Cached input / 1M | Cache write / 1M | Cached output | Web search | Best for | Details |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
| `gpt-live-1` | GPT Live 1 | $0.00058 per second | Not applicable | Not applicable | Not offered; standard output rate | Not applicable | Real-time voice agents and phone-style calls | https://tokenrex.ai/models/gpt-live-1 |
| `gpt-live-1-transcribe` | GPT Live 1 Transcribe | $0.00058 per second | Not applicable | Not applicable | Not offered; standard output rate | Not applicable | Real-time voice agents and phone-style calls | https://tokenrex.ai/models/gpt-live-1-transcribe |
| `gpt-live-1-voice` | GPT Live 1 Voice | $0.00058 per second | Not applicable | Not applicable | Not offered; standard output rate | Not applicable | Real-time voice agents and phone-style calls | https://tokenrex.ai/models/gpt-live-1-voice |

### music (2)
| Model ID | Name | Price | Cached input / 1M | Cache write / 1M | Cached output | Web search | Best for | Details |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
| `lyria-3-clip-preview` | Lyria 3 Clip | $0.028 per clip | Not applicable | Not applicable | Not offered; standard output rate | Not applicable | Generating music tracks from text or images | https://tokenrex.ai/models/lyria-3-clip-preview |
| `lyria-3-pro-preview` | Lyria 3 Pro | $0.056 per song | Not applicable | Not applicable | Not offered; standard output rate | Not applicable | Generating music tracks from text or images | https://tokenrex.ai/models/lyria-3-pro-preview |

### stt (4)
| Model ID | Name | Price | Cached input / 1M | Cache write / 1M | Cached output | Web search | Best for | Details |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
| `gemini-3.5-transcribe` | Gemini 3.5 Transcribe | $0.0035 per minute | Not applicable | Not applicable | Not offered; standard output rate | Not applicable | Transcribing audio files into text | https://tokenrex.ai/models/gemini-3.5-transcribe |
| `gpt-4o-mini-transcribe` | GPT-4o Mini Transcribe | $0.00211 per minute | Not applicable | Not applicable | Not offered; standard output rate | Not applicable | Transcribing audio files into text | https://tokenrex.ai/models/gpt-4o-mini-transcribe |
| `gpt-4o-transcribe` | GPT-4o Transcribe | $0.00423 per minute | Not applicable | Not applicable | Not offered; standard output rate | Not applicable | Transcribing audio files into text | https://tokenrex.ai/models/gpt-4o-transcribe |
| `gpt-transcribe` | GPT Transcribe | $0.00321 per audio minute | Not applicable | Not applicable | Not offered; standard output rate | Not applicable | Transcribing audio files into text | https://tokenrex.ai/models/gpt-transcribe |

### tts (4)
| Model ID | Name | Price | Cached input / 1M | Cache write / 1M | Cached output | Web search | Best for | Details |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
| `gemini-2.5-flash-tts` | Gemini 2.5 Flash TTS | $0.012 per 1k chars | Not applicable | Not applicable | Not offered; standard output rate | Not applicable | Turning text into natural-sounding speech | https://tokenrex.ai/models/gemini-2.5-flash-tts |
| `gemini-2.5-pro-tts` | Gemini 2.5 Pro TTS | $0.0238 per 1k chars | Not applicable | Not applicable | Not offered; standard output rate | Not applicable | Turning text into natural-sounding speech | https://tokenrex.ai/models/gemini-2.5-pro-tts |
| `gemini-3.1-flash-tts-preview` | Gemini 3.1 Flash TTS | $0.0238 per 1k chars | Not applicable | Not applicable | Not offered; standard output rate | Not applicable | Turning text into natural-sounding speech | https://tokenrex.ai/models/gemini-3.1-flash-tts-preview |
| `gpt-4o-mini-tts` | GPT-4o Mini TTS | $0.0105 per 1k chars | Not applicable | Not applicable | Not offered; standard output rate | Not applicable | Turning text into natural-sounding speech | https://tokenrex.ai/models/gpt-4o-mini-tts |

### video (6)
| Model ID | Name | Price | Cached input / 1M | Cache write / 1M | Cached output | Web search | Best for | Details |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
| `gemini-omni-1.1-flash` | Gemini Omni 1.1 Flash | $0.07 per second | Not applicable | Not applicable | Not offered; standard output rate | Not applicable | Short AI video clips from text or images | https://tokenrex.ai/models/gemini-omni-1.1-flash |
| `seedance-2.5` | Seedance 2.5 | $0.072 per second (480p) | Not applicable | Not applicable | Not offered; standard output rate | Not applicable | Videos with sound from text, first/last frames and ordered image, video or audio references | https://tokenrex.ai/models/seedance-2.5 |
| `starlight-fast-2` | Starlight Fast 2 | $0.084 per Topaz unit | Not applicable | Not applicable | Not offered; standard output rate | Not applicable | Restoring and upscaling existing footage to a 1080p or 4K tier | https://tokenrex.ai/models/starlight-fast-2 |
| `veo-3.1` | Veo 3.1 | $0.28 per second | Not applicable | Not applicable | Not offered; standard output rate | Not applicable | Short AI video clips from text or images | https://tokenrex.ai/models/veo-3.1 |
| `veo-3.1-fast` | Veo 3.1 Fast | $0.07 per second | Not applicable | Not applicable | Not offered; standard output rate | Not applicable | Short AI video clips from text or images | https://tokenrex.ai/models/veo-3.1-fast |
| `veo-3.1-lite` | Veo 3.1 Lite | $0.035 per second | Not applicable | Not applicable | Not offered; standard output rate | Not applicable | Short AI video clips from text or images | https://tokenrex.ai/models/veo-3.1-lite |

## Per-model feature and usage reference
Each entry links its category recipe and reviewed details. Limits and modalities are reference information, not proof that every provider-native feature is available through TokenRex. Unverified features remain unverified. Prices and cache rates are in the catalog table above.

### ChatGPT Latest — `chat-latest`
Latest Instant model used in ChatGPT — natural conversation
- Type: chat. Endpoint(s): POST /v1/chat/completions; POST /v1/responses.
- Optional Jev Armour (Beta): add armour:true to /v1/chat/completions (or /v1/responses for supported OpenAI models) and Jev auto-picks this model's thinking level per request. https://tokenrex.ai/features/jev-armour
- How to use: follow the 'Simple chat completion' recipe above and substitute this exact model ID.
- API inputs: Consult the category recipe and reviewed model details. API outputs: Consult the category recipe.
- Reviewed context limit: Not verified; output limit: Not verified. These are model references; request caps may be lower.
- Note: No reliable source establishing specifications or benchmarks for this exact model was found in this research pass. It remains in the enabled catalog; missing metadata does not disable it.
- Details and sources: https://tokenrex.ai/models/chat-latest

### Claude Fable 5.1 — `claude-fable-5-1`
Claude Fable 5.1 with medium thinking (default)
- Type: chat. Endpoint(s): POST /v1/chat/completions; POST /v1/messages.
- Optional Jev Armour (Beta): add armour:true to /v1/chat/completions (or /v1/responses for supported OpenAI models) and Jev auto-picks this model's thinking level per request. https://tokenrex.ai/features/jev-armour
- How to use: follow the 'Simple chat completion' recipe above and substitute this exact model ID.
- API inputs: Text, Image/PDF content through the chat bridge. API outputs: Text.
- Reviewed context limit: 1000000; output limit: 128000. These are model references; request caps may be lower.
- Note: Published provider limits; maximum-capacity requests have not been independently exercised through TokenRex. Thinking-level variants use the same provider model; reasoning and answer tokens share the output budget.
- Note: Benchmark configuration is stated per result. Provider max-effort tests are not measurements of the default medium or xhigh catalog versions. ProgramBench 87.6 is the vendor’s filtered 166-task test, not a generic public score.
- Details and sources: https://tokenrex.ai/models/claude-fable-5-1

### Claude Haiku 4.5 — `claude-haiku-4-5`
Claude Haiku 4.5 with medium thinking (default)
- Type: chat. Endpoint(s): POST /v1/chat/completions; POST /v1/messages.
- Optional Jev Armour (Beta): add armour:true to /v1/chat/completions (or /v1/responses for supported OpenAI models) and Jev auto-picks this model's thinking level per request. https://tokenrex.ai/features/jev-armour
- How to use: follow the 'Simple chat completion' recipe above and substitute this exact model ID.
- API inputs: Text, Image/PDF content through the chat bridge. API outputs: Text.
- Reviewed context limit: 200000; output limit: 64000. These are model references; request caps may be lower.
- Note: Published provider limits; maximum-capacity requests have not been independently exercised through TokenRex. Thinking-level variants use the same provider model; reasoning and answer tokens share the output budget.
- Details and sources: https://tokenrex.ai/models/claude-haiku-4-5

### Claude Opus 5 — `claude-opus-5`
Claude Opus 5 with medium thinking (default)
- Type: chat. Endpoint(s): POST /v1/chat/completions; POST /v1/messages.
- Optional Jev Armour (Beta): add armour:true to /v1/chat/completions (or /v1/responses for supported OpenAI models) and Jev auto-picks this model's thinking level per request. https://tokenrex.ai/features/jev-armour
- How to use: follow the 'Simple chat completion' recipe above and substitute this exact model ID.
- API inputs: Text, Image/PDF content through the chat bridge. API outputs: Text.
- Reviewed context limit: 1000000; output limit: 128000. These are model references; request caps may be lower.
- Note: Published provider limits; maximum-capacity requests have not been independently exercised through TokenRex. Thinking-level variants use the same provider model; reasoning and answer tokens share the output budget.
- Details and sources: https://tokenrex.ai/models/claude-opus-5

### Claude Opus 5.5 — `claude-opus-5-5`
Claude Opus 5.5 with medium thinking (default)
- Type: chat. Endpoint(s): POST /v1/chat/completions; POST /v1/messages.
- Optional Jev Armour (Beta): add armour:true to /v1/chat/completions (or /v1/responses for supported OpenAI models) and Jev auto-picks this model's thinking level per request. https://tokenrex.ai/features/jev-armour
- How to use: follow the 'Simple chat completion' recipe above and substitute this exact model ID.
- API inputs: Text, Image/PDF content through the chat bridge. API outputs: Text.
- Reviewed context limit: 1000000; output limit: 128000. These are model references; request caps may be lower.
- Note: Published provider limits; maximum-capacity requests have not been independently exercised through TokenRex. Thinking-level variants use the same provider model; reasoning and answer tokens share the output budget.
- Details and sources: https://tokenrex.ai/models/claude-opus-5-5

### Claude Opus 5.5 Fast — `claude-opus-5-5-fast`
Claude Opus 5.5 fast mode (quicker output, premium rate) with medium thinking (default)
- Type: chat. Endpoint(s): POST /v1/chat/completions; POST /v1/messages.
- Optional Jev Armour (Beta): add armour:true to /v1/chat/completions (or /v1/responses for supported OpenAI models) and Jev auto-picks this model's thinking level per request. https://tokenrex.ai/features/jev-armour
- How to use: follow the 'Simple chat completion' recipe above and substitute this exact model ID.
- API inputs: Text, Image/PDF content through the chat bridge. API outputs: Text.
- Reviewed context limit: 1000000; output limit: 128000. These are model references; request caps may be lower.
- Note: Published provider limits; maximum-capacity requests have not been independently exercised through TokenRex. Thinking-level variants use the same provider model; reasoning and answer tokens share the output budget.
- Details and sources: https://tokenrex.ai/models/claude-opus-5-5-fast

### Claude Opus 5 Fast — `claude-opus-5-fast`
Claude Opus 5 fast mode (quicker output, premium rate) with medium thinking (default)
- Type: chat. Endpoint(s): POST /v1/chat/completions; POST /v1/messages.
- Optional Jev Armour (Beta): add armour:true to /v1/chat/completions (or /v1/responses for supported OpenAI models) and Jev auto-picks this model's thinking level per request. https://tokenrex.ai/features/jev-armour
- How to use: follow the 'Simple chat completion' recipe above and substitute this exact model ID.
- API inputs: Text, Image/PDF content through the chat bridge. API outputs: Text.
- Reviewed context limit: 1000000; output limit: 128000. These are model references; request caps may be lower.
- Note: Published provider limits; maximum-capacity requests have not been independently exercised through TokenRex. Thinking-level variants use the same provider model; reasoning and answer tokens share the output budget.
- Details and sources: https://tokenrex.ai/models/claude-opus-5-fast

### Claude Sonnet 5 — `claude-sonnet-5`
Claude Sonnet 5 with medium thinking (default)
- Type: chat. Endpoint(s): POST /v1/chat/completions; POST /v1/messages.
- Optional Jev Armour (Beta): add armour:true to /v1/chat/completions (or /v1/responses for supported OpenAI models) and Jev auto-picks this model's thinking level per request. https://tokenrex.ai/features/jev-armour
- How to use: follow the 'Simple chat completion' recipe above and substitute this exact model ID.
- API inputs: Text, Image/PDF content through the chat bridge. API outputs: Text.
- Reviewed context limit: 1000000; output limit: 128000. These are model references; request caps may be lower.
- Note: Published provider limits; maximum-capacity requests have not been independently exercised through TokenRex. Thinking-level variants use the same provider model; reasoning and answer tokens share the output budget.
- Details and sources: https://tokenrex.ai/models/claude-sonnet-5

### Gemini 3 Flash — `gemini-3-flash-preview`
Fast Gemini preview
- Type: chat. Endpoint(s): POST /v1/chat/completions.
- Optional Jev Armour (Beta): add armour:true to /v1/chat/completions (or /v1/responses for supported OpenAI models) and Jev auto-picks this model's thinking level per request. https://tokenrex.ai/features/jev-armour
- How to use: follow the 'Simple chat completion' recipe above and substitute this exact model ID.
- API inputs: Consult the category recipe and reviewed model details. API outputs: Consult the category recipe.
- Reviewed input limit: 1048576; output limit: 65536. These are model references; request caps may be lower.
- Note: Published provider limits; maximum-capacity requests have not been independently exercised through TokenRex. Thinking-level variants use the same provider model; reasoning and answer tokens share the output budget.
- Details and sources: https://tokenrex.ai/models/gemini-3-flash-preview

### Gemini 3.1 Flash Lite — `gemini-3.1-flash-lite`
Cost-efficient high volume
- Type: chat. Endpoint(s): POST /v1/chat/completions.
- Optional Jev Armour (Beta): add armour:true to /v1/chat/completions (or /v1/responses for supported OpenAI models) and Jev auto-picks this model's thinking level per request. https://tokenrex.ai/features/jev-armour
- How to use: follow the 'Simple chat completion' recipe above and substitute this exact model ID.
- API inputs: Consult the category recipe and reviewed model details. API outputs: Consult the category recipe.
- Reviewed input limit: 1048576; output limit: 65536. These are model references; request caps may be lower.
- Note: Published provider limits; maximum-capacity requests have not been independently exercised through TokenRex. Thinking-level variants use the same provider model; reasoning and answer tokens share the output budget.
- Details and sources: https://tokenrex.ai/models/gemini-3.1-flash-lite

### Gemini 3.1 Flash Lite Fast — `gemini-3.1-flash-lite-fast`
Gemini 3.1 Flash Lite on priority serving for faster replies — 1.8x price
- Type: chat. Endpoint(s): POST /v1/chat/completions.
- Optional Jev Armour (Beta): add armour:true to /v1/chat/completions (or /v1/responses for supported OpenAI models) and Jev auto-picks this model's thinking level per request. https://tokenrex.ai/features/jev-armour
- How to use: follow the 'Simple chat completion' recipe above and substitute this exact model ID.
- API inputs: Consult the category recipe and reviewed model details. API outputs: Consult the category recipe.
- Reviewed input limit: 1048576; output limit: 65536. These are model references; request caps may be lower.
- Note: Published provider limits; maximum-capacity requests have not been independently exercised through TokenRex. Thinking-level variants use the same provider model; reasoning and answer tokens share the output budget.
- Details and sources: https://tokenrex.ai/models/gemini-3.1-flash-lite-fast

### Gemini 3.1 Pro — `gemini-3.1-pro-preview`
Next-gen Gemini Pro reasoning
- Type: chat. Endpoint(s): POST /v1/chat/completions.
- Optional Jev Armour (Beta): add armour:true to /v1/chat/completions (or /v1/responses for supported OpenAI models) and Jev auto-picks this model's thinking level per request. https://tokenrex.ai/features/jev-armour
- How to use: follow the 'Simple chat completion' recipe above and substitute this exact model ID.
- API inputs: Consult the category recipe and reviewed model details. API outputs: Consult the category recipe.
- Reviewed input limit: 1048576; output limit: 65536. These are model references; request caps may be lower.
- Note: Published provider limits; maximum-capacity requests have not been independently exercised through TokenRex. Thinking-level variants use the same provider model; reasoning and answer tokens share the output budget.
- Details and sources: https://tokenrex.ai/models/gemini-3.1-pro-preview

### Gemini 3.5 Flash — `gemini-3.5-flash`
High-efficiency Gemini 3.5
- Type: chat. Endpoint(s): POST /v1/chat/completions.
- Optional Jev Armour (Beta): add armour:true to /v1/chat/completions (or /v1/responses for supported OpenAI models) and Jev auto-picks this model's thinking level per request. https://tokenrex.ai/features/jev-armour
- How to use: follow the 'Simple chat completion' recipe above and substitute this exact model ID.
- API inputs: Consult the category recipe and reviewed model details. API outputs: Consult the category recipe.
- Reviewed input limit: 1048576; output limit: 65536. These are model references; request caps may be lower.
- Note: Published provider limits; maximum-capacity requests have not been independently exercised through TokenRex. Thinking-level variants use the same provider model; reasoning and answer tokens share the output budget.
- Details and sources: https://tokenrex.ai/models/gemini-3.5-flash

### Gemini 3.6 Flash — `gemini-3.6-flash`
High-efficiency Gemini 3.6
- Type: chat. Endpoint(s): POST /v1/chat/completions.
- Optional Jev Armour (Beta): add armour:true to /v1/chat/completions (or /v1/responses for supported OpenAI models) and Jev auto-picks this model's thinking level per request. https://tokenrex.ai/features/jev-armour
- How to use: follow the 'Simple chat completion' recipe above and substitute this exact model ID.
- API inputs: Consult the category recipe and reviewed model details. API outputs: Consult the category recipe.
- Reviewed input limit: 1048576; output limit: 65536. These are model references; request caps may be lower.
- Note: Published provider limits; maximum-capacity requests have not been independently exercised through TokenRex. Thinking-level variants use the same provider model; reasoning and answer tokens share the output budget.
- Details and sources: https://tokenrex.ai/models/gemini-3.6-flash

### Gemini 3.7 Flash — `gemini-3.7-flash`
Latest Gemini Flash (default)
- Type: chat. Endpoint(s): POST /v1/chat/completions.
- Optional Jev Armour (Beta): add armour:true to /v1/chat/completions (or /v1/responses for supported OpenAI models) and Jev auto-picks this model's thinking level per request. https://tokenrex.ai/features/jev-armour
- How to use: follow the 'Simple chat completion' recipe above and substitute this exact model ID.
- API inputs: Consult the category recipe and reviewed model details. API outputs: Consult the category recipe.
- Reviewed input limit: 1048576; output limit: 65536. These are model references; request caps may be lower.
- Note: Published provider limits; maximum-capacity requests have not been independently exercised through TokenRex. Thinking-level variants use the same provider model; reasoning and answer tokens share the output budget.
- Details and sources: https://tokenrex.ai/models/gemini-3.7-flash

### Gemini 3.8 Flash — `gemini-3.8-flash`
Latest-generation Gemini Flash model for fast coding, reasoning, and agentic workflows.
- Type: chat. Endpoint(s): POST /v1/chat/completions.
- Optional Jev Armour (Beta): add armour:true to /v1/chat/completions (or /v1/responses for supported OpenAI models) and Jev auto-picks this model's thinking level per request. https://tokenrex.ai/features/jev-armour
- How to use: follow the 'Simple chat completion' recipe above and substitute this exact model ID.
- API inputs: Consult the category recipe and reviewed model details. API outputs: Consult the category recipe.
- Reviewed input limit: 1048576; output limit: 65536. These are model references; request caps may be lower.
- Note: Published provider limits; maximum-capacity requests have not been independently exercised through TokenRex. Thinking-level variants use the same provider model; reasoning and answer tokens share the output budget.
- Details and sources: https://tokenrex.ai/models/gemini-3.8-flash

### Gemini 4 Argon — `gemini-4-argon`
Frontier Gemini model for long-horizon coding, reasoning and enterprise knowledge work — 1M context, text/image/audio/video input
- Type: chat. Endpoint(s): POST /v1/chat/completions.
- Optional Jev Armour (Beta): add armour:true to /v1/chat/completions (or /v1/responses for supported OpenAI models) and Jev auto-picks this model's thinking level per request. https://tokenrex.ai/features/jev-armour
- How to use: follow the 'Simple chat completion' recipe above and substitute this exact model ID.
- API inputs: Consult the category recipe and reviewed model details. API outputs: Consult the category recipe.
- Reviewed context limit: 1048576; output limit: 65536. These are model references; request caps may be lower.
- Note: Published provider limits; maximum-capacity requests have not been independently exercised through TokenRex. Standard requests allow up to 65,536 output tokens. Google's long-decode mode (output up to 1,048,576 tokens minus input) is enabled with background=true — the TokenRex chat endpoint accepts this parameter (verified live on 2026-10-14), but a full 1M-token output has not been exercised, so the default 65,536-token output limit is shown.
- Note: All benchmark scores are self-reported by Google in the official model card; TokenRex has not re-run them.
- Details and sources: https://tokenrex.ai/models/gemini-4-argon

### GPT-5 — `gpt-5`
Powerful multimodal all-rounder
- Type: chat. Endpoint(s): POST /v1/chat/completions; POST /v1/responses.
- Optional Jev Armour (Beta): add armour:true to /v1/chat/completions (or /v1/responses for supported OpenAI models) and Jev auto-picks this model's thinking level per request. https://tokenrex.ai/features/jev-armour
- How to use: follow the 'Simple chat completion' recipe above and substitute this exact model ID.
- API inputs: Text, Image/PDF content through the chat bridge. API outputs: Text.
- Reviewed context limit: 400000; output limit: 128000. These are model references; request caps may be lower.
- Note: Published provider limits; maximum-capacity requests have not been independently exercised through TokenRex. Thinking-level variants use the same provider model; reasoning and answer tokens share the output budget.
- Details and sources: https://tokenrex.ai/models/gpt-5

### GPT-5 Fast — `gpt-5-fast`
GPT-5 on priority serving for faster replies, balanced thinking — 2x price
- Type: chat. Endpoint(s): POST /v1/chat/completions; POST /v1/responses.
- Optional Jev Armour (Beta): add armour:true to /v1/chat/completions (or /v1/responses for supported OpenAI models) and Jev auto-picks this model's thinking level per request. https://tokenrex.ai/features/jev-armour
- How to use: follow the 'Simple chat completion' recipe above and substitute this exact model ID.
- API inputs: Text, Image/PDF content through the chat bridge. API outputs: Text.
- Reviewed context limit: 400000; output limit: 128000. These are model references; request caps may be lower.
- Note: Published provider limits; maximum-capacity requests have not been independently exercised through TokenRex. Thinking-level variants use the same provider model; reasoning and answer tokens share the output budget.
- Details and sources: https://tokenrex.ai/models/gpt-5-fast

### GPT-5 Mini — `gpt-5-mini`
Fast, affordable GPT-5
- Type: chat. Endpoint(s): POST /v1/chat/completions; POST /v1/responses.
- Optional Jev Armour (Beta): add armour:true to /v1/chat/completions (or /v1/responses for supported OpenAI models) and Jev auto-picks this model's thinking level per request. https://tokenrex.ai/features/jev-armour
- How to use: follow the 'Simple chat completion' recipe above and substitute this exact model ID.
- API inputs: Text, Image/PDF content through the chat bridge. API outputs: Text.
- Reviewed context limit: 400000; output limit: 128000. These are model references; request caps may be lower.
- Note: Published provider limits; maximum-capacity requests have not been independently exercised through TokenRex. Thinking-level variants use the same provider model; reasoning and answer tokens share the output budget.
- Details and sources: https://tokenrex.ai/models/gpt-5-mini

### GPT-5 Mini Fast — `gpt-5-mini-fast`
GPT-5 Mini on priority serving for faster replies, balanced thinking — 1.8x price
- Type: chat. Endpoint(s): POST /v1/chat/completions; POST /v1/responses.
- Optional Jev Armour (Beta): add armour:true to /v1/chat/completions (or /v1/responses for supported OpenAI models) and Jev auto-picks this model's thinking level per request. https://tokenrex.ai/features/jev-armour
- How to use: follow the 'Simple chat completion' recipe above and substitute this exact model ID.
- API inputs: Text, Image/PDF content through the chat bridge. API outputs: Text.
- Reviewed context limit: 400000; output limit: 128000. These are model references; request caps may be lower.
- Note: Published provider limits; maximum-capacity requests have not been independently exercised through TokenRex. Thinking-level variants use the same provider model; reasoning and answer tokens share the output budget.
- Details and sources: https://tokenrex.ai/models/gpt-5-mini-fast

### GPT-5 Nano — `gpt-5-nano`
Ultra-cheap GPT-5 for simple tasks
- Type: chat. Endpoint(s): POST /v1/chat/completions; POST /v1/responses.
- Optional Jev Armour (Beta): add armour:true to /v1/chat/completions (or /v1/responses for supported OpenAI models) and Jev auto-picks this model's thinking level per request. https://tokenrex.ai/features/jev-armour
- How to use: follow the 'Simple chat completion' recipe above and substitute this exact model ID.
- API inputs: Text, Image/PDF content through the chat bridge. API outputs: Text.
- Reviewed context limit: 400000; output limit: 128000. These are model references; request caps may be lower.
- Note: Published provider limits; maximum-capacity requests have not been independently exercised through TokenRex. Thinking-level variants use the same provider model; reasoning and answer tokens share the output budget.
- Details and sources: https://tokenrex.ai/models/gpt-5-nano

### GPT-5.2 — `gpt-5.2`
Complex reasoning & problem solving
- Type: chat. Endpoint(s): POST /v1/chat/completions; POST /v1/responses.
- Optional Jev Armour (Beta): add armour:true to /v1/chat/completions (or /v1/responses for supported OpenAI models) and Jev auto-picks this model's thinking level per request. https://tokenrex.ai/features/jev-armour
- How to use: follow the 'Simple chat completion' recipe above and substitute this exact model ID.
- API inputs: Text, Image/PDF content through the chat bridge. API outputs: Text.
- Reviewed context limit: 400000; output limit: 128000. These are model references; request caps may be lower.
- Note: Published provider limits; maximum-capacity requests have not been independently exercised through TokenRex. Thinking-level variants use the same provider model; reasoning and answer tokens share the output budget.
- Details and sources: https://tokenrex.ai/models/gpt-5.2

### GPT-5.2 Fast — `gpt-5.2-fast`
GPT-5.2 on priority serving for faster replies, balanced thinking — 2x price
- Type: chat. Endpoint(s): POST /v1/chat/completions; POST /v1/responses.
- Optional Jev Armour (Beta): add armour:true to /v1/chat/completions (or /v1/responses for supported OpenAI models) and Jev auto-picks this model's thinking level per request. https://tokenrex.ai/features/jev-armour
- How to use: follow the 'Simple chat completion' recipe above and substitute this exact model ID.
- API inputs: Text, Image/PDF content through the chat bridge. API outputs: Text.
- Reviewed context limit: 400000; output limit: 128000. These are model references; request caps may be lower.
- Note: Published provider limits; maximum-capacity requests have not been independently exercised through TokenRex. Thinking-level variants use the same provider model; reasoning and answer tokens share the output budget.
- Details and sources: https://tokenrex.ai/models/gpt-5.2-fast

### GPT-5.4 — `gpt-5.4`
Affordable frontier model
- Type: chat. Endpoint(s): POST /v1/chat/completions; POST /v1/responses.
- Optional Jev Armour (Beta): add armour:true to /v1/chat/completions (or /v1/responses for supported OpenAI models) and Jev auto-picks this model's thinking level per request. https://tokenrex.ai/features/jev-armour
- How to use: follow the 'Simple chat completion' recipe above and substitute this exact model ID.
- API inputs: Text, Image/PDF content through the chat bridge. API outputs: Text.
- Reviewed context limit: 1050000; output limit: 128000. These are model references; request caps may be lower.
- Note: Published provider limits; maximum-capacity requests have not been independently exercised through TokenRex. Thinking-level variants use the same provider model; reasoning and answer tokens share the output budget.
- Details and sources: https://tokenrex.ai/models/gpt-5.4

### GPT-5.4 Fast — `gpt-5.4-fast`
GPT-5.4 on priority serving for faster replies, balanced thinking — 2x price
- Type: chat. Endpoint(s): POST /v1/chat/completions; POST /v1/responses.
- Optional Jev Armour (Beta): add armour:true to /v1/chat/completions (or /v1/responses for supported OpenAI models) and Jev auto-picks this model's thinking level per request. https://tokenrex.ai/features/jev-armour
- How to use: follow the 'Simple chat completion' recipe above and substitute this exact model ID.
- API inputs: Text, Image/PDF content through the chat bridge. API outputs: Text.
- Reviewed context limit: 1050000; output limit: 128000. These are model references; request caps may be lower.
- Note: Published provider limits; maximum-capacity requests have not been independently exercised through TokenRex. Thinking-level variants use the same provider model; reasoning and answer tokens share the output budget.
- Details and sources: https://tokenrex.ai/models/gpt-5.4-fast

### GPT-5.4 Mini — `gpt-5.4-mini`
Strong mini for high volume
- Type: chat. Endpoint(s): POST /v1/chat/completions; POST /v1/responses.
- Optional Jev Armour (Beta): add armour:true to /v1/chat/completions (or /v1/responses for supported OpenAI models) and Jev auto-picks this model's thinking level per request. https://tokenrex.ai/features/jev-armour
- How to use: follow the 'Simple chat completion' recipe above and substitute this exact model ID.
- API inputs: Text, Image/PDF content through the chat bridge. API outputs: Text.
- Reviewed context limit: 400000; output limit: 128000. These are model references; request caps may be lower.
- Note: Published provider limits; maximum-capacity requests have not been independently exercised through TokenRex. Thinking-level variants use the same provider model; reasoning and answer tokens share the output budget.
- Details and sources: https://tokenrex.ai/models/gpt-5.4-mini

### GPT-5.4 Mini Fast — `gpt-5.4-mini-fast`
GPT-5.4 Mini on priority serving for faster replies, balanced thinking — 2x price
- Type: chat. Endpoint(s): POST /v1/chat/completions; POST /v1/responses.
- Optional Jev Armour (Beta): add armour:true to /v1/chat/completions (or /v1/responses for supported OpenAI models) and Jev auto-picks this model's thinking level per request. https://tokenrex.ai/features/jev-armour
- How to use: follow the 'Simple chat completion' recipe above and substitute this exact model ID.
- API inputs: Text, Image/PDF content through the chat bridge. API outputs: Text.
- Reviewed context limit: 400000; output limit: 128000. These are model references; request caps may be lower.
- Note: Published provider limits; maximum-capacity requests have not been independently exercised through TokenRex. Thinking-level variants use the same provider model; reasoning and answer tokens share the output budget.
- Details and sources: https://tokenrex.ai/models/gpt-5.4-mini-fast

### GPT-5.4 Nano — `gpt-5.4-nano`
Cheapest GPT-5.4 for simple tasks
- Type: chat. Endpoint(s): POST /v1/chat/completions; POST /v1/responses.
- Optional Jev Armour (Beta): add armour:true to /v1/chat/completions (or /v1/responses for supported OpenAI models) and Jev auto-picks this model's thinking level per request. https://tokenrex.ai/features/jev-armour
- How to use: follow the 'Simple chat completion' recipe above and substitute this exact model ID.
- API inputs: Text, Image/PDF content through the chat bridge. API outputs: Text.
- Reviewed context limit: 400000; output limit: 128000. These are model references; request caps may be lower.
- Note: Published provider limits; maximum-capacity requests have not been independently exercised through TokenRex. Thinking-level variants use the same provider model; reasoning and answer tokens share the output budget.
- Details and sources: https://tokenrex.ai/models/gpt-5.4-nano

### GPT-5.4 Pro — `gpt-5.4-pro`
Premium GPT-5.4 deep reasoning
- Type: chat. Endpoint(s): POST /v1/chat/completions; POST /v1/responses.
- Optional Jev Armour (Beta): add armour:true to /v1/chat/completions (or /v1/responses for supported OpenAI models) and Jev auto-picks this model's thinking level per request. https://tokenrex.ai/features/jev-armour
- How to use: follow the 'Simple chat completion' recipe above and substitute this exact model ID.
- API inputs: Text, Image/PDF content through the chat bridge. API outputs: Text.
- Reviewed context limit: 1050000; output limit: 128000. These are model references; request caps may be lower.
- Note: Published provider limits; maximum-capacity requests have not been independently exercised through TokenRex. Thinking-level variants use the same provider model; reasoning and answer tokens share the output budget.
- Details and sources: https://tokenrex.ai/models/gpt-5.4-pro

### GPT-5.5 — `gpt-5.5`
Frontier coding & analysis
- Type: chat. Endpoint(s): POST /v1/chat/completions; POST /v1/responses.
- Optional Jev Armour (Beta): add armour:true to /v1/chat/completions (or /v1/responses for supported OpenAI models) and Jev auto-picks this model's thinking level per request. https://tokenrex.ai/features/jev-armour
- How to use: follow the 'Simple chat completion' recipe above and substitute this exact model ID.
- API inputs: Text, Image/PDF content through the chat bridge. API outputs: Text.
- Reviewed context limit: 1050000; output limit: 128000. These are model references; request caps may be lower.
- Note: Published provider limits; maximum-capacity requests have not been independently exercised through TokenRex. Thinking-level variants use the same provider model; reasoning and answer tokens share the output budget.
- Details and sources: https://tokenrex.ai/models/gpt-5.5

### GPT-5.5 Fast — `gpt-5.5-fast`
GPT-5.5 on priority serving for faster replies, balanced thinking — 2.5x price
- Type: chat. Endpoint(s): POST /v1/chat/completions; POST /v1/responses.
- Optional Jev Armour (Beta): add armour:true to /v1/chat/completions (or /v1/responses for supported OpenAI models) and Jev auto-picks this model's thinking level per request. https://tokenrex.ai/features/jev-armour
- How to use: follow the 'Simple chat completion' recipe above and substitute this exact model ID.
- API inputs: Text, Image/PDF content through the chat bridge. API outputs: Text.
- Reviewed context limit: 1050000; output limit: 128000. These are model references; request caps may be lower.
- Note: Published provider limits; maximum-capacity requests have not been independently exercised through TokenRex. Thinking-level variants use the same provider model; reasoning and answer tokens share the output budget.
- Details and sources: https://tokenrex.ai/models/gpt-5.5-fast

### GPT-5.5 Pro — `gpt-5.5-pro`
Extended-reasoning GPT-5.5 Pro
- Type: chat. Endpoint(s): POST /v1/chat/completions; POST /v1/responses.
- Optional Jev Armour (Beta): add armour:true to /v1/chat/completions (or /v1/responses for supported OpenAI models) and Jev auto-picks this model's thinking level per request. https://tokenrex.ai/features/jev-armour
- How to use: follow the 'Simple chat completion' recipe above and substitute this exact model ID.
- API inputs: Text, Image/PDF content through the chat bridge. API outputs: Text.
- Reviewed context limit: 1050000; output limit: 128000. These are model references; request caps may be lower.
- Note: Published provider limits; maximum-capacity requests have not been independently exercised through TokenRex. Thinking-level variants use the same provider model; reasoning and answer tokens share the output budget.
- Details and sources: https://tokenrex.ai/models/gpt-5.5-pro

### GPT-5.6 Luna — `gpt-5.6-luna`
Fast, low-cost GPT-5.6
- Type: chat. Endpoint(s): POST /v1/chat/completions; POST /v1/responses.
- Optional Jev Armour (Beta): add armour:true to /v1/chat/completions (or /v1/responses for supported OpenAI models) and Jev auto-picks this model's thinking level per request. https://tokenrex.ai/features/jev-armour
- How to use: follow the 'Simple chat completion' recipe above and substitute this exact model ID.
- API inputs: Text, Image/PDF content through the chat bridge. API outputs: Text.
- Reviewed context limit: 1050000; output limit: 128000. These are model references; request caps may be lower.
- Note: Published provider limits; maximum-capacity requests have not been independently exercised through TokenRex. Thinking-level variants use the same provider model; reasoning and answer tokens share the output budget.
- Details and sources: https://tokenrex.ai/models/gpt-5.6-luna

### GPT-5.6 Luna Fast — `gpt-5.6-luna-fast`
GPT-5.6 Luna on priority serving for faster replies, balanced thinking — 2x price
- Type: chat. Endpoint(s): POST /v1/chat/completions; POST /v1/responses.
- Optional Jev Armour (Beta): add armour:true to /v1/chat/completions (or /v1/responses for supported OpenAI models) and Jev auto-picks this model's thinking level per request. https://tokenrex.ai/features/jev-armour
- How to use: follow the 'Simple chat completion' recipe above and substitute this exact model ID.
- API inputs: Text, Image/PDF content through the chat bridge. API outputs: Text.
- Reviewed context limit: 1050000; output limit: 128000. These are model references; request caps may be lower.
- Note: Published provider limits; maximum-capacity requests have not been independently exercised through TokenRex. Thinking-level variants use the same provider model; reasoning and answer tokens share the output budget.
- Details and sources: https://tokenrex.ai/models/gpt-5.6-luna-fast

### GPT-5.6 Sol — `gpt-5.6-sol`
Flagship GPT-5.6 reasoning & agentic
- Type: chat. Endpoint(s): POST /v1/chat/completions; POST /v1/responses.
- Optional Jev Armour (Beta): add armour:true to /v1/chat/completions (or /v1/responses for supported OpenAI models) and Jev auto-picks this model's thinking level per request. https://tokenrex.ai/features/jev-armour
- How to use: follow the 'Simple chat completion' recipe above and substitute this exact model ID.
- API inputs: Text, Image/PDF content through the chat bridge. API outputs: Text.
- Reviewed context limit: 1050000; output limit: 128000. These are model references; request caps may be lower.
- Note: Published provider limits; maximum-capacity requests have not been independently exercised through TokenRex. Thinking-level variants use the same provider model; reasoning and answer tokens share the output budget.
- Details and sources: https://tokenrex.ai/models/gpt-5.6-sol

### GPT-5.6 Sol Fast — `gpt-5.6-sol-fast`
GPT-5.6 Sol on priority serving for faster replies, balanced thinking — 2x price
- Type: chat. Endpoint(s): POST /v1/chat/completions; POST /v1/responses.
- Optional Jev Armour (Beta): add armour:true to /v1/chat/completions (or /v1/responses for supported OpenAI models) and Jev auto-picks this model's thinking level per request. https://tokenrex.ai/features/jev-armour
- How to use: follow the 'Simple chat completion' recipe above and substitute this exact model ID.
- API inputs: Text, Image/PDF content through the chat bridge. API outputs: Text.
- Reviewed context limit: 1050000; output limit: 128000. These are model references; request caps may be lower.
- Note: Published provider limits; maximum-capacity requests have not been independently exercised through TokenRex. Thinking-level variants use the same provider model; reasoning and answer tokens share the output budget.
- Details and sources: https://tokenrex.ai/models/gpt-5.6-sol-fast

### GPT-5.6 Terra — `gpt-5.6-terra`
Balanced everyday GPT-5.6
- Type: chat. Endpoint(s): POST /v1/chat/completions; POST /v1/responses.
- Optional Jev Armour (Beta): add armour:true to /v1/chat/completions (or /v1/responses for supported OpenAI models) and Jev auto-picks this model's thinking level per request. https://tokenrex.ai/features/jev-armour
- How to use: follow the 'Simple chat completion' recipe above and substitute this exact model ID.
- API inputs: Text, Image/PDF content through the chat bridge. API outputs: Text.
- Reviewed context limit: 1050000; output limit: 128000. These are model references; request caps may be lower.
- Note: Published provider limits; maximum-capacity requests have not been independently exercised through TokenRex. Thinking-level variants use the same provider model; reasoning and answer tokens share the output budget.
- Details and sources: https://tokenrex.ai/models/gpt-5.6-terra

### GPT-5.6 Terra Fast — `gpt-5.6-terra-fast`
GPT-5.6 Terra on priority serving for faster replies, balanced thinking — 2x price
- Type: chat. Endpoint(s): POST /v1/chat/completions; POST /v1/responses.
- Optional Jev Armour (Beta): add armour:true to /v1/chat/completions (or /v1/responses for supported OpenAI models) and Jev auto-picks this model's thinking level per request. https://tokenrex.ai/features/jev-armour
- How to use: follow the 'Simple chat completion' recipe above and substitute this exact model ID.
- API inputs: Text, Image/PDF content through the chat bridge. API outputs: Text.
- Reviewed context limit: 1050000; output limit: 128000. These are model references; request caps may be lower.
- Note: Published provider limits; maximum-capacity requests have not been independently exercised through TokenRex. Thinking-level variants use the same provider model; reasoning and answer tokens share the output budget.
- Details and sources: https://tokenrex.ai/models/gpt-5.6-terra-fast

### GPT-6 Astra — `gpt-6-astra`
OpenAI's most capable model for complex reasoning, coding and research — balanced thinking
- Type: chat. Endpoint(s): POST /v1/chat/completions; POST /v1/responses.
- Optional Jev Armour (Beta): add armour:true to /v1/chat/completions (or /v1/responses for supported OpenAI models) and Jev auto-picks this model's thinking level per request. https://tokenrex.ai/features/jev-armour
- How to use: follow the 'Simple chat completion' recipe above and substitute this exact model ID.
- API inputs: Text, Image/PDF content through the chat bridge. API outputs: Text.
- Reviewed context limit: 1050000; output limit: 128000. These are model references; request caps may be lower.
- Note: Published provider limits; maximum-capacity requests have not been independently exercised through TokenRex. Thinking-level variants use the same provider model; reasoning and answer tokens share the output budget.
- Details and sources: https://tokenrex.ai/models/gpt-6-astra

### GPT-6 Astra Fast — `gpt-6-astra-fast`
GPT-6 Astra on priority serving for faster replies — 2x price, balanced thinking
- Type: chat. Endpoint(s): POST /v1/chat/completions; POST /v1/responses.
- Optional Jev Armour (Beta): add armour:true to /v1/chat/completions (or /v1/responses for supported OpenAI models) and Jev auto-picks this model's thinking level per request. https://tokenrex.ai/features/jev-armour
- How to use: follow the 'Simple chat completion' recipe above and substitute this exact model ID.
- API inputs: Text, Image/PDF content through the chat bridge. API outputs: Text.
- Reviewed context limit: 1050000; output limit: 128000. These are model references; request caps may be lower.
- Note: Published provider limits; maximum-capacity requests have not been independently exercised through TokenRex. Thinking-level variants use the same provider model; reasoning and answer tokens share the output budget.
- Details and sources: https://tokenrex.ai/models/gpt-6-astra-fast

### GPT-6 Luna — `gpt-6-luna`
Low-cost GPT-6 model from OpenAI
- Type: chat. Endpoint(s): POST /v1/chat/completions; POST /v1/responses.
- Optional Jev Armour (Beta): add armour:true to /v1/chat/completions (or /v1/responses for supported OpenAI models) and Jev auto-picks this model's thinking level per request. https://tokenrex.ai/features/jev-armour
- How to use: follow the 'Simple chat completion' recipe above and substitute this exact model ID.
- API inputs: Text, Image/PDF content through the chat bridge. API outputs: Text.
- Reviewed context limit: 1050000; output limit: 128000. These are model references; request caps may be lower.
- Note: Published provider limits; maximum-capacity requests have not been independently exercised through TokenRex. Thinking-level variants use the same provider model; reasoning and answer tokens share the output budget.
- Details and sources: https://tokenrex.ai/models/gpt-6-luna

### GPT-6 Luna Fast — `gpt-6-luna-fast`
GPT-6 Luna on priority serving for faster replies, balanced thinking — 2x price
- Type: chat. Endpoint(s): POST /v1/chat/completions; POST /v1/responses.
- Optional Jev Armour (Beta): add armour:true to /v1/chat/completions (or /v1/responses for supported OpenAI models) and Jev auto-picks this model's thinking level per request. https://tokenrex.ai/features/jev-armour
- How to use: follow the 'Simple chat completion' recipe above and substitute this exact model ID.
- API inputs: Text, Image/PDF content through the chat bridge. API outputs: Text.
- Reviewed context limit: 1050000; output limit: 128000. These are model references; request caps may be lower.
- Note: Published provider limits; maximum-capacity requests have not been independently exercised through TokenRex. Thinking-level variants use the same provider model; reasoning and answer tokens share the output budget.
- Details and sources: https://tokenrex.ai/models/gpt-6-luna-fast

### GPT-6 Sol — `gpt-6-sol`
OpenAI's mid-tier GPT-6 model — strong reasoning at a lower price, balanced thinking
- Type: chat. Endpoint(s): POST /v1/chat/completions; POST /v1/responses.
- Optional Jev Armour (Beta): add armour:true to /v1/chat/completions (or /v1/responses for supported OpenAI models) and Jev auto-picks this model's thinking level per request. https://tokenrex.ai/features/jev-armour
- How to use: follow the 'Simple chat completion' recipe above and substitute this exact model ID.
- API inputs: Consult the category recipe and reviewed model details. API outputs: Consult the category recipe.
- Reviewed context limit: Not verified; output limit: Not verified. These are model references; request caps may be lower.
- Details and sources: https://tokenrex.ai/models/gpt-6-sol

### GPT-6 Sol Fast — `gpt-6-sol-fast`
GPT-6 Sol on priority serving for faster replies — 2x price, balanced thinking
- Type: chat. Endpoint(s): POST /v1/chat/completions; POST /v1/responses.
- Optional Jev Armour (Beta): add armour:true to /v1/chat/completions (or /v1/responses for supported OpenAI models) and Jev auto-picks this model's thinking level per request. https://tokenrex.ai/features/jev-armour
- How to use: follow the 'Simple chat completion' recipe above and substitute this exact model ID.
- API inputs: Consult the category recipe and reviewed model details. API outputs: Consult the category recipe.
- Reviewed context limit: Not verified; output limit: Not verified. These are model references; request caps may be lower.
- Details and sources: https://tokenrex.ai/models/gpt-6-sol-fast

### GPT-6.1 Sol — `gpt-6.1-sol`
Near-Astra performance for complex coding and professional work — balanced thinking
- Type: chat. Endpoint(s): POST /v1/chat/completions; POST /v1/responses.
- Optional Jev Armour (Beta): add armour:true to /v1/chat/completions (or /v1/responses for supported OpenAI models) and Jev auto-picks this model's thinking level per request. https://tokenrex.ai/features/jev-armour
- How to use: follow the 'Simple chat completion' recipe above and substitute this exact model ID.
- API inputs: Consult the category recipe and reviewed model details. API outputs: Consult the category recipe.
- Reviewed context limit: 1050000; output limit: 128000. These are model references; request caps may be lower.
- Note: Published provider limits; maximum-capacity requests have not been independently exercised through TokenRex.
- Note: All benchmark scores are self-reported by OpenAI at launch (29 September 2026); TokenRex has not re-run them.
- Details and sources: https://tokenrex.ai/models/gpt-6.1-sol

### GPT-6.1 Sol Fast — `gpt-6.1-sol-fast`
GPT-6.1 Sol on priority serving for faster replies — 2x price, balanced thinking
- Type: chat. Endpoint(s): POST /v1/chat/completions; POST /v1/responses.
- Optional Jev Armour (Beta): add armour:true to /v1/chat/completions (or /v1/responses for supported OpenAI models) and Jev auto-picks this model's thinking level per request. https://tokenrex.ai/features/jev-armour
- How to use: follow the 'Simple chat completion' recipe above and substitute this exact model ID.
- API inputs: Consult the category recipe and reviewed model details. API outputs: Consult the category recipe.
- Reviewed context limit: 1050000; output limit: 128000. These are model references; request caps may be lower.
- Note: Published provider limits; maximum-capacity requests have not been independently exercised through TokenRex.
- Note: All benchmark scores are self-reported by OpenAI at launch (29 September 2026); TokenRex has not re-run them.
- Details and sources: https://tokenrex.ai/models/gpt-6.1-sol-fast

### GPT-6.1 Terra — `gpt-6.1-terra`
Efficient reasoning with image understanding and clear writing
- Type: chat. Endpoint(s): POST /v1/chat/completions; POST /v1/responses.
- Optional Jev Armour (Beta): add armour:true to /v1/chat/completions (or /v1/responses for supported OpenAI models) and Jev auto-picks this model's thinking level per request. https://tokenrex.ai/features/jev-armour
- How to use: follow the 'Simple chat completion' recipe above and substitute this exact model ID.
- API inputs: Text, Image. API outputs: Text.
- Reviewed context limit: 1050000; output limit: 128000. These are model references; request caps may be lower.
- Thinking: Low, Medium, High, Extra high and Max; Max requires Responses. Native none is also accepted.
- Responses: Streaming, function tools, strict JSON and built-in web search verified with direct requests.
- Fast: Priority serving verified as service_tier fast; 2× standard token rates. Bill the tier actually served.
- Note: Official Standard rates per 1M tokens: $1 input, $5 output, $0.05 cached input, $1.25 cache write (30 minutes); current TokenRex offer applies to these rates.
- Note: Above 272,000 input tokens, the entire request uses 2× input/cache rates and 1.5× output rates. Fast adds its 2× token multiplier.
- Note: 12-hour cache writes cost $2.50 per 1M tokens before offer and long-context multipliers; use prompt_cache_options.ttl=12h on Responses. Cached output is not offered.
- Note: Official launch material mentions benchmark comparisons, but no exact-version numeric scores were verified during this review. Benchmark gaps are left empty; no other model scores are inherited.
- Note: Maximum-capacity inputs and outputs, repeated cache hits and hosted computer-use execution were not independently tested.
- Details and sources: https://tokenrex.ai/models/gpt-6.1-terra

### GPT-6.1 Terra Fast — `gpt-6.1-terra-fast`
GPT-6.1 Terra on priority serving for lower latency; 2× standard token rates
- Type: chat. Endpoint(s): POST /v1/chat/completions; POST /v1/responses.
- Optional Jev Armour (Beta): add armour:true to /v1/chat/completions (or /v1/responses for supported OpenAI models) and Jev auto-picks this model's thinking level per request. https://tokenrex.ai/features/jev-armour
- How to use: follow the 'Simple chat completion' recipe above and substitute this exact model ID.
- API inputs: Text, Image. API outputs: Text.
- Reviewed context limit: 1050000; output limit: 128000. These are model references; request caps may be lower.
- Thinking: Low, Medium, High, Extra high and Max; Max requires Responses. Native none is also accepted.
- Responses: Streaming, function tools, strict JSON and built-in web search verified with direct requests.
- Fast: Priority serving verified as service_tier fast; 2× standard token rates. Bill the tier actually served.
- Note: No separate Fast benchmark results are verified; do not inherit Standard scores.
- Note: Priority is billed only when the returned tier is fast or priority.
- Note: Official Standard rates per 1M tokens: $1 input, $5 output, $0.05 cached input, $1.25 cache write (30 minutes); current TokenRex offer applies to these rates.
- Note: Above 272,000 input tokens, the entire request uses 2× input/cache rates and 1.5× output rates. Fast adds its 2× token multiplier.
- Note: 12-hour cache writes cost $2.50 per 1M tokens before offer and long-context multipliers; use prompt_cache_options.ttl=12h on Responses. Cached output is not offered.
- Note: Official launch material mentions benchmark comparisons, but no exact-version numeric scores were verified during this review. Benchmark gaps are left empty; no other model scores are inherited.
- Note: Maximum-capacity inputs and outputs, repeated cache hits and hosted computer-use execution were not independently tested.
- Details and sources: https://tokenrex.ai/models/gpt-6.1-terra-fast

### Jev 1.13 — `jev-1.13`
Typed decisions with probabilities — classification, scoring and routing
- Type: decision. Endpoint(s): POST /v1/decisions.
- How to use: follow the 'Typed decisions (classify / score / route)' recipe above and substitute this exact model ID.
- API inputs: Consult the category recipe and reviewed model details. API outputs: Consult the category recipe.
- Reviewed context limit: Not verified; output limit: Not verified. These are model references; request caps may be lower.
- Note: This is a decision model, not a general chat model. The moving latest ID is not a pinned benchmark version.
- Details and sources: https://tokenrex.ai/models/jev-1.13

### Gemini Embedding 001 — `gemini-embedding-001`
Gemini embeddings (default)
- Type: embedding. Endpoint(s): POST /v1/embeddings.
- How to use: follow the 'Embeddings (vector search)' recipe above and substitute this exact model ID.
- API inputs: Consult the category recipe and reviewed model details. API outputs: Consult the category recipe.
- Reviewed input limit: 2048; output limit: Not verified. These are model references; request caps may be lower.
- Details and sources: https://tokenrex.ai/models/gemini-embedding-001

### Gemini Embedding 2 — `gemini-embedding-2`
Latest Gemini embeddings
- Type: embedding. Endpoint(s): POST /v1/embeddings.
- How to use: follow the 'Embeddings (vector search)' recipe above and substitute this exact model ID.
- API inputs: Consult the category recipe and reviewed model details. API outputs: Consult the category recipe.
- Reviewed context limit: Not verified; output limit: Not verified. These are model references; request caps may be lower.
- Note: Vendor multimodal embeddings do not guarantee the same input surface through TokenRex.
- Details and sources: https://tokenrex.ai/models/gemini-embedding-2

### Text Embedding 3 Large — `text-embedding-3-large`
High-quality embeddings
- Type: embedding. Endpoint(s): POST /v1/embeddings.
- How to use: follow the 'Embeddings (vector search)' recipe above and substitute this exact model ID.
- API inputs: Consult the category recipe and reviewed model details. API outputs: Consult the category recipe.
- Reviewed context limit: Not verified; output limit: Not verified. These are model references; request caps may be lower.
- Details and sources: https://tokenrex.ai/models/text-embedding-3-large

### Text Embedding 3 Small — `text-embedding-3-small`
Lightweight embeddings
- Type: embedding. Endpoint(s): POST /v1/embeddings.
- How to use: follow the 'Embeddings (vector search)' recipe above and substitute this exact model ID.
- API inputs: Consult the category recipe and reviewed model details. API outputs: Consult the category recipe.
- Reviewed context limit: Not verified; output limit: Not verified. These are model references; request caps may be lower.
- Details and sources: https://tokenrex.ai/models/text-embedding-3-small

### Gemini 3 Pro Image — `gemini-3-pro-image`
Highest-quality Gemini image — 1K output
- Type: image. Endpoint(s): POST /v1/images/generations; POST /v1/images/edits.
- How to use: follow the 'Image generation' recipe above and substitute this exact model ID.
- API inputs: Consult the category recipe and reviewed model details. API outputs: Consult the category recipe.
- Reviewed input limit: 65536; output limit: 32768. These are model references; request caps may be lower.
- Details and sources: https://tokenrex.ai/models/gemini-3-pro-image

### Gemini 3 Pro Image 2K — `gemini-3-pro-image-2k`
Gemini 3 Pro Image at 2K resolution (2048 px on the long side for 1:1)
- Type: image. Endpoint(s): POST /v1/images/generations; POST /v1/images/edits.
- How to use: follow the 'Image generation' recipe above and substitute this exact model ID.
- API inputs: Consult the category recipe and reviewed model details. API outputs: Consult the category recipe.
- Reviewed input limit: 65536; output limit: 32768. These are model references; request caps may be lower.
- Details and sources: https://tokenrex.ai/models/gemini-3-pro-image-2k

### Gemini 3 Pro Image 4K — `gemini-3-pro-image-4k`
Gemini 3 Pro Image at 4K resolution (4096 px for 1:1)
- Type: image. Endpoint(s): POST /v1/images/generations; POST /v1/images/edits.
- How to use: follow the 'Image generation' recipe above and substitute this exact model ID.
- API inputs: Consult the category recipe and reviewed model details. API outputs: Consult the category recipe.
- Reviewed input limit: 65536; output limit: 32768. These are model references; request caps may be lower.
- Details and sources: https://tokenrex.ai/models/gemini-3-pro-image-4k

### Gemini 3.1 Flash Image — `gemini-3.1-flash-image`
Nano Banana 2 — fast HQ image, 1K output
- Type: image. Endpoint(s): POST /v1/images/generations; POST /v1/images/edits.
- How to use: follow the 'Image generation' recipe above and substitute this exact model ID.
- API inputs: Consult the category recipe and reviewed model details. API outputs: Consult the category recipe.
- Reviewed context limit: Not verified; output limit: Not verified. These are model references; request caps may be lower.
- Note: The reviewed discovery source does not verify every specification for this exact TokenRex ID. Missing fields have not been inferred from other releases.
- Details and sources: https://tokenrex.ai/models/gemini-3.1-flash-image

### Gemini 3.1 Flash Image 2K — `gemini-3.1-flash-image-2k`
Nano Banana 2 at 2K resolution (2048 px for 1:1)
- Type: image. Endpoint(s): POST /v1/images/generations; POST /v1/images/edits.
- How to use: follow the 'Image generation' recipe above and substitute this exact model ID.
- API inputs: Consult the category recipe and reviewed model details. API outputs: Consult the category recipe.
- Reviewed context limit: Not verified; output limit: Not verified. These are model references; request caps may be lower.
- Note: The reviewed discovery source does not verify every specification for this exact TokenRex ID. Missing fields have not been inferred from other releases.
- Details and sources: https://tokenrex.ai/models/gemini-3.1-flash-image-2k

### Gemini 3.1 Flash Image 4K — `gemini-3.1-flash-image-4k`
Nano Banana 2 at 4K resolution (4096 px for 1:1)
- Type: image. Endpoint(s): POST /v1/images/generations; POST /v1/images/edits.
- How to use: follow the 'Image generation' recipe above and substitute this exact model ID.
- API inputs: Consult the category recipe and reviewed model details. API outputs: Consult the category recipe.
- Reviewed context limit: Not verified; output limit: Not verified. These are model references; request caps may be lower.
- Note: The reviewed discovery source does not verify every specification for this exact TokenRex ID. Missing fields have not been inferred from other releases.
- Details and sources: https://tokenrex.ai/models/gemini-3.1-flash-image-4k

### Gemini 3.1 Flash Lite Image — `gemini-3.1-flash-lite-image`
Nano Banana 2 Lite — cheapest, 1K only
- Type: image. Endpoint(s): POST /v1/images/generations; POST /v1/images/edits.
- How to use: follow the 'Image generation' recipe above and substitute this exact model ID.
- API inputs: Consult the category recipe and reviewed model details. API outputs: Consult the category recipe.
- Reviewed context limit: Not verified; output limit: Not verified. These are model references; request caps may be lower.
- Note: The reviewed discovery source does not verify every specification for this exact TokenRex ID. Missing fields have not been inferred from other releases.
- Details and sources: https://tokenrex.ai/models/gemini-3.1-flash-lite-image

### GPT Image 1 Mini — `gpt-image-1-mini`
Cost-efficient OpenAI image gen — billed by tokens (being retired upstream)
- Type: image. Endpoint(s): POST /v1/images/generations; POST /v1/images/edits.
- How to use: follow the 'Image generation' recipe above and substitute this exact model ID.
- API inputs: Consult the category recipe and reviewed model details. API outputs: Consult the category recipe.
- Reviewed context limit: Not verified; output limit: Not verified. These are model references; request caps may be lower.
- Details and sources: https://tokenrex.ai/models/gpt-image-1-mini

### GPT Image 2 — `gpt-image-2`
Highest-quality OpenAI image gen — Low/Medium/High quality, billed by tokens
- Type: image. Endpoint(s): POST /v1/images/generations; POST /v1/images/edits.
- How to use: follow the 'Image generation' recipe above and substitute this exact model ID.
- API inputs: Consult the category recipe and reviewed model details. API outputs: Consult the category recipe.
- Reviewed context limit: Not verified; output limit: Not verified. These are model references; request caps may be lower.
- Details and sources: https://tokenrex.ai/models/gpt-image-2

### GPT Image 2.5 Flare — `gpt-image-2.5-flare`
Latency-first OpenAI image generation and editing — Low to Max quality, billed by tokens
- Type: image. Endpoint(s): POST /v1/images/generations; POST /v1/images/edits.
- How to use: follow the 'Image generation' recipe above and substitute this exact model ID.
- API inputs: Consult the category recipe and reviewed model details. API outputs: Consult the category recipe.
- Reviewed context limit: Not verified; output limit: Not verified. These are model references; request caps may be lower.
- Details and sources: https://tokenrex.ai/models/gpt-image-2.5-flare

### GPT Image 2.5 Sunburst — `gpt-image-2.5-sunburst`
Quality-first OpenAI image generation and editing — Low to Max quality, billed by tokens
- Type: image. Endpoint(s): POST /v1/images/generations; POST /v1/images/edits.
- How to use: follow the 'Image generation' recipe above and substitute this exact model ID.
- API inputs: Consult the category recipe and reviewed model details. API outputs: Consult the category recipe.
- Reviewed context limit: Not verified; output limit: Not verified. These are model references; request caps may be lower.
- Details and sources: https://tokenrex.ai/models/gpt-image-2.5-sunburst

### GPT Image 2.6 Flare — `gpt-image-2.6-flare`
Latency-first image generation and editing with complexity, markup and animated GIF controls
- Type: image. Endpoint(s): POST /v1/images/generations; POST /v1/images/edits.
- How to use: follow the 'Image generation' recipe above and substitute this exact model ID.
- API inputs: Text prompt, Reference images, PNG mask or transparent PNG markup. API outputs: PNG, JPEG, WebP, Animated GIF.
- Reviewed context limit: Not verified; output limit: Not verified. These are model references; request caps may be lower.
- Positioning: Latency-first
- Rendering quality: Auto, Low, Medium, High, XHigh, Max
- Planning complexity: Low, Medium, High (provider default High)
- Animation: 2–16 GIF frames; 20–2,000 ms per frame
- Transparency: PNG, WebP and GIF; not JPEG
- Editing: Ordered references, mask or markup; not mask and markup together
- Note: SVG is described by OpenAI but unavailable through the current image service.
- Note: Official Standard rates per 1M tokens: $5 text input, $8 image input, $30 image output. Official cached rates: $1.25 text and $2 image; TokenRex does not currently offer verified cache discounts for this model, so normal input rates apply. No cached output rate.
- Note: No exact-version independently sourced benchmark score was verified. Earlier functional tests are not benchmark rankings or guarantees of identity preservation.
- Note: Raster sizes: multiples of 16, aspect ratio 1:3–3:1, at most 3840 per edge and 655,360–8,294,400 pixels. GIF has a separate total animation pixel budget; prefer auto.
- Note: GIF requests use completed JSON; the Playground uses owner-scoped saved jobs. Polling and reopening never regenerate.
- Details and sources: https://tokenrex.ai/models/gpt-image-2.6-flare

### GPT Image 2.6 Sunburst — `gpt-image-2.6-sunburst`
Quality-first image generation and editing with complexity, markup and animated GIF controls
- Type: image. Endpoint(s): POST /v1/images/generations; POST /v1/images/edits.
- How to use: follow the 'Image generation' recipe above and substitute this exact model ID.
- API inputs: Text prompt, Reference images, PNG mask or transparent PNG markup. API outputs: PNG, JPEG, WebP, Animated GIF.
- Reviewed context limit: Not verified; output limit: Not verified. These are model references; request caps may be lower.
- Positioning: Quality-first
- Rendering quality: Auto, Low, Medium, High, XHigh, Max
- Planning complexity: Low, Medium, High (provider default High)
- Animation: 2–16 GIF frames; 20–2,000 ms per frame
- Transparency: PNG, WebP and GIF; not JPEG
- Editing: Ordered references, mask or markup; not mask and markup together
- Note: SVG is described by OpenAI but unavailable through the current image service.
- Note: Official Standard rates per 1M tokens: $5 text input, $8 image input, $30 image output. Official cached rates: $1.25 text and $2 image; TokenRex does not currently offer verified cache discounts for this model, so normal input rates apply. No cached output rate.
- Note: No exact-version independently sourced benchmark score was verified. Earlier functional tests are not benchmark rankings or guarantees of identity preservation.
- Note: Raster sizes: multiples of 16, aspect ratio 1:3–3:1, at most 3840 per edge and 655,360–8,294,400 pixels. GIF has a separate total animation pixel budget; prefer auto.
- Note: GIF requests use completed JSON; the Playground uses owner-scoped saved jobs. Polling and reopening never regenerate.
- Details and sources: https://tokenrex.ai/models/gpt-image-2.6-sunburst

### Seedream 5 Pro — `seedream-5-pro`
ByteDance image generation and reference-guided editing with accurate text — 1K, 2K or custom size, up to 10 references, one JPEG
- Type: image. Endpoint(s): POST /v1/images/generations; POST /v1/images/edits.
- How to use: follow the 'Image generation' recipe above and substitute this exact model ID.
- API inputs: Prompt (required), Up to 10 ordered reference images (URL or data URL), Size 1K, 2K or WIDTHxHEIGHT, Watermark on or off. API outputs: One JPEG as base64.
- Reviewed context limit: Not verified; output limit: Not verified. These are model references; request caps may be lower.
- Images per request: Exactly one
- Reference images: 1–10, order preserved
- Sizes: 1K, 2K or WIDTHxHEIGHT
- Streaming: Completed image only (image_generation.completed)
- Note: Functional test through TokenRex (2026-11-11): a 1K text-to-image request returned an 832×1248 JPEG poster with the requested headline, and a one-reference edit returned the edited JPEG. These are working checks, not quality benchmarks.
- Note: 1K and 2K set the output scale and are not exact squares; a custom WIDTHxHEIGHT size such as 1536x864 is accepted.
- Note: Quality, masks, transparency, output format, seed, negative prompts and multiple outputs are not supported and are refused.
- Details and sources: https://tokenrex.ai/models/seedream-5-pro

### GPT Live 1 — `gpt-live-1`
Real-time two-way voice conversation — phone-call style, billed per second
- Type: live. Endpoint(s): WebSocket /v1/live.
- How to use: follow the 'Live voice & tools (GPT Live 1)' recipe above and substitute this exact model ID.
- API inputs: Consult the category recipe and reviewed model details. API outputs: Consult the category recipe.
- Reviewed context limit: Not verified; output limit: Not verified. These are model references; request caps may be lower.
- Note: Full-duplex voice model: listens and speaks simultaneously, with interruption (barge-in), silence and background-noise handling and a native speech transcript.
- Note: Audio-only: no image or video input, no image or video generation, no fine-tuning, no structured outputs.
- Note: Supports function calling and backend model delegation; web/tool use runs through the delegated backend. Reasoning in vendor benchmarks delegates to GPT-6 Astra.
- Note: Connects over WebRTC, WebSocket or SIP; telephony partner integrations include LiveKit, Twilio, Telnyx and Daily/Pipecat.
- Note: Voices: Marin (default), Quartz, Ripple, Vesper, Willow, Stone, Gleam, Meridian, Bossa, Tempo, Beacon, Delta and Cinder; custom voices supported.
- Note: Official price $0.05 per minute, billed per second. TokenRex applies its current model discount to that rate; the live TokenRex price is shown on this page. Backend model and tool usage is billed separately.
- Details and sources: https://tokenrex.ai/models/gpt-live-1

### GPT Live 1 Transcribe — `gpt-live-1-transcribe`
TokenRex's live speech-to-text mode built on GPT Live 1. Microphone audio becomes streaming transcripts; playback must be muted by the client.
- Type: live. Endpoint(s): WebSocket /v1/live.
- How to use: follow the gpt-live-1-transcribe connection example above; do not use the conversation tool example.
- API inputs: Live microphone audio. API outputs: Streaming text transcripts.
- Reviewed context limit: Not verified; output limit: Not verified. These are model references; request caps may be lower.
- Underlying model: GPT Live 1
- Mode developed by: TokenRex
- Task: Speech-to-text (STT)
- Transport: Live WebSocket signaling + WebRTC audio
- Note: A TokenRex instruction-based mode, not a separately trained OpenAI model or native standalone speech endpoint.
- Note: Connected time is billed per second with a 15-second minimum; idle time and muted playback remain billable.
- Note: Exact reading and permanent model silence are not guaranteed. Transcription clients must suppress playback.
- Details and sources: https://tokenrex.ai/models/gpt-live-1-transcribe

### GPT Live 1 Voice — `gpt-live-1-voice`
TokenRex's live text-to-speech mode built on GPT Live 1. Send text over an active session and play incoming speech without waiting for a completed recording.
- Type: live. Endpoint(s): WebSocket /v1/live.
- How to use: follow the gpt-live-1-voice connection example above; do not use the conversation tool example.
- API inputs: Text via tokenrex.speak. API outputs: Streaming live audio, Output transcript events.
- Reviewed context limit: Not verified; output limit: Not verified. These are model references; request caps may be lower.
- Underlying model: GPT Live 1
- Mode developed by: TokenRex
- Task: Text-to-speech (TTS)
- Transport: Live WebSocket signaling + WebRTC audio
- Note: A TokenRex instruction-based mode, not a separately trained OpenAI model or native standalone speech endpoint.
- Note: Connected time is billed per second with a 15-second minimum; idle time and muted playback remain billable.
- Note: Exact reading and permanent model silence are not guaranteed. Transcription clients must suppress playback.
- Details and sources: https://tokenrex.ai/models/gpt-live-1-voice

### Lyria 3 Clip — `lyria-3-clip-preview`
30-second music clips, loops and previews — vocals or instrumentals, from text or an image
- Type: music. Endpoint(s): POST /v1/music.
- How to use: follow the 'Music generation (Lyria 3)' recipe above and substitute this exact model ID.
- API inputs: Text prompt (up to 4,000 characters), Optional image. API outputs: MP3 audio (binary response).
- Reviewed input limit: 131072; output limit: Not verified. These are model references; request caps may be lower.
- Track duration: About 30 seconds
- Audio response: MP3
- Prompt limit through TokenRex: 4,000 characters
- Length control: Describe the length in the prompt; no duration parameter
- Note: The provider publishes a 131,072-token input limit, but TokenRex accepts music prompts of at most 4,000 characters. These are different limits, not conflicting measurements.
- Note: The provider supports lyrics text, but TokenRex returns the audio response only; a separate lyrics field is not exposed.
- Note: Google documents the nominal duration; the length of each generated file may vary slightly.
- Details and sources: https://tokenrex.ai/models/lyria-3-clip-preview

### Lyria 3 Pro — `lyria-3-pro-preview`
Full-length songs up to ~3 minutes with verses, choruses and timed lyrics
- Type: music. Endpoint(s): POST /v1/music.
- How to use: follow the 'Music generation (Lyria 3)' recipe above and substitute this exact model ID.
- API inputs: Text prompt (up to 4,000 characters), Optional image. API outputs: MP3 audio (binary response).
- Reviewed input limit: 131072; output limit: Not verified. These are model references; request caps may be lower.
- Track duration: Up to 184 seconds (3:04)
- Audio response: MP3
- Prompt limit through TokenRex: 4,000 characters
- Length control: Describe the length in the prompt; no duration parameter
- Note: The provider publishes a 131,072-token input limit, but TokenRex accepts music prompts of at most 4,000 characters. These are different limits, not conflicting measurements.
- Note: The provider supports lyrics text, but TokenRex returns the audio response only; a separate lyrics field is not exposed.
- Note: Google documents the nominal duration; the length of each generated file may vary slightly.
- Details and sources: https://tokenrex.ai/models/lyria-3-pro-preview

### Gemini 3.5 Transcribe — `gemini-3.5-transcribe`
Auto language detection across 85+ languages
- Type: stt. Endpoint(s): POST /v1/audio/transcriptions.
- How to use: follow the 'Speech-to-Text (STT)' recipe above and substitute this exact model ID.
- API inputs: Consult the category recipe and reviewed model details. API outputs: Consult the category recipe.
- Reviewed context limit: Not verified; output limit: Not verified. These are model references; request caps may be lower.
- Note: The reviewed discovery source does not verify every specification for this exact TokenRex ID. Missing fields have not been inferred from other releases.
- Details and sources: https://tokenrex.ai/models/gemini-3.5-transcribe

### GPT-4o Mini Transcribe — `gpt-4o-mini-transcribe`
Cost-efficient speech-to-text
- Type: stt. Endpoint(s): POST /v1/audio/transcriptions.
- How to use: follow the 'Speech-to-Text (STT)' recipe above and substitute this exact model ID.
- API inputs: Consult the category recipe and reviewed model details. API outputs: Consult the category recipe.
- Reviewed context limit: 16000; output limit: 2000. These are model references; request caps may be lower.
- Details and sources: https://tokenrex.ai/models/gpt-4o-mini-transcribe

### GPT-4o Transcribe — `gpt-4o-transcribe`
High-accuracy speech-to-text
- Type: stt. Endpoint(s): POST /v1/audio/transcriptions.
- How to use: follow the 'Speech-to-Text (STT)' recipe above and substitute this exact model ID.
- API inputs: Consult the category recipe and reviewed model details. API outputs: Consult the category recipe.
- Reviewed context limit: 16000; output limit: 2000. These are model references; request caps may be lower.
- Details and sources: https://tokenrex.ai/models/gpt-4o-transcribe

### GPT Transcribe — `gpt-transcribe`
Latest OpenAI speech-to-text — context, keyword and language hints for names & specialist words
- Type: stt. Endpoint(s): POST /v1/audio/transcriptions.
- How to use: follow the 'Speech-to-Text (STT)' recipe above and substitute this exact model ID.
- API inputs: Consult the category recipe and reviewed model details. API outputs: Consult the category recipe.
- Reviewed context limit: Not verified; output limit: Not verified. These are model references; request caps may be lower.
- Details and sources: https://tokenrex.ai/models/gpt-transcribe

### Gemini 2.5 Flash TTS — `gemini-2.5-flash-tts`
Fast Gemini TTS
- Type: tts. Endpoint(s): POST /v1/audio/speech.
- How to use: follow the 'Text-to-Speech (TTS)' recipe above and substitute this exact model ID.
- API inputs: Consult the category recipe and reviewed model details. API outputs: Consult the category recipe.
- Reviewed input limit: 8192; output limit: 16384. These are model references; request caps may be lower.
- Note: TokenRex uses a gateway model ID; the vendor documentation uses a preview-TTS ID. Audio compatibility must be checked for the gateway route.
- Details and sources: https://tokenrex.ai/models/gemini-2.5-flash-tts

### Gemini 2.5 Pro TTS — `gemini-2.5-pro-tts`
High-quality Gemini TTS
- Type: tts. Endpoint(s): POST /v1/audio/speech.
- How to use: follow the 'Text-to-Speech (TTS)' recipe above and substitute this exact model ID.
- API inputs: Consult the category recipe and reviewed model details. API outputs: Consult the category recipe.
- Reviewed input limit: 8192; output limit: 16384. These are model references; request caps may be lower.
- Note: TokenRex uses a gateway model ID; the vendor documentation uses a preview-TTS ID. Audio compatibility must be checked for the gateway route.
- Details and sources: https://tokenrex.ai/models/gemini-2.5-pro-tts

### Gemini 3.1 Flash TTS — `gemini-3.1-flash-tts-preview`
Latest Gemini TTS preview
- Type: tts. Endpoint(s): POST /v1/audio/speech.
- How to use: follow the 'Text-to-Speech (TTS)' recipe above and substitute this exact model ID.
- API inputs: Consult the category recipe and reviewed model details. API outputs: Consult the category recipe.
- Reviewed context limit: Not verified; output limit: Not verified. These are model references; request caps may be lower.
- Note: The reviewed discovery source does not verify every specification for this exact TokenRex ID. Missing fields have not been inferred from other releases.
- Details and sources: https://tokenrex.ai/models/gemini-3.1-flash-tts-preview

### GPT-4o Mini TTS — `gpt-4o-mini-tts`
OpenAI streaming TTS
- Type: tts. Endpoint(s): POST /v1/audio/speech.
- How to use: follow the 'Text-to-Speech (TTS)' recipe above and substitute this exact model ID.
- API inputs: Consult the category recipe and reviewed model details. API outputs: Consult the category recipe.
- Reviewed context limit: Not verified; output limit: Not verified. These are model references; request caps may be lower.
- Details and sources: https://tokenrex.ai/models/gpt-4o-mini-tts

### Gemini Omni 1.1 Flash — `gemini-omni-1.1-flash`
Fast low-cost video gen, edit & extend — 360p drafts to 4K
- Type: video. Endpoint(s): POST /v1/videos; GET /v1/videos/{id}.
- How to use: follow the 'Video generation (Veo 3.1)' recipe above and substitute this exact model ID.
- API inputs: Text prompt, Optional base64 image. API outputs: Asynchronous video job; retrieve the completed result.
- Reviewed context limit: Not verified; output limit: Not verified. These are model references; request caps may be lower.
- Duration accepted by TokenRex: 3–10 seconds (whole seconds)
- Resolution accepted by TokenRex: 360p, 720p, 1080p or 4K
- Default request: 8 seconds at 720p
- Audio control: Model-generated audio
- Note: These durations and resolutions are accepted by the TokenRex endpoint; they are not fresh generation measurements.
- Note: TokenRex does not expose provider video extension, reference-image arrays or first/last-frame controls.
- Note: Duration is rounded and clamped to 3–10 seconds. The Omni request does not forward generate_audio, seed or negative_prompt; do not assume Veo-specific controls apply.
- Details and sources: https://tokenrex.ai/models/gemini-omni-1.1-flash

### Seedance 2.5 — `seedance-2.5`
ByteDance video with synchronized audio — 480p/720p, 4–30s or automatic length, first/last frames and image, video and audio references
- Type: video. Endpoint(s): POST /v1/videos; GET /v1/videos/{id}.
- How to use: follow the 'Video generation (Veo 3.1)' recipe above and substitute this exact model ID.
- API inputs: Prompt up to 25,000 characters (optional with references), First frame and optional last frame, Up to 30 ordered reference images, Up to 10 reference videos (public HTTPS, 30 s combined), Up to 10 reference audio clips (30 s combined). API outputs: Asynchronous video job; poll, then download the MP4.
- Reviewed context limit: Not verified; output limit: Not verified. These are model references; request caps may be lower.
- Duration accepted by TokenRex: 4–30 seconds, or Auto (-1)
- Resolution accepted by TokenRex: 480p or 720p
- Aspect ratios: 16:9, 4:3, 1:1, 3:4, 9:16, 21:9 or adaptive
- Frame rate and format: 24 fps MP4 only
- Sound: generate_audio on or off
- Note: Functional test through TokenRex (2026-11-11): a 4-second 480p job with sound and one reference image completed in about 2 minutes and downloaded as an 854×480, 24 fps MP4 with AAC audio. This is a working check, not a quality benchmark.
- Note: A request whose generated sound resembled copyrighted music was refused by the provider's safety check; refused jobs are not charged.
- Note: 720p, reference-video and reference-audio requests are accepted by validation but were not rendered in TokenRex's own tests.
- Note: camera_fixed is accepted but has no observed effect. use_virtual_avatar is a provider policy option and does not bypass real-person or deepfake restrictions.
- Details and sources: https://tokenrex.ai/models/seedance-2.5

### Starlight Fast 2 — `starlight-fast-2`
Topaz Labs restoration and upscaling of existing footage to 1080p or 4K tiers — not text-to-video
- Type: video. Endpoint(s): POST /v1/videos; GET /v1/videos/{id}.
- How to use: follow the 'Video generation (Veo 3.1)' recipe above and substitute this exact model ID.
- API inputs: Public HTTPS source video up to 600 seconds, Exact source container, size, frame count and frame rate, Inclusive frame range, Target tier 1920x1080 or 3840x2160. API outputs: Asynchronous video job; poll, then download the MP4.
- Reviewed context limit: Not verified; output limit: Not verified. These are model references; request caps may be lower.
- Target tiers: 1080p (1920x1080) or 4K (3840x2160); shape and frame rate are kept
- Upscaling factor: 1 only
- Containers: MP4, MOV, MKV, WebM, AVI and 16 more
- Job length: Can take hours; jobs keep running after you close the page
- Note: Functional test through TokenRex (2026-11-11): frames 0–29 of a 640×360, 30 fps MP4 restored to a 1920×1080, 30 fps MP4 with 30 frames in about 75 seconds. This is a working check, not a quality benchmark.
- Note: Restoration only: it does not create new scenes, sound or extra frames, and it takes no prompt.
- Note: Source size, frame count and frame rate must be the real values from the file; TokenRex never estimates them.
- Details and sources: https://tokenrex.ai/models/starlight-fast-2

### Veo 3.1 — `veo-3.1`
Highest-quality Veo video
- Type: video. Endpoint(s): POST /v1/videos; GET /v1/videos/{id}.
- How to use: follow the 'Video generation (Veo 3.1)' recipe above and substitute this exact model ID.
- API inputs: Text prompt, Optional base64 image. API outputs: Asynchronous video job; retrieve the completed result.
- Reviewed context limit: Not verified; output limit: Not verified. These are model references; request caps may be lower.
- Duration accepted by TokenRex: 4, 6 or 8 seconds
- Resolution accepted by TokenRex: 720p, 1080p or 4K
- Default request: 8 seconds at 720p
- Audio control: Enabled by default; generate_audio can disable it
- Note: These durations and resolutions are accepted by the TokenRex endpoint; they are not fresh generation measurements.
- Note: TokenRex does not expose provider video extension, reference-image arrays or first/last-frame controls.
- Note: TokenRex’s endpoint requires 8 seconds for 1080p and 4K; this is its validation rule, not a claim about every upstream interface. Unsupported duration values are normalized to 8 seconds.
- Details and sources: https://tokenrex.ai/models/veo-3.1

### Veo 3.1 Fast — `veo-3.1-fast`
Faster, cheaper Veo video
- Type: video. Endpoint(s): POST /v1/videos; GET /v1/videos/{id}.
- How to use: follow the 'Video generation (Veo 3.1)' recipe above and substitute this exact model ID.
- API inputs: Text prompt, Optional base64 image. API outputs: Asynchronous video job; retrieve the completed result.
- Reviewed context limit: Not verified; output limit: Not verified. These are model references; request caps may be lower.
- Duration accepted by TokenRex: 4, 6 or 8 seconds
- Resolution accepted by TokenRex: 720p, 1080p or 4K
- Default request: 8 seconds at 720p
- Audio control: Enabled by default; generate_audio can disable it
- Note: These durations and resolutions are accepted by the TokenRex endpoint; they are not fresh generation measurements.
- Note: TokenRex does not expose provider video extension, reference-image arrays or first/last-frame controls.
- Note: TokenRex’s endpoint requires 8 seconds for 1080p and 4K; this is its validation rule, not a claim about every upstream interface. Unsupported duration values are normalized to 8 seconds.
- Details and sources: https://tokenrex.ai/models/veo-3.1-fast

### Veo 3.1 Lite — `veo-3.1-lite`
Cheapest Veo video
- Type: video. Endpoint(s): POST /v1/videos; GET /v1/videos/{id}.
- How to use: follow the 'Video generation (Veo 3.1)' recipe above and substitute this exact model ID.
- API inputs: Text prompt, Optional base64 image. API outputs: Asynchronous video job; retrieve the completed result.
- Reviewed context limit: Not verified; output limit: Not verified. These are model references; request caps may be lower.
- Duration accepted by TokenRex: 4, 6 or 8 seconds
- Resolution accepted by TokenRex: 720p or 1080p
- Default request: 8 seconds at 720p
- Audio control: Enabled by default; generate_audio can disable it
- Note: These durations and resolutions are accepted by the TokenRex endpoint; they are not fresh generation measurements.
- Note: TokenRex does not expose provider video extension, reference-image arrays or first/last-frame controls.
- Note: TokenRex’s endpoint requires 8 seconds for 1080p and 4K; this is its validation rule, not a claim about every upstream interface. Unsupported duration values are normalized to 8 seconds.
- Note: 4K requests are rejected for Veo 3.1 Lite.
- Details and sources: https://tokenrex.ai/models/veo-3.1-lite