ਟੋਕਨ ਗਿਣਤੀ

ਭੇਜਣ ਤੋਂ ਪਹਿਲਾਂ ਕਿਸੇ ਟੈਕਸਟ ਜਾਂ ਪੂਰੀ ਰਿਕੁਐਸਟ ਦੇ ਟੋਕਨ ਗਿਣੋ।

POST https://api.shannon-ai.com/v1/tokenize

POST https://api.shannon-ai.com/v1/messages/count_tokens

ਦੋਵੇਂ endpoints ਤੁਹਾਡੇ ਦੱਸੇ ਮਾਡਲ ਦੇ tokenizer ਨਾਲ ਗਿਣਦੇ ਹਨ, ਅਤੇ ਕੋਈ ਮਾਡਲ ਨਹੀਂ ਚੱਲਦਾ। ਇਹ ਹੋਸਟ ਕੀਤੇ open-weight ਮਾਡਲਾਂ ਲਈ ਹਨ। /v1/tokenize ਸਾਦਾ ਟੈਕਸਟ ਜਾਂ Chat Completions ਗੱਲਬਾਤ ਲੈਂਦਾ ਹੈ। /v1/messages/count_tokens Anthropic Messages ਫਾਰਮੈਟ ਵਿੱਚ ਰਿਕੁਐਸਟ ਲੈਂਦਾ ਹੈ, ਜੋ ਉਹ ਕਾਲ ਹੈ ਜੋ Anthropic SDK ਅਤੇ Claude Code ਕਰਦੇ ਹਨ।

ਗਿਣਤੀ ਮੁਫ਼ਤ ਹੈ। ਕਾਲ ਲਈ ਤੁਹਾਡੀ API key ਚਾਹੀਦੀ ਹੈ, ਇਹ ਤੁਹਾਡੇ ਬੈਲੇਂਸ ਵਿੱਚੋਂ ਕੁਝ ਨਹੀਂ ਲੈਂਦੀ ਅਤੇ ਤੁਹਾਡੇ ਵਰਤੋਂ ਲੌਗ ਵਿੱਚ ਨਹੀਂ ਦਿਸਦੀ।

ਟੈਕਸਟ ਦੀ ਗਿਣਤੀ

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"
  }'

200 ਜਵਾਬ

{
  "model": "DeepSeek-V4-Flash-0731-W4A16-AUTOROUND-REAP",
  "tokens": 3
}

ਇਸ ਪੰਨੇ ਦੇ ਜਵਾਬਾਂ ਵਿੱਚ ਸੰਖਿਆਵਾਂ ਉਦਾਹਰਨਾਂ ਹਨ। ਉਹੀ ਟੈਕਸਟ ਵੱਖਰੇ ਮਾਡਲ ਉੱਤੇ ਵੱਖਰੀ ਗਿਣਤੀ ਦਿੰਦਾ ਹੈ।

ਚੈਟ ਰਿਕੁਐਸਟ ਦੀ ਗਿਣਤੀ

model ਅਤੇ messages ਭੇਜੋ, ਅਤੇ ਜੇ ਰਿਕੁਐਸਟ ਵਿੱਚ tools ਹਨ ਤਾਂ ਉਹ ਵੀ, ਬਿਲਕੁਲ ਉਸੇ ਤਰ੍ਹਾਂ ਜਿਵੇਂ ਤੁਸੀਂ ਉਨ੍ਹਾਂ ਨੂੰ /v1/chat/completions ਨੂੰ ਭੇਜੋਗੇ। ਜਵਾਬ ਪੂਰੇ ਇਨਪੁਟ ਦਾ ਆਕਾਰ ਹੈ।

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"]
          }
        }
      }
    ]
  }'

200 ਜਵਾਬ

{
  "model": "DeepSeek-V4-Flash-0731-W4A16-AUTOROUND-REAP",
  "tokens": 164
}

