Skip to content
← Back to guides

Models and routing

Use an API key created in your 6090ti dashboard to find model IDs, then choose the API format required by your tool. This guide explains models and routing and includes authentication, first requests, SDKs, streaming, and troubleshooting.

Before connecting: the examples describe how each API format is used; they do not mean every model has every capability enabled. These examples have not all been verified with live 6090ti requests. Check your current key’s permissions, the model’s supported endpoints, and actual request results.

Reading order: Account and key → API formats and authentication → Models and routing → OpenAI / Claude → Client setup → Troubleshooting.

1. Before you start

  1. Create an account in the dashboard and verify your email.
  2. Check your balance. When a top-up is needed, use the payment options currently offered in the dashboard and review the payment amount and account credit before paying.
  3. Create your own key on the API Keys page in the dashboard menu and keep it private.
  4. Find an available model ID that supports the API format required by your client.

Your API key authenticates model requests. Your email and password sign you into the dashboard; do not use your password as an API key.

Wallet credit and model prices are displayed in USD. Top-up payments use CNY; the order shows the exact credit amount. Check requests, token usage, charges, and balance in the dashboard.

Placeholders in the examples

The examples put the key directly in commands and code. Before running them, replace <your key> with the key you created in the dashboard, and model placeholders such as <chat model> with actual model IDs (see section 3). Run the commands on the computer or server that will make the requests.

Do not commit, screenshot, or share commands and code that contain your real key.

2. Choose an API format

Format SDK / client Base URL Full request path Typical use
OpenAI Chat Completions https://api.6090ti.com/v1 POST /v1/chat/completions Chat applications and compatible clients
OpenAI Responses https://api.6090ti.com/v1 POST /v1/responses Codex and Responses-based applications
Anthropic Messages https://api.6090ti.com POST /v1/messages Claude Code and native Claude requests

Choose a format supported by both the client and the model. A model appearing in the list does not mean it supports every endpoint in this table.

A Base URL is different from a complete request URL. SDKs normally append the method path. Do not put /chat/completions in an SDK Base URL. If a client offers a full-URL setting, follow that setting and avoid duplicate paths such as /v1/v1.

Authentication headers

OpenAI format:

Authorization: Bearer <your key>
Content-Type: application/json

Anthropic format:

x-api-key: <your key>
anthropic-version: 2023-06-01
Content-Type: application/json

Use headers or the client’s dedicated key field. Do not put keys in URL query parameters.

3. Find an available model

Send GET https://api.6090ti.com/v1/models to retrieve model IDs visible to your key.

Windows PowerShell:

$headers = @{ Authorization = "Bearer <your key>" }
$models = Invoke-RestMethod -Method Get -Uri "https://api.6090ti.com/v1/models" -Headers $headers
$models | ConvertTo-Json -Depth 20

macOS / Linux:

curl --fail-with-body "https://api.6090ti.com/v1/models" \
  -H "Authorization: Bearer <your key>"

Copy the appropriate id from a returned model item. Replace <chat model>, <Responses model>, and <Claude model> with actual model IDs for the respective endpoints; they are placeholders only.

The model list identifies models; the pricing page displays prices. Requests also depend on key permissions, balance, and endpoint support.

Which model ID should I enter?

Put the exact id returned for your current key in the request’s model field or your client’s model setting. Preserve capitalization, hyphens, dots, and version suffixes. Do not substitute a translated display name or invent a provider prefix.

The dashboard’s model-name list is a platform-maintained display list for finding and copying names. It serves a different purpose from querying /v1/models with your own key. A displayed model is not proof that your key can call it. A successful model-list request also does not verify every endpoint, tool call, image, or caching capability.

How does 6090ti handle routing?

  1. You choose the model and API format. Your client sends the request and API key to the corresponding endpoint at api.6090ti.com.
  2. The gateway processes it according to its configuration. Requests depend on key permissions, configured models, balance, and endpoint support. The platform maintains upstream accounts and routing; users do not need to enter upstream accounts or configure routing rules.
  3. Verify one request first. Send a short input, check the response and dashboard usage record, then verify features such as streaming, tools, or images that your application needs.

