Quickstart

Get connected in three steps

Step 1 — Get your API key

1.1 Sign in to the tokgate.io console

Open console.tokgate.io and sign in with email + password or a Google account. If you don't have an account yet, click "Sign up free"; the registration method is determined by the platform's current policy:

• Open registration: enter your email → click "Get verification code" → enter the code from the email → set a password.
• Invite registration: an invite code is required.
• Registration requires agreeing to the Terms of Service and the Privacy Policy.

1.2 Create an API key

After signing in, go to "Keys & Resources › API Keys" in the left navigation and click "Create key" in the upper right. The dialog lets you configure:

1.3 Save your API key

After submitting, a "Key created" dialog appears. The plaintext key starts with sk- — click the copy button next to it to copy it.

Step 2 — Make your first API call

Choose the protocol by model vendor first. This section uses a DeepSeek model to demonstrate the OpenAI-compatible format. For Anthropic and Google models, use Anthropic Messages and the native Gemini format respectively; do not reuse the request body below.

2.1 List available models

Browse all models in the Model Catalog, or filter by vendor, check context lengths and USD unit prices, and copy model IDs with one click on the console's "Models › Model Catalog" page. To fetch them dynamically in code, call the models endpoint directly:

curl https://api.tokgate.io/v1/models \
-H "Authorization: Bearer sk-***"

The id field in the response is the model name to pass when calling.

2.2 Make your first request

curl https://api.tokgate.io/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer sk-***" \
  -d '{
    "model": "deepseek-v4-pro",
    "messages": [
      {"role": "system", "content": "You are a helpful assistant"},
      {"role": "user", "content": "Hello, introduce yourself"}
    ]
  }'

from openai import OpenAI

client = OpenAI(
    api_key="sk-***",
    base_url="https://api.tokgate.io/v1",
)

response = client.chat.completions.create(
    model="deepseek-v4-pro",
    messages=[{"role": "user", "content": "Hello, introduce yourself"}],
)
print(response.choices[0].message.content)

import OpenAI from "openai";

const client = new OpenAI({
  apiKey: process.env.TOKGATE_API_KEY,
  baseURL: "https://api.tokgate.io/v1",
});

const response = await client.chat.completions.create({
  model: "deepseek-v4-pro",
  messages: [{ role: "user", content: "Hello, introduce yourself" }],
});
console.log(response.choices[0].message.content);

package main

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

func main() {
    cfg := openai.DefaultConfig("sk-***")
    cfg.BaseURL = "https://api.tokgate.io/v1"
    client := openai.NewClientWithConfig(cfg)

    resp, err := client.CreateChatCompletion(context.Background(),
        openai.ChatCompletionRequest{
            Model: "deepseek-v4-pro",
            Messages: []openai.ChatCompletionMessage{
                {Role: "user", Content: "Hello, introduce yourself"},
            },
        })
    if err != nil {
        panic(err)
    }
    fmt.Println(resp.Choices[0].Message.Content)
}

Step 3 — Connect your tools

Your client or SDK must support the protocol required by the target model. All three protocols share one API key, but their base URLs, paths and request bodies differ:

Claude Code / Codex CLI

Configure these command-line coding assistants using environment variables. Claude Code uses the Anthropic protocol, while Codex CLI uses the OpenAI protocol.

# Claude Code (Anthropic protocol)
export ANTHROPIC_BASE_URL="https://api.tokgate.io"
export ANTHROPIC_AUTH_TOKEN="sk-***"

# Codex CLI (OpenAI protocol)
export OPENAI_BASE_URL="https://api.tokgate.io/v1"
export OPENAI_API_KEY="sk-***"

Desktop clients such as Cherry Studio

1. Open "Settings › Model Providers › Add Provider".
2. The provider type must match the model vendor: Anthropic for Anthropic models, Gemini for Google models, and OpenAI-compatible for other LLMs.
3. Use the matching base URL from the table above and the same API key created in the console.
4. Add the model IDs you want to use (from GET /v1/models or the Model Catalog).

Other clients and SDKs