/v1/tokenize ਦੇ ਫੀਲਡ

ਫੀਲਡ	ਕਿਸਮ	ਵੇਰਵਾ
`model`	`string`	ਲਾਜ਼ਮੀ। ਹੋਸਟ ਕੀਤੇ open-weight ਮਾਡਲ ਦਾ id। ਵੱਡੇ ਅਤੇ ਛੋਟੇ ਅੱਖਰਾਂ ਨੂੰ ਇੱਕੋ ਜਿਹਾ ਮੰਨਿਆ ਜਾਂਦਾ ਹੈ।
`text`	`string`	ਇੱਕ ਟੈਕਸਟ ਜੋ ਜਿਵੇਂ ਹੈ ਉਵੇਂ ਗਿਣਨਾ ਹੈ, ਚੈਟ ਫਾਰਮੈਟਿੰਗ ਤੋਂ ਬਿਨਾਂ। 4,000,000 ਬਾਈਟ ਤੱਕ। `text` ਜਾਂ `messages` ਭੇਜੋ; ਜਦੋਂ ਦੋਵੇਂ ਹੋਣ, ਤਾਂ `text` ਗਿਣਿਆ ਜਾਂਦਾ ਹੈ।
`messages`	`array`	Chat Completions ਫਾਰਮੈਟ ਵਿੱਚ ਚੈਟ ਸੰਦੇਸ਼। ਇਹ ਰਿਕੁਐਸਟ ਦੇ ਪੂਰੇ ਇਨਪੁਟ ਵਜੋਂ ਗਿਣੇ ਜਾਂਦੇ ਹਨ: ਹਰ ਸੰਦੇਸ਼ ਉਸ ਫਾਰਮੈਟਿੰਗ ਸਮੇਤ ਜੋ ਮਾਡਲ ਦਾ ਚੈਟ ਟੈਂਪਲੇਟ ਉਸਦੇ ਆਲੇ-ਦੁਆਲੇ ਲਗਾਉਂਦਾ ਹੈ।
`tools`	`array`	ਗਿਣਤੀ ਵਿੱਚ ਸ਼ਾਮਲ ਕਰਨ ਲਈ ਟੂਲ ਪਰਿਭਾਸ਼ਾਵਾਂ। `messages` ਦੇ ਨਾਲ ਮਿਲ ਕੇ ਵਰਤੀਆਂ ਜਾਂਦੀਆਂ ਹਨ।

ਜਵਾਬ ਇੱਕ JSON object ਹੈ ਜਿਸ ਵਿੱਚ ਇਹ ਫੀਲਡ ਹਨ:

ਫੀਲਡ	ਕਿਸਮ	ਵੇਰਵਾ
`model`	`string`	ਉਹ ਮਾਡਲ id ਜਿਸ ਲਈ ਗਿਣਤੀ ਕੀਤੀ ਗਈ, ਉਸਦੀ ਪ੍ਰਕਾਸ਼ਿਤ ਸਪੈਲਿੰਗ ਵਿੱਚ।
`tokens`	`integer`	`text` ਨਾਲ: ਟੈਕਸਟ ਦੇ ਟੋਕਨ। `messages` ਨਾਲ: ਇਮੇਜਾਂ ਸਮੇਤ ਪੂਰੇ ਇਨਪੁਟ ਦੇ ਟੋਕਨ।

Messages ਰਿਕੁਐਸਟ ਦੀ ਗਿਣਤੀ

ਉਹ ਬਾਡੀ ਭੇਜੋ ਜੋ ਤੁਸੀਂ /v1/messages ਨੂੰ ਭੇਜੋਗੇ: model, messages, ਅਤੇ ਜੇ ਵਰਤਦੇ ਹੋ ਤਾਂ system ਅਤੇ tools। ਅਧਿਕਾਰਤ Anthropic SDK ਇਸ endpoint ਨੂੰ 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."}
    ]
  }'