Whether one key can call models from multiple providers depends on what the platform has enabled for that key. When changing models, check that the tool and endpoint match. One key does not mean every model uses one endpoint. Do not use auto, a route name, or an arbitrary alias as the model ID unless the platform explicitly offers that exact ID.

This guide uses explicitly selected models. Automatic model selection, switching providers after failures, and another platform’s Fast mode, speed claims, or pricing multipliers are not default capabilities or promises of this guide.

Four checks before changing models

CheckAction
Model nameQuery models with your current key and copy the exact ID. Do not reuse another platform’s model table.
API formatUse section 2 to select an endpoint supported by both client and model. Prefer Messages for Claude; confirm Responses support before using a model with Responses.
Pricing and accessCheck model pricing and the dashboard. A visible model does not establish sufficient balance or prices for caching, images, or other features.
Actual resultVerify a short request, then check required features and usage records. For errors, inspect the response body, model ID, and endpoint. After a timeout, check records before deciding to retry.

4. OpenAI-compatible requests

4.1 Your first Chat Completions request

Create request.json in your current directory and replace the model ID:

{
  "model": "<chat model>",
  "messages": [
    {"role": "user", "content": "Reply with OK only."}
  ]
}

Windows PowerShell:

$headers = @{ Authorization = "Bearer <your key>" }
$body = Get-Content -LiteralPath ".\request.json" -Raw -Encoding UTF8
$result = Invoke-RestMethod -Method Post -Uri "https://api.6090ti.com/v1/chat/completions" -Headers $headers -ContentType "application/json; charset=utf-8" -Body ([Text.Encoding]::UTF8.GetBytes($body))
$result.choices[0].message.content

macOS / Linux:

curl --fail-with-body "https://api.6090ti.com/v1/chat/completions" \
  -H "Authorization: Bearer <your key>" \
  -H "Content-Type: application/json" \
  --data-binary @request.json

Text appears in choices[0].message.content. A successful response looks like this (excerpt; numbers are examples only):

{
  "object": "chat.completion",
  "model": "<chat model>",
  "choices": [
    {"index": 0, "message": {"role": "assistant", "content": "OK"}, "finish_reason": "stop"}
  ],
  "usage": {"prompt_tokens": 12, "completion_tokens": 1, "total_tokens": 13}
}

After receiving the reply, check the request under Usage in your dashboard.

4.2 Python SDK

Install with py -m pip install openai on Windows or python3 -m pip install openai on macOS / Linux, preferably in your own virtual environment. Save as quickstart.py:

from openai import OpenAI

client = OpenAI(
    api_key="<your key>",
    base_url="https://api.6090ti.com/v1",
    timeout=120.0,
    max_retries=0,
)

reply = client.chat.completions.create(
    model="<chat model>",
    messages=[{"role": "user", "content": "Reply with OK only."}],
)
print(reply.choices[0].message.content)

Run py quickstart.py on Windows or python3 quickstart.py on macOS / Linux. The timeout controls the client’s wait; it does not promise a server execution limit. Automatic retries are disabled for the initial diagnostic request.

4.3 Responses API

Reuse the Python client from the previous section and replace the request with:

reply = client.responses.create(
    model="<Responses model>",
    input="Reply with OK only.",
)
print(reply.output_text)

Responses takes input; Chat Completions takes messages. Raw Responses JSON uses the output array; output_text is an SDK convenience property. OpenAI text generation documentation

4.4 Node.js SDK

Run npm install openai in your own project and save this as quickstart.mjs:

import OpenAI from "openai";

const client = new OpenAI({
  apiKey: "<your key>",
  baseURL: "https://api.6090ti.com/v1",
  timeout: 120000,
  maxRetries: 0,
});

