अनुरोध भेजने से पहले टोकन गिनें: Python में tiktoken

आप अपनी मशीन पर ही प्रॉम्प्ट के टोकन गिन सकते हैं, भेजने से पहले: tiktoken इंस्टॉल करें, टेक्स्ट encode करें, परिणाम का len() लें। tiktoken OpenAI का tokeniser है, इसलिए DeepSeek, GLM और MiniMax मॉडल के लिए यह संख्या एक अनुमान है। असली आंकड़ा पहली कॉल के बाद usage.prompt_tokens में वापस आता है, और दोनों की तुलना में एक और लाइन लगती है।

परेशानी क्यों करें? क्योंकि बिल और एरर दोनों की शुरुआत इनपुट के आकार से होती है। किसी स्क्रिप्ट में एक लंबा कॉन्ट्रैक्ट पेस्ट करें, और पता तब चलता है कि यह बहुत बड़ा था जब API 400 के साथ जवाब देता है। पांच हज़ार ईमेल का बैच चलाएं, और पता तब चलता है कि इसका खर्च क्या हुआ जब बैलेंस कम हो। पहले गिनने से दोनों आश्चर्य एक ऐसी संख्या में बदल जाते हैं जिसे आप पहले से पढ़ सकते हैं।

टोकन गिनने वाली पांच लाइनें#

tiktoken README (1 नवंबर 2026 को जांचा गया) पूरा विचार दिखाता है: एक encoding चुनें, टेक्स्ट encode करें, और सूची की लंबाई ही टोकन संख्या है।

pip install tiktoken

import tiktoken

enc = tiktoken.get_encoding('o200k_base')
text = 'Hello world'
tokens = enc.encode(text)
print(len(tokens))  # how many tokens the text is

enc.decode(tokens) मूल टेक्स्ट लौटाता है, जो एक उपयोगी sanity check है कि आप वही टेक्स्ट देख रहे हैं जो मॉडल देखेगा। README में tiktoken.encoding_for_model('gpt-4o') का भी ज़िक्र है, जो किसी विशिष्ट OpenAI मॉडल के लिए tokeniser चुनता है। यही वह बात है जो याद रखने लायक है: tokeniser मॉडल परिवारों के होते हैं। README का अनुमानित नियम प्रति टोकन लगभग चार बाइट टेक्स्ट है, और यह केवल OpenAI के tokeniser का वर्णन करता है।

तो DeepSeek मॉडल के लिए आप क्या करें? उसी गिनती को कामचलाऊ अनुमान के रूप में इस्तेमाल करें, और नीचे दिखाए अनुसार इसे कैलिब्रेट करें।

क्या प्रॉम्प्ट विंडो में फिट बैठता है?#

हर मॉडल की एक context window होती है, और आपका इनपुट प्लस जितना जवाब आप अनुमति देते हैं, उसे उसमें फिट होना चाहिए। हमारे द्वारा सेवा किए जाने वाले मॉडलों की विंडो: DeepSeek-V4-Flash 380K, GLM-5.3-Flash 390K, MiniMax-M2.7 180K टोकन। सबसे लंबा जवाब DeepSeek-V4-Flash के लिए 32,768 टोकन और अन्य दो के लिए 8,192 है (CheapTokens मॉडल सूची, 1 नवंबर 2026)।

कॉल से पहले एक guard चार लाइनों का है:

CONTEXT = {
    'deepseek-ai/DeepSeek-V4-Flash-0731': 380_000,
    'zai-org/GLM-5.3-Flash': 390_000,
    'MiniMaxAI/MiniMax-M2.7': 180_000,
}

def fits(prompt_tokens, max_tokens, model):
    return prompt_tokens + max_tokens <= CONTEXT[model]

मान लें आपके पास 250,000-टोकन का दस्तावेज़ है। fits(250_000, 8_192, 'MiniMaxAI/MiniMax-M2.7') का मान False है, इसलिए आप उस काम को बड़ी विंडो वाले मॉडल पर भेजते हैं या दस्तावेज़ को बांटते हैं, और 400 कभी नहीं होता। fits(250_000, 8_192, 'deepseek-ai/DeepSeek-V4-Flash-0731') का मान True है। अगर आप एरर कैसा दिखता है इसकी पूरी कहानी चाहते हैं, तो request too long: 400 vs 413, context window and max_tokens इसे समझाता है।

इसका खर्च क्या होगा?#

अब बजट। एक सामान्य आइटम लें, उसे गिनें, और गुणा करें। मान लें आप 5,000 ऑर्डर ईमेल वर्गीकृत करते हैं। आप एक प्रतिनिधि ईमेल गिनते हैं और लगभग 800 इनपुट टोकन पाते हैं, और लेबल तथा एक छोटे कारण को 200 आउटपुट टोकन पर सीमित करते हैं। कुल: 5,000 × 800 = 4,000,000 इनपुट टोकन और 5,000 × 200 = 1,000,000 आउटपुट टोकन।

नीचे दी गई तालिका ठीक उसी कार्यभार की कीमत लाइव दरों पर लगाती है, इनपुट और आउटपुट को मिलाकर गिनते हुए:

कुल मिलाकर, इनपुट और आउटपुट को मिलाकर गिनते हुए, इन मॉडलों के लिए CheapTokens कॉलम OpenRouter से सस्ता है। तीनों संख्याओं को अपनी गिनती में बदलें और आपके पास पहले अनुरोध से पहले ही बजट तैयार है। बिल के दोनों पक्षों के अंतर के लिए, input vs output tokens: what an AI API bills you for देखें, और वास्तविक मापे गए उदाहरणों के लिए how many tokens an API request uses। मौजूदा कीमतें हमेशा pricing page पर होती हैं।

अनुमान की usage से तुलना करें#

अनुमान किसी और के tokeniser के बारे में एक अंदाज़ा है, इसलिए इसे एक बार उत्तर-कुंजी से जांच लें। हर प्रतिक्रिया में एक usage फ़ील्ड होता है, और usage.prompt_tokens वह है जो API ने आपके इनपुट के लिए गिना। दोनों संख्याओं को साथ रखें और भाग दें।

pip install tiktoken openai
export CHEAPTOKENS_API_KEY='your-key-here'

import os
import tiktoken
from openai import OpenAI

MODEL = 'deepseek-ai/DeepSeek-V4-Flash-0731'
enc = tiktoken.get_encoding('o200k_base')
messages = [{'role': 'user',
             'content': 'Classify this email as order, refund or other: Hi, my parcel from last Tuesday has not arrived yet.'}]

estimate = sum(len(enc.encode(m['content'])) for m in messages)

client = OpenAI(base_url='https://api.cheaptokens.dev/v1',
                api_key=os.environ['CHEAPTOKENS_API_KEY'])
r = client.chat.completions.create(model=MODEL, messages=messages, max_tokens=200)

real = r.usage.prompt_tokens
print(f'estimate {estimate}, usage.prompt_tokens {real}, ratio {real / estimate:.2f}')

आगे से दिनचर्या यह है: स्थानीय रूप से अनुमान लगाएं, विंडो की guard करें, बजट पर अपना अनुपात लागू करें, और हर प्रतिक्रिया में usage आपको ईमानदार रखे। अगर आप पूरे काम का चलता कुल भी चाहते हैं, तो track AI agent token cost in Python उसी फ़ील्ड पर इसे बनाता है। कनेक्शन में नए हैं? Your first API request with CheapTokens इसे कवर करता है, और बाकी docs में है।

गिनना सस्ता है, स्थानीय है और सेकंडों में हो जाता है। इसे उस कॉल से पहले करें जिसमें पैसे लगते हैं।