200 ਜਵਾਬ

{
  "input_tokens": 21
}

/v1/messages/count_tokens ਦੇ ਰਿਕੁਐਸਟ ਫੀਲਡ

ਫੀਲਡ	ਕਿਸਮ	ਵੇਰਵਾ
`model`	`string`	ਲਾਜ਼ਮੀ। ਹੋਸਟ ਕੀਤੇ open-weight ਮਾਡਲ ਦਾ id।
`messages`	`array`	ਲਾਜ਼ਮੀ। Anthropic Messages ਫਾਰਮੈਟ ਵਿੱਚ ਸੰਦੇਸ਼। `text`, `image`, `tool_use` ਅਤੇ `tool_result` ਬਲਾਕ ਗਿਣੇ ਜਾਂਦੇ ਹਨ।
`system`	`string \| array`	ਸਿਸਟਮ ਪ੍ਰੋਂਪਟ: ਇੱਕ string ਜਾਂ ਟੈਕਸਟ ਬਲਾਕਾਂ ਦੀ array।
`tools`	`array`	`name`, `description` ਅਤੇ `input_schema` ਵਾਲੀਆਂ ਟੂਲ ਪਰਿਭਾਸ਼ਾਵਾਂ।

ਅਨੁਕੂਲਤਾ ਲਈ ਸਵੀਕਾਰ ਕੀਤੇ ਜਾਂਦੇ ਹਨ, ਗਿਣਤੀ ਉੱਤੇ ਕੋਈ ਅਸਰ ਨਹੀਂ: tool_choice, max_tokens, temperature, top_p, stop_sequences, stream, thinking। ਤੁਸੀਂ ਅਸਲ ਰਿਕੁਐਸਟ ਦੀ ਬਾਡੀ ਬਿਨਾਂ ਬਦਲੇ ਦੇ ਸਕਦੇ ਹੋ।

ਜਵਾਬ ਇੱਕ JSON object ਹੈ ਜਿਸ ਵਿੱਚ ਇਹ ਫੀਲਡ ਹਨ:

ਫੀਲਡ	ਕਿਸਮ	ਵੇਰਵਾ
`input_tokens`	`integer`	ਪੂਰੇ ਇਨਪੁਟ ਦੇ ਟੋਕਨ: ਸਿਸਟਮ ਪ੍ਰੋਂਪਟ, ਸੰਦੇਸ਼, ਟੂਲ ਅਤੇ ਇਮੇਜਾਂ।

ਸਮਰਥਿਤ ਮਾਡਲ

ਦੋਵੇਂ endpoints ਹੋਸਟ ਕੀਤੇ open-weight ਮਾਡਲਾਂ ਲਈ ਗਿਣਤੀ ਕਰਦੇ ਹਨ। GET /v1/models ਹਰ ਉਸ ਮਾਡਲ ਦੇ endpoints ਵਿੱਚ /v1/tokenize ਅਤੇ /v1/messages/count_tokens ਦੱਸਦਾ ਹੈ ਜੋ ਉਨ੍ਹਾਂ ਨੂੰ ਸਹਾਰਦਾ ਹੈ। ਕਿਸੇ ਵੀ ਹੋਰ model ਮੁੱਲ ਦਾ, Shannon ਦੇ ids ਸਮੇਤ, ਜਵਾਬ 400 ਨਾਲ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ।

DeepSeek-V4-Pro-0813-3BIT-REAP
GLM-5.2-3BIT-REAP
Kimi-K3-3BIT-REAP
Nemotron3Ultra-3BIT-REAP
MiniMax-M3-3BIT-REAP
DeepSeek-V4-Flash-0731-W4A16-AUTOROUND-REAP
Kimi-K2.6-W4A16-AUTOROUND-REAP
Laguna-S-2.1-W4A16-AUTOROUND-REAP
inkling-W4A16-AUTOROUND-REAP
MiMo-V2.5-Pro-W8A16
MiMo-V2.5-W8A16
Hy3-W8A16

