Docs

OpenAI-compatible API. One model. A dedicated virtual server per account — it's yours alone, no other tenants.

1. Get a key

Dashboard → API keys → Create. Keys label your tasks (observability). They do not cap concurrency — concurrency is your SKU's max-num-seqs.

2. Point your agent at it

base_url:  https://api.notoken.cloud/{instance_id}/v1
api_key:   tnt-...
model:     tnt-coder

Your instance_id is unique to your server and appears in the dashboard the moment it goes live. The API key authenticates your account; the instance id routes to your server.

Works with: Cursor, Claude Code (via claude-code-router), Cline, Roo Code, Aider, OpenCode, Windsurf, Zed, Factory Droid, LiteLLM, Portkey, Braintrust, Vercel AI Gateway — anything that speaks OpenAI chat completions.

3. IDE & agent configuration

noTOKEN.cloud exposes an OpenAI-compatible Chat Completions API, so you can use it with IDEs, coding agents, and SDKs that support custom OpenAI-compatible endpoints.

You will need the following values from your noTOKEN.cloud dashboard:

  • Instance ID: your dedicated instance identifier
  • API key: starts with tnt-

The examples below use:

Model ID:      tnt-coder
Display name:  TNT-CODER (noTOKEN)
Base URL:      https://api.notoken.cloud/{instance_id}/v1
Chat endpoint: https://api.notoken.cloud/{instance_id}/v1/chat/completions

The model configuration used throughout this guide enables:

Tool calling:       Yes
Vision/image input: Yes
Maximum input:      260,000 tokens
Maximum output:     160,000 tokens
Total context:      420,000 tokens

Replace {instance_id} with the instance ID shown in your dashboard.

API key

Avoid storing your tnt-... API key directly in source-controlled configuration files.

For command-line tools and SDKs, set it as an environment variable.

macOS / Linux

export TNT_KEY="tnt-..."

Windows PowerShell

$env:TNT_KEY="tnt-..."

OpenCode

OpenCode supports custom OpenAI-compatible providers through @ai-sdk/openai-compatible.

Add the following to:

~/.config/opencode/opencode.json
{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "notoken": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "noTOKEN.cloud",
      "options": {
        "baseURL": "https://api.notoken.cloud/{instance_id}/v1",
        "apiKey": "{env:TNT_KEY}"
      },
      "models": {
        "tnt-coder": {
          "name": "TNT-CODER (noTOKEN)",
          "limit": { "context": 260000, "output": 160000 }
        }
      }
    }
  }
}

The base URL should end at /v1. OpenCode's OpenAI-compatible provider appends the Chat Completions API path automatically.

Make sure TNT_KEY is available in the environment before starting OpenCode:

export TNT_KEY="tnt-..."
opencode

Then open the model picker:

/models

and select:

TNT-CODER (noTOKEN)

VS Code

VS Code supports OpenAI-compatible models natively through its Custom Endpoint provider.

Open the Command Palette and run:

Chat: Manage Language Models

Then choose:

Add Models → Custom Endpoint

VS Code will open chatLanguageModels.json.

Use the following configuration:

[
  {
    "name": "noTOKEN.cloud",
    "vendor": "customendpoint",
    "apiKey": "${input:notokenApiKey}",
    "apiType": "chat-completions",
    "models": [
      {
        "id": "tnt-coder",
        "name": "TNT-CODER (noTOKEN)",
        "url": "https://api.notoken.cloud/{instance_id}/v1/chat/completions",
        "toolCalling": true,
        "vision": true,
        "maxInputTokens": 260000,
        "maxOutputTokens": 160000
      }
    ]
  }
]

Replace {instance_id} with your instance ID.

Using "apiKey": "${input:notokenApiKey}" is preferred over putting a raw tnt-... key in the file. VS Code prompts for the credential and keeps the actual API key out of chatLanguageModels.json.

For VS Code, use the full Chat Completions URL — https://api.notoken.cloud/{instance_id}/v1/chat/completions — rather than only the /v1 base URL.