const reply = await client.responses.create({
  model: "<Responses model>",
  input: "Reply with OK only.",
});
console.log(reply.output_text);

Run node quickstart.mjs on Windows, macOS, or Linux. For Chat Completions, replace the request with:

const reply = await client.chat.completions.create({
  model: "<chat model>",
  messages: [{ role: "user", content: "Reply with OK only." }],
});
console.log(reply.choices[0].message.content);

4.5 Streaming

Reuse your Python OpenAI client:

events = client.chat.completions.create(
    model="<chat model>",
    messages=[{"role": "user", "content": "Write a four-line poem."}],
    stream=True,
)
for event in events:
    if event.choices:
        text = event.choices[0].delta.content
        if text:
            print(text, end="", flush=True)
print()

Raw Chat Completions SSE typically sends data: lines and finishes with data: [DONE]. Responses uses its own events, including response.output_text.delta. Handle completion, failure, and incomplete termination; HTTP 200 alone does not prove successful generation.

5. Native Anthropic format

Use https://api.6090ti.com as the Base URL for Claude Code and Anthropic-format applications.

Use this native format (/v1/messages) for Claude models. Calling Claude through the OpenAI-compatible format may lose prompt caching, extended thinking, and other capabilities, and may cost more; it suits simple chat only. Agent tools such as Claude Code must be configured with the Anthropic format.

5.1 Your first request

Create claude-request.json in your current directory and replace the model ID:

{
  "model": "<Claude model>",
  "max_tokens": 512,
  "messages": [
    {"role": "user", "content": "Reply with OK only."}
  ]
}

Windows PowerShell:

$headers = @{ "x-api-key" = "<your key>"; "anthropic-version" = "2023-06-01" }
$body = Get-Content -LiteralPath ".\claude-request.json" -Raw -Encoding UTF8
$result = Invoke-RestMethod -Method Post -Uri "https://api.6090ti.com/v1/messages" -Headers $headers -ContentType "application/json; charset=utf-8" -Body ([Text.Encoding]::UTF8.GetBytes($body))
$result.content | Where-Object { $_.type -eq "text" } | ForEach-Object { $_.text }

macOS / Linux:

curl --fail-with-body "https://api.6090ti.com/v1/messages" \
  -H "x-api-key: <your key>" \
  -H "anthropic-version: 2023-06-01" \
  -H "Content-Type: application/json" \
  --data-binary @claude-request.json

A successful response looks like this (excerpt; numbers are examples only):

{
  "type": "message",
  "role": "assistant",
  "model": "<Claude model>",
  "content": [{"type": "text", "text": "OK"}],
  "stop_reason": "end_turn",
  "usage": {"input_tokens": 14, "output_tokens": 4}
}

Text is in the content blocks whose type is text.

5.2 Python SDK

Install with py -m pip install anthropic on Windows or python3 -m pip install anthropic on macOS / Linux. Save as claude_example.py:

from anthropic import Anthropic

client = Anthropic(
    api_key="<your key>",
    base_url="https://api.6090ti.com",
    timeout=120.0,
    max_retries=0,
)

reply = client.messages.create(
    model="<Claude model>",
    max_tokens=512,
    messages=[{"role": "user", "content": "Reply with OK only."}],
)
for block in reply.content:
    if block.type == "text":
        print(block.text)

Run py claude_example.py on Windows or python3 claude_example.py on macOS / Linux. Adjust the output limit according to your model.

5.3 Streaming

From the command line, add "stream": true to claude-request.json and add -N to the curl command so output appears immediately. The response is an SSE event stream: message_start, content_block_start, several content_block_delta events, content_block_stop, message_delta, and message_stop.

In Python, replace the request and output section with:

with client.messages.stream(
    model="<Claude model>",
    max_tokens=512,
    messages=[{"role": "user", "content": "Write a four-line poem."}],
) as stream:
    for text in stream.text_stream:
        print(text, end="", flush=True)