Shannon ਮਾਡਲ ਲਈ, ਟੋਕਨ ਗਿਣਤੀ ਜਵਾਬ ਦੇ usage object ਤੋਂ ਪੜ੍ਹੋ।

ਗਿਣਤੀ ਕਿਵੇਂ ਕੀਤੀ ਜਾਂਦੀ ਹੈ

ਹਰ ਮਾਡਲ ਦੀ ਗਿਣਤੀ ਉਸਦੇ ਆਪਣੇ tokenizer ਅਤੇ ਆਪਣੇ ਚੈਟ ਟੈਂਪਲੇਟ ਨਾਲ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਅੱਖਰਾਂ ਜਾਂ ਸ਼ਬਦਾਂ ਤੋਂ ਕੋਈ ਅੰਦਾਜ਼ਾ ਨਹੀਂ ਵਰਤਿਆ ਜਾਂਦਾ।

ਕੀ ਗਿਣਿਆ ਜਾਂਦਾ ਹੈ	ਨਿਯਮ
ਇੱਕ ਟੈਕਸਟ	string ਦੇ ਟੋਕਨ ਜਿਵੇਂ ਭੇਜੀ ਗਈ ਹੈ। ਖਾਲੀ string 0 ਗਿਣੀ ਜਾਂਦੀ ਹੈ।
ਸੰਦੇਸ਼	ਸੰਦੇਸ਼ ਅਤੇ ਟੂਲ ਮਾਡਲ ਦੇ ਆਪਣੇ ਚੈਟ ਟੈਂਪਲੇਟ ਨਾਲ ਉੱਥੇ ਤੱਕ ਸਜਾਏ ਜਾਂਦੇ ਹਨ ਜਿੱਥੋਂ ਜਵਾਬ ਸ਼ੁਰੂ ਹੁੰਦਾ ਹੈ, ਅਤੇ ਉਹ ਪੂਰਾ ਪ੍ਰੋਂਪਟ ਗਿਣਿਆ ਜਾਂਦਾ ਹੈ।
ਭੂਮਿਕਾਵਾਂ	`system`, `user`, `assistant` ਅਤੇ `tool` ਸੰਦੇਸ਼ ਗਿਣੇ ਜਾਂਦੇ ਹਨ। `developer` ਨੂੰ `system` ਵਜੋਂ ਗਿਣਿਆ ਜਾਂਦਾ ਹੈ। ਜਿਸ ਸੰਦੇਸ਼ ਵਿੱਚ ਨਾ ਸਮੱਗਰੀ ਹੋਵੇ ਨਾ ਟੂਲ ਕਾਲ, ਉਹ ਕੁਝ ਨਹੀਂ ਜੋੜਦਾ।
ਟੂਲ ਕਾਲਾਂ ਅਤੇ ਨਤੀਜੇ	ਪਿਛਲੇ assistant ਮੋੜਾਂ ਦੀਆਂ ਟੂਲ ਕਾਲਾਂ ਅਤੇ ਉਨ੍ਹਾਂ ਦੇ ਨਤੀਜੇ ਗਿਣਤੀ ਦਾ ਹਿੱਸਾ ਹਨ, ਦੋਵਾਂ endpoints ਉੱਤੇ।
ਇਮੇਜਾਂ	ਬਾਡੀ ਦੇ ਅੰਦਰ ਭੇਜੀ ਇਮੇਜ (base64 ਜਾਂ `data:` URL) ਹਰ 28 × 28 ਪਿਕਸਲ ਦੇ ਟੁਕੜੇ ਲਈ ਇੱਕ ਟੋਕਨ ਜੋੜਦੀ ਹੈ: `ceil(width / 28) × ceil(height / 28)`। `http(s)` URL ਵਜੋਂ ਦਿੱਤੀ ਇਮੇਜ ਇਹ endpoints ਡਾਊਨਲੋਡ ਨਹੀਂ ਕਰਦੇ ਅਤੇ ਉਹ 1,024 ਗਿਣੀ ਜਾਂਦੀ ਹੈ।