After saving the configuration, select TNT-CODER (noTOKEN) from the model picker in VS Code Chat.

If the model does not appear immediately, reload or restart VS Code.

Pi

Pi supports custom OpenAI-compatible providers through:

~/.pi/agent/models.json

Add:

{
  "providers": {
    "notoken": {
      "baseUrl": "https://api.notoken.cloud/{instance_id}/v1",
      "api": "openai-completions",
      "apiKey": "$TNT_KEY",
      "authHeader": true,
      "models": [
        {
          "id": "tnt-coder",
          "name": "TNT-CODER (noTOKEN)",
          "input": ["text", "image"],
          "contextWindow": 420000,
          "maxTokens": 160000
        }
      ]
    }
  }
}

Pi's contextWindow represents the total context window. With a maximum input size of 260,000 tokens and maximum output size of 160,000 tokens, this is configured as:

260,000 + 160,000 = 420,000 tokens

Set your API key before starting Pi:

export TNT_KEY="tnt-..."

Then run pi. Open the model picker with:

/model

and select the notoken provider with model:

tnt-coder

You can also start Pi with the provider and model selected directly:

pi --provider notoken --model tnt-coder

The API key is read from TNT_KEY, so it does not need to be stored directly in models.json.

Python — OpenAI SDK

The official OpenAI Python SDK can connect directly by overriding base_url.

Install it with:

pip install openai

Set your API key:

export TNT_KEY="tnt-..."

Then:

import os

from openai import OpenAI

client = OpenAI(
    base_url="https://api.notoken.cloud/{instance_id}/v1",
    api_key=os.environ["TNT_KEY"],
)

response = client.chat.completions.create(
    model="tnt-coder",
    messages=[
        { "role": "user", "content": "Refactor this module and explain the changes." }
    ],
    stream=True,
)

for chunk in response:
    content = chunk.choices[0].delta.content
    if content:
        print(content, end="", flush=True)

For SDKs, use the base URL https://api.notoken.cloud/{instance_id}/v1. The SDK automatically calls /chat/completions.

Do not append /chat/completions to base_url when using the OpenAI SDK.

Python — vision input

Because the model supports image input, you can also send images using the OpenAI-compatible multimodal message format:

import os

from openai import OpenAI

client = OpenAI(
    base_url="https://api.notoken.cloud/{instance_id}/v1",
    api_key=os.environ["TNT_KEY"],
)

response = client.chat.completions.create(
    model="tnt-coder",
    messages=[
        {
            "role": "user",
            "content": [
                { "type": "text", "text": "Describe this image." },
                { "type": "image_url", "image_url": { "url": "https://example.com/image.jpg" } }
            ]
        }
    ]
)

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

cURL

You can test the endpoint directly before configuring an IDE or agent:

curl \
  "https://api.notoken.cloud/{instance_id}/v1/chat/completions" \
  -H "Authorization: Bearer $TNT_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "tnt-coder",
    "messages": [
      { "role": "user", "content": "Reply with: noTOKEN connection successful" }
    ]
  }'

A successful response confirms that the instance ID, API key, endpoint, and model ID are configured correctly.

Configuration reference

Use these values when configuring another OpenAI-compatible client:

Provider name:      noTOKEN.cloud
Model ID:           tnt-coder
Model name:         TNT-CODER (noTOKEN)

Base URL:
https://api.notoken.cloud/{instance_id}/v1

Chat Completions endpoint:
https://api.notoken.cloud/{instance_id}/v1/chat/completions

Authentication:
Authorization: Bearer tnt-...

API type:
OpenAI Chat Completions

Tool calling:
Enabled

Vision:
Enabled

Maximum input:
260,000 tokens

Maximum output:
160,000 tokens

Total context window:
420,000 tokens

Recommended practices

Keep API keys out of repositories and shared configuration files. Use environment variables, operating-system secret storage, or the client's built-in credential store whenever possible.

