Token లెక్కింపు
ఒక టెక్స్ట్ లేదా మొత్తం రిక్వెస్ట్ యొక్క tokens ను పంపే ముందే లెక్కించండి.
POST https://api.shannon-ai.com/v1/tokenize
POST https://api.shannon-ai.com/v1/messages/count_tokens
రెండు ఎండ్పాయింట్లు మీరు పేర్కొన్న మోడల్ యొక్క tokenizer తో లెక్కిస్తాయి, ఏ మోడల్ నడవదు. అవి హోస్ట్ చేసిన ఓపెన్-వెయిట్ మోడల్స్కు వర్తిస్తాయి. /v1/tokenize సాధారణ టెక్స్ట్ను లేదా Chat Completions సంభాషణను తీసుకుంటుంది. /v1/messages/count_tokens Anthropic Messages ఫార్మాట్లోని రిక్వెస్ట్ను తీసుకుంటుంది; Anthropic SDK మరియు Claude Code చేసే కాల్ ఇదే.
లెక్కించడం ఉచితం. కాల్కు మీ API కీ అవసరం, అది మీ బ్యాలెన్స్ నుండి ఏమీ తీసుకోదు మరియు మీ usage లాగ్లో కనిపించదు.
ఒక టెక్స్ట్ను లెక్కించండి
model మరియు text పంపండి. టెక్స్ట్ చుట్టూ చాట్ ఫార్మాటింగ్ లేకుండా, ఉన్నది ఉన్నట్లే లెక్కించబడుతుంది.
import requests
response = requests.post(
"https://api.shannon-ai.com/v1/tokenize",
headers={"Authorization": "Bearer YOUR_API_KEY"},
json={
"model": "DeepSeek-V4-Flash-0731-W4A16-AUTOROUND-REAP",
"text": "Hello, world",
},
)
print(response.json()["tokens"]) const response = await fetch("https://api.shannon-ai.com/v1/tokenize", {
method: "POST",
headers: {
Authorization: "Bearer YOUR_API_KEY",
"Content-Type": "application/json",
},
body: JSON.stringify({
model: "DeepSeek-V4-Flash-0731-W4A16-AUTOROUND-REAP",
text: "Hello, world",
}),
});
const { tokens } = await response.json();
console.log(tokens); curl https://api.shannon-ai.com/v1/tokenize \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "DeepSeek-V4-Flash-0731-W4A16-AUTOROUND-REAP",
"text": "Hello, world"
}' {
"model": "DeepSeek-V4-Flash-0731-W4A16-AUTOROUND-REAP",
"tokens": 3
} ఈ పేజీలోని సమాధానాలలో ఉన్న సంఖ్యలు ఉదాహరణలు. అదే టెక్స్ట్కు వేరే మోడల్లో వేరే లెక్క వస్తుంది.
చాట్ రిక్వెస్ట్ను లెక్కించండి
/v1/chat/completions కు పంపినట్లే model మరియు messages పంపండి, రిక్వెస్ట్లో ఉంటే tools కూడా. సమాధానం మొత్తం ఇన్పుట్ పరిమాణం.
import requests
request = {
"model": "DeepSeek-V4-Flash-0731-W4A16-AUTOROUND-REAP",
"messages": [
{"role": "system", "content": "You are a concise assistant."},
{"role": "user", "content": "What is the weather in Paris?"},
],
"tools": [
{
"type": "function",
"function": {
"name": "get_weather",
"description": "Current weather for a city",
"parameters": {
"type": "object",
"properties": {"city": {"type": "string"}},
"required": ["city"],
},
},
}
],
}
response = requests.post(
"https://api.shannon-ai.com/v1/tokenize",
headers={"Authorization": "Bearer YOUR_API_KEY"},
json=request,
)
print(response.json()["tokens"]) const request = {
model: "DeepSeek-V4-Flash-0731-W4A16-AUTOROUND-REAP",
messages: [
{ role: "system", content: "You are a concise assistant." },
{ role: "user", content: "What is the weather in Paris?" },
],
tools: [
{
type: "function",
function: {
name: "get_weather",
description: "Current weather for a city",
parameters: {
type: "object",
properties: { city: { type: "string" } },
required: ["city"],
},
},
},
],
};
const response = await fetch("https://api.shannon-ai.com/v1/tokenize", {
method: "POST",
headers: {
Authorization: "Bearer YOUR_API_KEY",
"Content-Type": "application/json",
},
body: JSON.stringify(request),
});
const { tokens } = await response.json();
console.log(tokens); curl https://api.shannon-ai.com/v1/tokenize \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "DeepSeek-V4-Flash-0731-W4A16-AUTOROUND-REAP",
"messages": [
{"role": "system", "content": "You are a concise assistant."},
{"role": "user", "content": "What is the weather in Paris?"}
],
"tools": [
{
"type": "function",
"function": {
"name": "get_weather",
"description": "Current weather for a city",
"parameters": {
"type": "object",
"properties": {"city": {"type": "string"}},
"required": ["city"]
}
}
}
]
}' {
"model": "DeepSeek-V4-Flash-0731-W4A16-AUTOROUND-REAP",
"tokens": 164
} /v1/tokenize ఫీల్డ్లు
| ఫీల్డ్ | రకం | వివరణ |
|---|---|---|
model | string | తప్పనిసరి. హోస్ట్ చేసిన ఓపెన్-వెయిట్ మోడల్ id. పెద్ద అక్షరాలు, చిన్న అక్షరాలు ఒకేలా పరిగణించబడతాయి. |
text | string | చాట్ ఫార్మాటింగ్ లేకుండా, ఉన్నది ఉన్నట్లే లెక్కించాల్సిన టెక్స్ట్. 4,000,000 బైట్ల వరకు. text లేదా messages పంపండి; రెండూ ఉంటే text లెక్కించబడుతుంది. |
messages | array | Chat Completions ఫార్మాట్లో చాట్ మెసేజ్లు. అవి రిక్వెస్ట్ యొక్క పూర్తి ఇన్పుట్గా లెక్కించబడతాయి: ప్రతి మెసేజ్, మోడల్ చాట్ టెంప్లేట్ దాని చుట్టూ ఉంచే ఫార్మాటింగ్తో సహా. |
tools | array | లెక్కలో చేర్చాల్సిన టూల్ డెఫినిషన్లు. messages తో కలిపి ఉపయోగించబడతాయి. |
సమాధానం ఈ ఫీల్డ్లు ఉన్న JSON ఆబ్జెక్ట్:
| ఫీల్డ్ | రకం | వివరణ |
|---|---|---|
model | string | లెక్క చేసిన మోడల్ id, ప్రచురించిన స్పెల్లింగ్లో. |
tokens | integer | text తో: టెక్స్ట్ యొక్క tokens. messages తో: చిత్రాలతో సహా మొత్తం ఇన్పుట్ యొక్క tokens. |
Messages రిక్వెస్ట్ను లెక్కించండి
మీరు /v1/messages కు పంపే బాడీనే పంపండి: model, messages, మరియు వాడితే system, tools. అధికారిక Anthropic SDKలు ఈ ఎండ్పాయింట్ను messages.count_tokens ద్వారా కాల్ చేస్తాయి.
import anthropic
client = anthropic.Anthropic(
api_key="YOUR_API_KEY",
base_url="https://api.shannon-ai.com",
)
count = client.messages.count_tokens(
model="DeepSeek-V4-Flash-0731-W4A16-AUTOROUND-REAP",
system="You are a concise assistant.",
messages=[
{"role": "user", "content": "Summarise the attached report."}
],
)
print(count.input_tokens) import Anthropic from "@anthropic-ai/sdk";
const client = new Anthropic({
apiKey: "YOUR_API_KEY",
baseURL: "https://api.shannon-ai.com",
});
const count = await client.messages.countTokens({
model: "DeepSeek-V4-Flash-0731-W4A16-AUTOROUND-REAP",
system: "You are a concise assistant.",
messages: [
{ role: "user", content: "Summarise the attached report." },
],
});
console.log(count.input_tokens); curl https://api.shannon-ai.com/v1/messages/count_tokens \
-H "x-api-key: YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "DeepSeek-V4-Flash-0731-W4A16-AUTOROUND-REAP",
"system": "You are a concise assistant.",
"messages": [
{"role": "user", "content": "Summarise the attached report."}
]
}' {
"input_tokens": 21
} /v1/messages/count_tokens కు పంపవలసిన ఫీల్డ్లు
| ఫీల్డ్ | రకం | వివరణ |
|---|---|---|
model | string | తప్పనిసరి. హోస్ట్ చేసిన ఓపెన్-వెయిట్ మోడల్ id. |
messages | array | తప్పనిసరి. Anthropic Messages ఫార్మాట్లో మెసేజ్లు. text, image, tool_use మరియు tool_result బ్లాక్లు లెక్కించబడతాయి. |
system | string | array | సిస్టమ్ ప్రాంప్ట్: ఒక string లేదా టెక్స్ట్ బ్లాక్ల అర్రే. |
tools | array | name, description మరియు input_schema ఉన్న టూల్ డెఫినిషన్లు. |
అనుకూలత కోసం అంగీకరించబడతాయి, లెక్కపై ప్రభావం ఉండదు: tool_choice, max_tokens, temperature, top_p, stop_sequences, stream, thinking. నిజమైన రిక్వెస్ట్ బాడీని మార్పు లేకుండా పంపవచ్చు.
సమాధానం ఈ ఫీల్డ్లు ఉన్న JSON ఆబ్జెక్ట్:
| ఫీల్డ్ | రకం | వివరణ |
|---|---|---|
input_tokens | integer | మొత్తం ఇన్పుట్ tokens: సిస్టమ్ ప్రాంప్ట్, మెసేజ్లు, టూల్స్ మరియు చిత్రాలు. |
మద్దతు ఉన్న మోడల్స్
రెండు ఎండ్పాయింట్లు హోస్ట్ చేసిన ఓపెన్-వెయిట్ మోడల్స్ కోసం లెక్కిస్తాయి. GET /v1/models వాటికి మద్దతు ఇచ్చే ప్రతి మోడల్ యొక్క endpoints లో /v1/tokenize మరియు /v1/messages/count_tokens ను జాబితా చేస్తుంది. Shannon id లతో సహా ఏ ఇతర model విలువకైనా 400 తో సమాధానం వస్తుంది.
DeepSeek-V4-Pro-0813-3BIT-REAPGLM-5.2-3BIT-REAPKimi-K3-3BIT-REAPNemotron3Ultra-3BIT-REAPMiniMax-M3-3BIT-REAPDeepSeek-V4-Flash-0731-W4A16-AUTOROUND-REAPKimi-K2.6-W4A16-AUTOROUND-REAPLaguna-S-2.1-W4A16-AUTOROUND-REAPinkling-W4A16-AUTOROUND-REAPMiMo-V2.5-Pro-W8A16MiMo-V2.5-W8A16Hy3-W8A16
Shannon మోడల్ కోసం, token లెక్కలను సమాధానంలోని usage ఆబ్జెక్ట్ నుండి చదవండి.
లెక్క ఎలా చేయబడుతుంది
ప్రతి మోడల్ తన స్వంత tokenizer మరియు తన స్వంత చాట్ టెంప్లేట్తో లెక్కించబడుతుంది. అక్షరాలు లేదా పదాల నుండి అంచనా వేయరు.
| ఏది లెక్కించబడుతుంది | నియమం |
|---|---|
| ఒక టెక్స్ట్ | పంపిన string యొక్క tokens. ఖాళీ string 0 గా లెక్కించబడుతుంది. |
| మెసేజ్లు | మెసేజ్లు మరియు టూల్స్ మోడల్ స్వంత చాట్ టెంప్లేట్తో, సమాధానం మొదలయ్యే వరకు అమర్చబడతాయి, ఆ మొత్తం ప్రాంప్ట్ లెక్కించబడుతుంది. |
| రోల్స్ | system, user, assistant మరియు tool మెసేజ్లు లెక్కించబడతాయి. developer ను system గా లెక్కిస్తారు. కంటెంట్ మరియు టూల్ కాల్ రెండూ లేని మెసేజ్ ఏమీ జోడించదు. |
| టూల్ కాల్స్ మరియు ఫలితాలు | మునుపటి అసిస్టెంట్ టర్న్ల టూల్ కాల్స్ మరియు వాటి ఫలితాలు రెండు ఎండ్పాయింట్లలోనూ లెక్కలో భాగం. |
| చిత్రాలు | బాడీ లోపల పంపిన చిత్రం (base64 లేదా data: URL) ప్రతి 28 × 28 పిక్సెల్ ప్యాచ్కు ఒక token జోడిస్తుంది: ceil(width / 28) × ceil(height / 28). http(s) URL గా ఇచ్చిన చిత్రాన్ని ఈ ఎండ్పాయింట్లు డౌన్లోడ్ చేయవు, అది 1,024 గా లెక్కించబడుతుంది. |
ఉదాహరణ: 1,024 × 768 పిక్సెల్ చిత్రం ceil(1024 / 28) × ceil(768 / 28) = 37 × 28 = 1,036 tokens గా లెక్కించబడుతుంది.
లెక్క మరియు రిక్వెస్ట్కు ఛార్జ్ అయ్యేది
మొత్తం రిక్వెస్ట్ లెక్క, అదే మోడల్, మెసేజ్లు మరియు టూల్స్తో నిజమైన రిక్వెస్ట్ యొక్క ఇన్పుట్ లెక్కను చేసిన విధంగానే చేయబడుతుంది. సమాధానం ఆ సంఖ్యను Chat Completions లో usage.prompt_tokens గా, Responses లో usage.input_tokens గా, Messages లో usage.input_tokens ప్లస్ usage.cache_read_input_tokens గా చూపుతుంది.
- లెక్క అంటే క్యాష్డ్-ఇన్పుట్ డిస్కౌంట్కు ముందు ఉన్న ఇన్పుట్. నిజమైన రిక్వెస్ట్ ఆ ఇన్పుట్లో కొంత భాగాన్ని క్యాష్ నుండి చదివి, ఆ భాగానికి క్యాష్ రేటుతో బిల్ చేయవచ్చు. ప్రాంప్ట్ క్యాషింగ్
http(s)URL గా ఇచ్చిన చిత్రం ఇక్కడ 1,024 గా లెక్కించబడుతుంది. నిజమైన రిక్వెస్ట్ చిత్రాన్ని డౌన్లోడ్ చేసి, దాని పిక్సెల్ పరిమాణం నుండి లెక్కిస్తుంది, కాబట్టి ఈ రెండు సంఖ్యలు వేరుగా ఉండవచ్చు. అదే సంఖ్య రావాలంటే చిత్రాన్ని base64 గా పంపండి.- అవుట్పుట్ లెక్కలో భాగం కాదు. నిజమైన రిక్వెస్ట్ సమాధానం, రీజనింగ్తో సహా, అదనంగా అవుట్పుట్ tokens గా బిల్ చేయబడుతుంది.
textలెక్కలో చాట్ ఫార్మాటింగ్ ఉండదు. డాక్యుమెంట్ లేదా ప్రాంప్ట్ భాగాన్ని కొలవడానికి దాన్ని, రిక్వెస్ట్ను కొలవడానికిmessagesరూపాన్ని ఉపయోగించండి.
లెక్కను ఖర్చుగా మార్చడానికి, దాన్ని మోడల్ యొక్క 1M tokens ఇన్పుట్ ధరతో గుణించండి. మోడల్స్ & ధరలు
పరిమితులు
| పరిమితి | విలువ | దాని పైన |
|---|---|---|
text పొడవు | 4,000,000 బైట్లు (UTF-8) | text too long మెసేజ్తో 413 |
| రిక్వెస్ట్ బాడీ | 32 MiB | 413 |
| ప్రతి రిక్వెస్ట్కు | ఒక టెక్స్ట్ లేదా ఒక సంభాషణ | అనేక టెక్స్ట్లను లెక్కించడానికి ప్రతి టెక్స్ట్కు ఒక రిక్వెస్ట్ పంపండి. |
లెక్కింపు కాల్స్ నిమిషానికి 120 రిక్వెస్ట్ల పరిమితిలో లెక్కించబడవు. పరిమితులు మరియు బ్యాలెన్స్
ఎర్రర్లు
| స్టేటస్ | రకం | మెసేజ్ | ఎప్పుడు |
|---|---|---|---|
400 | invalid_request_error | tokenize is available for the hosted open models; unknown model: <model> | హోస్ట్ చేసిన ఓపెన్-వెయిట్ id కాని model తో /v1/tokenize. |
400 | invalid_request_error | count_tokens is available for the hosted open models; unknown model: <model> | హోస్ట్ చేసిన ఓపెన్-వెయిట్ id కాని model తో, లేదా model లేకుండా /v1/messages/count_tokens. |
400 | invalid_request_error | send `text` or `messages` | text లేదా messages రెండూ లేకుండా /v1/tokenize. |
401 | authentication_error | Missing authentication / Invalid API key | కీ పంపలేదు, లేదా కీ చెల్లదు. |
413 | invalid_request_error | text too long | text 4,000,000 బైట్ల కంటే పొడవుగా ఉంది. 32 MiB కంటే పెద్ద బాడీకి కూడా 413 తో సమాధానం వస్తుంది. |
415 | invalid_request_error | Expected request with `Content-Type: application/json` | రిక్వెస్ట్లో JSON content type లేదు. |
422 | invalid_request_error | Failed to deserialize the JSON body into the target type: … | తప్పనిసరి ఫీల్డ్ లేదు (/v1/tokenize లో model, /v1/messages/count_tokens లో messages) లేదా ఒక ఫీల్డ్ తప్పు రకంలో ఉంది. |
503 | api_error | token counting is temporarily unavailable for this model | ప్రస్తుతం ఈ మోడల్కు లెక్క చేయడం సాధ్యం కాదు. తర్వాత మళ్ళీ ప్రయత్నించండి. |
/v1/tokenize ఎర్రర్లను OpenAI ఆకృతిలో ఇస్తుంది. /v1/messages/count_tokens లో ఆ ఎండ్పాయింట్ యొక్క స్వంత ఎర్రర్లు (మోడల్ కోసం 400, 503) Anthropic ఆకృతిలో వస్తాయి, మరియు 401, 413, 415, 422 OpenAI ఆకృతిలో వస్తాయి. ముందు స్టేటస్ కోడ్ను, తర్వాత రెండు ఆకృతులలోనూ ఉండే error.type మరియు error.message ను చదవండి.
{
"error": {
"type": "invalid_request_error",
"message": "tokenize is available for the hosted open models; unknown model: shannon-3"
}
} {
"type": "error",
"error": {
"type": "invalid_request_error",
"message": "count_tokens is available for the hosted open models; unknown model: shannon-3"
}
}