print()

Raw HTTP requests need anthropic-version: 2023-06-01; the official SDK handles the relevant header. Handle errors inside the event stream rather than treating every closed connection as success. Anthropic streaming documentation

5.4 Prompt caching

Claude prompt caching must be enabled by the caller: add "cache_control": {"type": "ephemeral"} at the end of the content you want to reuse. Without it nothing is cached, and cache reads and writes in the dashboard stay at 0. Common positions are a long fixed system prompt, the last tool definition, and the latest message.

Save the following as cache-request.json and replace <long fixed system prompt> with your own long system prompt:

{
  "model": "<Claude model>",
  "max_tokens": 512,
  "system": [
    {"type": "text", "text": "<long fixed system prompt>", "cache_control": {"type": "ephemeral"}}
  ],
  "messages": [
    {"role": "user", "content": "Reply with OK only."}
  ]
}

Send it twice with the command from section 5.1, replacing claude-request.json with cache-request.json. In the returned usage, cache_creation_input_tokens is the cache write and cache_read_input_tokens is the cache read. The first request usually shows only a write; a second request shortly afterwards should show a read.

Caching matches by prefix: everything before a marked position (system prompt, tools, earlier messages) must stay identical, and any change invalidates the cache after it. Content shorter than the selected model’s minimum cacheable length is not cached. With the Python SDK, pass the same structure in the system parameter. Cache write and read prices follow the pricing page and dashboard. Anthropic prompt caching documentation

6. Client setup

Step-by-step setup for each client is in the integration guides, one page per tool:

7. Troubleshooting

Symptom What to check
401 authentication failure Complete key, extra whitespace, disabled key, credentials belonging to 6090ti; header matching the format (x-api-key for Anthropic, Authorization: Bearer for OpenAI); /v1 in the OpenAI SDK Base URL but not the Anthropic one. Codes: INVALID_API_KEY, API_KEY_DISABLED
400 invalid request Correct request structure for the chosen format; start with the minimal example before adding optional parameters
403 balance / permission error INSUFFICIENT_BALANCE: top up in the dashboard and retry. API_KEY_EXPIRED: create a new key. Other codes: check key permissions or model restrictions
404 endpoint / model not found Actual model ID, duplicate /v1, correct method path, API domain rather than website or dashboard
429 request limited Request rate, concurrency, key quota (API_KEY_QUOTA_EXHAUSTED); respect Retry-After and bound retries with increasing delays
Slow or interrupted request Try a short request. A first-token delay of seconds to tens of seconds while large models think is normal. Use streaming for longer output, raise the client timeout, and check dashboard records before resending
Text works but tools / images fail Check model capabilities, protocol, and client adapter; verify each required feature separately
Claude via OpenAI format errors, costs more, or performs worse Use the native Anthropic format (/v1/messages) for Claude, see section 5; the OpenAI-compatible format may lose prompt caching and thinking

A disconnected client does not prove that a request was never executed. Check records before repeating work that could incur another charge.

Cache usage at 0: Claude prompt caching requires an explicit cache_control marker in the request; see section 5.4. Calling Claude through the OpenAI-compatible format usually does not enable caching. Content below the model’s minimum cacheable length, or a system prompt or tool list that changes between requests, also prevents cache hits. Other models follow their own caching rules. Cache writes, reads, and ordinary input are billed at actual prices.

Check usage and charges in the dashboard. API usage fields are token information, not a complete monetary bill.

If a key leaks, disable or delete it in the dashboard, create a replacement, and update affected programs. Signing out or changing your login password does not revoke a key. Never embed a full key in a public frontend, repository, screenshot, or support request.

For help, email 6090tihelp@6090ti.com with the client and version, model ID, endpoint path, time and timezone, request ID if available, and redacted errors. Do not send full keys, passwords, or verification codes. Telegram, QQ and other channels are listed in the support and issue-reporting guide.
QQ user group: 1109931264