Use /v1 as the base URL for OpenAI SDKs and clients such as OpenCode and Pi that construct API paths themselves. Use the complete /v1/chat/completions URL when a client, such as VS Code Custom Endpoint, asks for the individual model endpoint.

Always use the API model identifier tnt-coder when making requests. TNT-CODER (noTOKEN) is the human-readable display name and does not replace the API model ID.

Only enable client capability flags that the endpoint supports. The configurations above enable tool calling and image input. Reasoning-specific options such as reasoning_effort, thinking, or provider-specific thinking formats should only be added if those API parameters are explicitly supported by the deployment.

4. Call it

curl https://api.notoken.cloud/{instance_id}/v1/chat/completions \
  -H "Authorization: Bearer $TNT_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "tnt-coder",
    "stream": true,
    "messages": [{"role": "user", "content": "Refactor this module: ..."}]
  }'

Streaming is SSE. Long prefills (big contexts) may pause before the first token — keepalives are injected so proxies (including Cloudflare) don't drop the connection. Hard cap: 10 min per request.

5. Context windows

Native: 262,144 tokens. Extended: up to 1,000,000. Starter Ada reaches 1M with TNT SubQ — lossless up to 90K tokens, then a quality/speed tradeoff until 1M. All Blackwell configs use YaRN RoPE scaling (factor 4.0, Qwen's recommended method) — full attention to 100% of the context window, even at 1M. Per-SKU practical limits are on the pricing page. For agentic work, Qwen recommends reserving up to 262K for reasoning + 131K for the final response inside the 1M window.

6. Billing

Prepaid credits (1 credit = $0.01). Your server accrues its SKU rate per second while running. Auto-stop: your configured idle time (default 60 min), or credits = 0 (60s grace so in-flight generations finish). Top up from the dashboard (Stripe) — the server restarts on demand. Per-second billing, no egress fees, no minimums beyond the $10 top-up.

7. What's in every server

OpenAI-compatible API · up to 1M context · auto-stop on your rules · AI support · per-second billing with prepaid credits.

8. Errors

StatusMeaning
401Missing/invalid API key
409No active server (launch one) or server already exists
402Insufficient credits
503Server not ready yet — retry in a few seconds
502Server unreachable (it may be restarting)

9. Prompt best practices

Qwen3.8 is a beast — scoring 52 on the intelligence index (alongside GLM-5.2), it is configured on noTOKEN.cloud with xhigh reasoning and all the tweaks expected for long-horizon tasks to evolve continuously. That means your server is expected to work autonomously, on its own, after your prompt.

If you give it detailed instructions, it will Plan, Build, Review and Document the entire task for you — sometimes working for hours (a single Blackwell user on our servers has an average ~60 tok/s generation speed — no token limits, as our name says).

If you want the model to keep tasks short, instead of changing the API reasoning flags per call, you can simply add to your prompt just do this and then stop — a simple instruction, just like you would give to a person.

1 million tokens in the context window is wonderful for coding, but it is too big for some tasks. For instance, if you want your Qwen to answer customer support messages, anything greater than 90K tokens can feed the model years of conversation that might not be useful for such a short task. Note also that prompt processing time is a quadratic feature: under the Ada architecture (Starter plan, TNT SubQ) it can take several minutes to process, while under Blackwell plans (YaRN) it is much faster.

As expected, the fastest prefill and generation occur on the Ultra plan — that is where the GPU memory bandwidth is the fastest. For more information, check our Benchmark section on this website.

10. Server management API

Everything the dashboard does is also available as a JSON API. Authenticate with a session cookie (from POST /api/auth/login or /api/auth/verify-code); all endpoints are on https://notoken.cloud. Prefer managing servers with your API key instead? See the Admin API section below.

List your servers:

GET /api/servers
# 200 -> { "servers": [ { id, sku, status, instance_id, endpoint, ... } ] }

Launch a server — sku is one of starter-ada, starter-bw, pro-bw, pro-max-bw, ultra-bw; users and ctx default to the SKU's first menu option:

POST /api/servers
Content-Type: application/json

{ "sku": "pro-bw", "users": 1, "ctx": 500000 }
# 201 -> { "server": { id, sku, status, ... } }

Stop (auto-restartable) or terminate (permanent) a server:

POST /api/servers/{id}/stop        # 200 -> { "ok": true }
POST /api/servers/{id}/terminate   # 200 -> { "ok": true }

Get one server + your usage totals:

GET /api/servers/{id}
# 200 -> { "server": { ... }, "usage": { calls, prompt_tokens, completion_tokens, total_tokens } }

Errors: 401 not logged in, 402 insufficient credits (need ≥ $1 to launch), 404 server not found, 409 server already exists / not available / 10-server cap reached.

11. Admin API

Manage your account's servers programmatically with a normal API key — no dashboard required.

1. Base URL & authentication

All endpoints live on https://notoken.cloud/api/v1/ and authenticate with the same API keys the inference endpoints use:

Authorization: Bearer tnt-...

Keys are created in the dashboard (API keys tab). Key creation and revocation stay dashboard-only on purpose: a leaked key can manage your servers, so it must never be able to mint new keys.

2. The 8 routes

MethodPathDescription
POST/api/v1/serversLaunch a server (same validation as the dashboard)
GET/api/v1/serversList your servers
GET/api/v1/servers/:idGet one server
POST/api/v1/servers/:id/stopStop a server (auto-restartable)
POST/api/v1/servers/:id/terminateTerminate a server (permanent)
GET/api/v1/settingsGet idle auto-stop setting
POST/api/v1/settingsSet idle auto-stop (0–1440 min)
GET/api/v1/creditsCredits balance + ledger (read-only)

Mutations are rate-limited to 30 requests per minute per key. Every call is recorded in your key's action history (visible in the dashboard's API keys tab).