ਉਦਾਹਰਨ: 1,024 × 768 ਪਿਕਸਲ ਦੀ ਇਮੇਜ ceil(1024 / 28) × ceil(768 / 28) = 37 × 28 = 1,036 ਟੋਕਨ ਗਿਣੀ ਜਾਂਦੀ ਹੈ।

ਗਿਣਤੀ ਅਤੇ ਰਿਕੁਐਸਟ ਦਾ ਖਰਚ

ਪੂਰੀ ਰਿਕੁਐਸਟ ਦੀ ਗਿਣਤੀ ਉਸੇ ਤਰ੍ਹਾਂ ਕੀਤੀ ਜਾਂਦੀ ਹੈ ਜਿਵੇਂ ਉਸੇ ਮਾਡਲ, ਸੰਦੇਸ਼ਾਂ ਅਤੇ ਟੂਲਾਂ ਵਾਲੀ ਅਸਲ ਰਿਕੁਐਸਟ ਦੀ ਇਨਪੁਟ ਗਿਣਤੀ। ਜਵਾਬ ਉਹੀ ਸੰਖਿਆ Chat Completions ਉੱਤੇ usage.prompt_tokens ਵਜੋਂ, Responses ਉੱਤੇ usage.input_tokens ਵਜੋਂ, ਅਤੇ Messages ਉੱਤੇ usage.input_tokens ਪਲੱਸ usage.cache_read_input_tokens ਵਜੋਂ ਦੱਸਦਾ ਹੈ।

ਗਿਣਤੀ ਕੈਸ਼ਡ-ਇਨਪੁਟ ਛੋਟ ਤੋਂ ਪਹਿਲਾਂ ਦਾ ਇਨਪੁਟ ਹੈ। ਅਸਲ ਰਿਕੁਐਸਟ ਉਸ ਇਨਪੁਟ ਦਾ ਕੁਝ ਹਿੱਸਾ ਕੈਸ਼ ਤੋਂ ਪੜ੍ਹ ਸਕਦੀ ਹੈ ਅਤੇ ਉਸ ਹਿੱਸੇ ਦਾ ਬਿਲ ਕੈਸ਼ਡ ਦਰ ਉੱਤੇ ਬਣਦਾ ਹੈ। ਪ੍ਰੋਂਪਟ ਕੈਸ਼ਿੰਗ
http(s) URL ਵਜੋਂ ਦਿੱਤੀ ਇਮੇਜ ਇੱਥੇ 1,024 ਗਿਣੀ ਜਾਂਦੀ ਹੈ। ਅਸਲ ਰਿਕੁਐਸਟ ਇਮੇਜ ਡਾਊਨਲੋਡ ਕਰਦੀ ਹੈ ਅਤੇ ਉਸਨੂੰ ਪਿਕਸਲਾਂ ਵਿੱਚ ਉਸਦੇ ਆਕਾਰ ਤੋਂ ਗਿਣਦੀ ਹੈ, ਇਸ ਲਈ ਦੋਵੇਂ ਸੰਖਿਆਵਾਂ ਵੱਖਰੀਆਂ ਹੋ ਸਕਦੀਆਂ ਹਨ। ਇੱਕੋ ਸੰਖਿਆ ਲਈ ਇਮੇਜ base64 ਵਜੋਂ ਭੇਜੋ।
ਆਉਟਪੁੱਟ ਗਿਣਤੀ ਦਾ ਹਿੱਸਾ ਨਹੀਂ ਹੈ। ਅਸਲ ਰਿਕੁਐਸਟ ਦੇ ਜਵਾਬ ਦਾ ਬਿਲ, ਰੀਜ਼ਨਿੰਗ ਸਮੇਤ, ਇਸ ਤੋਂ ਉੱਪਰ ਆਉਟਪੁੱਟ ਟੋਕਨਾਂ ਵਜੋਂ ਬਣਦਾ ਹੈ।
text ਗਿਣਤੀ ਵਿੱਚ ਚੈਟ ਫਾਰਮੈਟਿੰਗ ਨਹੀਂ ਹੁੰਦੀ। ਇਸਨੂੰ ਕਿਸੇ ਦਸਤਾਵੇਜ਼ ਜਾਂ ਪ੍ਰੋਂਪਟ ਦੇ ਹਿੱਸੇ ਨੂੰ ਮਾਪਣ ਲਈ ਵਰਤੋ, ਅਤੇ ਰਿਕੁਐਸਟ ਮਾਪਣ ਲਈ messages ਰੂਪ ਵਰਤੋ।

