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.
- Website: www.6090ti.com
- Dashboard: Open your dashboard
- API gateway:
https://api.6090ti.com - Support: 6090tihelp@6090ti.com
QQ user group: 1109931264
1. Before you start
- Create an account in the dashboard and verify your email.
- 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.
- Create your own key on the API Keys page in the dashboard menu and keep it private.
- 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?
- You choose the model and API format. Your client sends the request and API key to the corresponding endpoint at
api.6090ti.com. - 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.
- 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
| Check | Action |
|---|---|
| Model name | Query models with your current key and copy the exact ID. Do not reuse another platform’s model table. |
| API format | Use 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 access | Check model pricing and the dashboard. A visible model does not establish sufficient balance or prices for caching, images, or other features. |
| Actual result | Verify 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:
- Codex CLI
- Codex Desktop
- Claude Code
- Claude Desktop
- CC Switch
- OpenCode
- OpenClaw
- Cline
- Cherry Studio
- WorkBuddy
- TRAE
- DeepSeek Harness
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