3. Examples

List your servers:

curl https://notoken.cloud/api/v1/servers \
  -H "Authorization: Bearer tnt-..."
# 200 -> { "servers": [ { id, sku, status, instance_id, endpoint, ... } ] }

Launch a server — sku is one of starter-ada, starter-bw, pro-bw, pro-max-bw, ultra-bw; users and ctx default to the SKU's first menu option:

curl -X POST https://notoken.cloud/api/v1/servers \
  -H "Authorization: Bearer tnt-..." \
  -H "Content-Type: application/json" \
  -d '{"sku":"starter-bw","users":1,"ctx":260000}'
# 201 -> { "server": { id, sku, status, instance_id, ... } }

Stop or terminate:

curl -X POST https://notoken.cloud/api/v1/servers/42/stop      -H "Authorization: Bearer tnt-..."
curl -X POST https://notoken.cloud/api/v1/servers/42/terminate -H "Authorization: Bearer tnt-..."
# 200 -> { "ok": true }

Settings and credits:

curl https://notoken.cloud/api/v1/settings -H "Authorization: Bearer tnt-..."
# 200 -> { "idle_stop_minutes": 15 }

curl -X POST https://notoken.cloud/api/v1/settings \
  -H "Authorization: Bearer tnt-..." -H "Content-Type: application/json" \
  -d '{"idle_stop_minutes":5}'

curl https://notoken.cloud/api/v1/credits -H "Authorization: Bearer tnt-..."
# 200 -> { "balance_cents": 509, "ledger": [ ... ] }

4. Errors

StatusMeaning
401Missing/invalid API key or disabled account
402Insufficient credits (need ≥ $1 to launch)
404Server not found (or belongs to another account)
409Invalid config / SKU not launchable / 10-server cap reached
429Rate limited — mutations are 30/min per key

Ownership is enforced on every route: a valid key can only see and manage its own account's servers. Foreign or unknown ids return 404, never a leak.

5. Inference vs management

This API manages servers. For inference, point your agent at your server's endpoint: https://api.notoken.cloud/{instance_id}/v1 — see the Docs above.