ਗਿਣਤੀ ਨੂੰ ਖਰਚ ਵਿੱਚ ਬਦਲਣ ਲਈ, ਇਸਨੂੰ ਮਾਡਲ ਦੀ ਪ੍ਰਤੀ 1M ਟੋਕਨ ਇਨਪੁਟ ਕੀਮਤ ਨਾਲ ਗੁਣਾ ਕਰੋ। ਮਾਡਲ ਅਤੇ ਕੀਮਤਾਂ

ਸੀਮਾਵਾਂ

ਸੀਮਾ	ਮੁੱਲ	ਇਸ ਤੋਂ ਉੱਪਰ
`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>`	`/v1/tokenize` ਅਜਿਹੇ `model` ਨਾਲ ਜੋ ਹੋਸਟ ਕੀਤੇ open-weight ਮਾਡਲ ਦਾ id ਨਹੀਂ ਹੈ।
`400`	`invalid_request_error`	`count_tokens is available for the hosted open models; unknown model: <model>`	`/v1/messages/count_tokens` ਅਜਿਹੇ `model` ਨਾਲ ਜੋ ਹੋਸਟ ਕੀਤੇ open-weight ਮਾਡਲ ਦਾ id ਨਹੀਂ ਹੈ, ਜਾਂ `model` ਤੋਂ ਬਿਨਾਂ।
`400`	`invalid_request_error`	send `text` or `messages`	`/v1/tokenize` ਜਿਸ ਵਿੱਚ ਨਾ `text` ਹੈ ਨਾ `messages`।
`401`	`authentication_error`	`Missing authentication / Invalid API key`	ਕੋਈ key ਨਹੀਂ ਭੇਜੀ ਗਈ, ਜਾਂ 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 ਉੱਤੇ endpoint ਦੀਆਂ ਆਪਣੀਆਂ ਗਲਤੀਆਂ (ਮਾਡਲ ਲਈ 400, 503) Anthropic ਸ਼ਕਲ ਵਿੱਚ ਆਉਂਦੀਆਂ ਹਨ, ਅਤੇ 401, 413, 415 ਅਤੇ 422 OpenAI ਸ਼ਕਲ ਵਿੱਚ ਆਉਂਦੀਆਂ ਹਨ। ਪਹਿਲਾਂ ਸਟੇਟਸ ਕੋਡ ਪੜ੍ਹੋ, ਫਿਰ error.type ਅਤੇ error.message, ਜੋ ਦੋਵਾਂ ਸ਼ਕਲਾਂ ਵਿੱਚ ਹੁੰਦੇ ਹਨ।

400 /v1/tokenize

{
  "error": {
    "type": "invalid_request_error",
    "message": "tokenize is available for the hosted open models; unknown model: shannon-3"
  }
}

400 /v1/messages/count_tokens

{
  "type": "error",
  "error": {
    "type": "invalid_request_error",
    "message": "count_tokens is available for the hosted open models; unknown model: shannon-3"
  }
}