Whether LangChain, LlamaIndex, Vercel AI SDK, Dify, FastGPT, NextChat or LobeChat can connect depends on support for the target model protocol and a custom base URL. Use the matching OpenAI, Anthropic or Google Gen AI SDK; do not call Anthropic or Google models with an OpenAI request body. With the Google Gen AI SDK you must also override the x-goog-api-key header it sends by default with Authorization: Bearer, otherwise the request returns 401.

Account & billing

The platform uses a single Credits-based billing mode. Fixed USD top-ups are converted at 1 USD = 200 Credits, and Credits are deducted for each call at the model’s published rate.

• Top up Credits: open "Billing Center › Credits & Orders", choose one of the fixed USD amounts shown and complete payment. Credits arrive at 1 USD = 200 Credits.
• No bonus ratio: Credits use only the fixed conversion rate; larger top-up tiers do not add bonus Credits.
• Transactions & orders: Credits transactions record top-ups, call deductions, fees, holds, settlements and releases; the orders page shows order number, amount, platform fee, channel and payment status.
• Unit price basis: the Model Catalog lists four unit prices per model — input, output, cache read and cache write — in "USD / per million tokens". Prices differ by model; actual deductions follow the console details.

Usage & Reports

In the console's "Billing Center › Usage & Reports" you can see:

• Summary cards: total requests, total tokens, total Credits consumed and the current Credits balance.
• Reports use UTC and cover the last 30 days by default. Group results by date to view trend charts, or by model or key to view sortable tables.
• Call details (in local time): time, model, key prefix, input tokens, output tokens, Credits consumed, latency (ms) and success/failure status, filterable by time range and model.
• CSV export: export usage data under the current filters with one click for your own reconciliation.

Console feature map

API capabilities at a glance

For full parameters, response structures and error codes, see the API Reference.

FAQ

How do I know which models are available to me?

Three ways: call GET /v1/models (which returns the models actually available to the current key); browse and copy model IDs in the console's "Model Catalog"; or check the Model Catalog on the website. If you set a model whitelist when creating the key, models outside the whitelist will not appear in that key's available list.

How to troubleshoot a 401 Unauthorized?

• Does the auth header match the protocol? OpenAI and Gemini use Authorization: Bearer ..., while Anthropic uses x-api-key.
• Was the key copied in full (the plaintext is shown only once — a truncated key keeps returning 401)?
• Has the key been deleted, disabled or expired?
• Did you mistake the console login session for API authentication? Model endpoints only accept API keys, not login cookies.
• When calling Gemini native endpoints, did you accidentally send x-goog-api-key? Its presence alone returns 401, even alongside a valid Authorization: Bearer header. Google's official Gen AI SDK sends it by default and must be overridden.

How to troubleshoot a 403 Forbidden?

This is usually a scope issue: the key has a model whitelist and the requested model is not in it, or the model is not enabled for your account. Edit the whitelist on the console's "API Keys" page, or switch to a key without model restrictions.

Getting a 402 / insufficient quota message?

Your Credits balance is insufficient, or this key's spending quota has been used up. For the former, top up Credits under "Credits & Orders"; for the latter, edit the key to raise the quota. A key running out of quota affects only that key, not other keys on the account.

Getting a 429 Too Many Requests?

You hit the key's RPM rate limit or an upstream concurrency cap. Implement exponential backoff retries on the client (e.g. 1s, 2s, 4s with a maximum retry count) and raise the key's RPM as needed. For sustained high concurrency, contact our business team for an assessment.

Seeing "key invalid or does not match the current gateway environment"?

Keys are bound to a gateway environment. Production uses api.tokgate.io; protocol roots are OpenAI /v1, the Anthropic SDK root without /v1, and Gemini /v1beta.

How to set timeouts for long-running generations?

Image generation takes significantly longer than chat. For chat, enable streaming (stream: true) to improve time-to-first-token; images return synchronously, so don't set the client timeout too short. Video APIs use asynchronous tasks: save the task ID after submission and poll for status instead of waiting on a long-lived connection. See the image and video docs for details.

Where can I find the full parameter documentation?

The API Reference provides field-by-field request/response documentation with runnable examples, split into chat, image and video. Still have questions? Reach us via the contact page.