SSD Nodes Learn Hosting plans →
تعلیمی Matt Connorتحریر: Matt Connor · اپ ڈیٹ شدہ 2026-10-30

Claude میں input اور output tokens کی لاگت کا فرق

Claude میں output tokens کی قیمت input سے 5 گنا ہے۔ Prefill اور decoding کا فرق سمجھیں، اور جانیں کہ agent کا ماہانہ bill واقعی کیسے بدلتا ہے۔

آؤٹ پٹ ٹوکنز کی لاگت ان پٹ ٹوکنز سے زیادہ کیوں ہے

موجودہ catalogue میں ہر Claude model پر آؤٹ پٹ ٹوکنز کی لاگت ان پٹ ٹوکنز کے مقابلے میں پانچ گنا ہے۔ اس کی وجہ computation کی نوعیت ہے۔ prompt پڑھنا model کے لیے ایک pass ہوتا ہے۔ جواب لکھنا ہر ٹوکن کے لیے ایک pass ہوتا ہے، اور ہر pass کو پچھلے pass کے مکمل ہونے کا انتظار کرنا پڑتا ہے۔

یہ تناسب price list کی ہر row میں یکساں ہے، اس لیے آپ کا منتخب کردہ model اس بات کو تبدیل نہیں کرتا کہ آپ کے bill کا کتنا حصہ آؤٹ پٹ پر خرچ ہوتا ہے۔ اس کا فیصلہ آپ کے workload کی نوعیت کرتی ہے۔ ایک agent step جو 60,000 ٹوکنز پڑھتا ہے اور 800 ٹوکنز میں جواب دیتا ہے، آؤٹ پٹ پر تقریباً کچھ خرچ نہیں کرتا۔ ایک drafting job جو 2,000 ٹوکنز پڑھتی ہے اور 12,000 ٹوکنز لکھتی ہے، ان پٹ پر تقریباً کچھ خرچ نہیں کرتی۔ دونوں صورتوں کا حساب ذیل میں Anthropic کی شائع کردہ rates کے مطابق دیا گیا ہے، جنہیں 27 October 2026 کو verify کیا گیا تھا۔

Prefill ایک بار چلتا ہے، decoding ہر token کے لیے ایک بار چلتی ہے

Inference server کسی request کو دو مراحل میں handle کرتا ہے، اور دونوں کی لاگت میں بہت فرق ہوتا ہے۔ Prefill prompt کو پڑھتا ہے۔ Decoding جواب لکھتی ہے۔

Prefill پورے prompt کو ایک ساتھ process کرتا ہے۔ ہر prompt token ایک ہی forward pass میں network میں داخل ہوتا ہے، اس لیے attention اور feed-forward کا کام بڑی matrix multiplications کی نسبتاً کم تعداد میں تبدیل ہو جاتا ہے، جن میں ایک وقت میں ہزاروں tokens شامل ہوتے ہیں۔ Memory سے model weights کو ایک بار پڑھنا پورے prompt کے لیے کافی ہوتا ہے۔ Accelerator کی matrix units مصروف رہتی ہیں، اس لیے prefill عموماً compute-bound ہوتا ہے: حد chip کی multiplication کی رفتار ہوتی ہے۔ NVIDIA کی serving documentation دو استثنا بیان کرتی ہے: بہت مختصر prefills، اور ایسے prefills جن میں طویل prefix پہلے ہی cache hit ہو، memory-bound ہو جاتے ہیں۔

عام decoding اس طرح کام نہیں کر سکتی، کیونکہ token 2 کا انحصار token 1 پر ہوتا ہے۔ Model نے جو token ابھی تیار کیا ہے، وہ اگلے مرحلے کے input کا حصہ بن جاتا ہے، اس لیے یہ مراحل ایک کے بعد ایک چلتے ہیں۔ ہر output token کے لیے اپنا forward pass ہوتا ہے، اور ان میں سے ہر pass ایک token تیار کرنے کے لیے model weights کے پورے set کے علاوہ KV cache (key/value cache؛ اب تک کے ہر token کے لیے محفوظ attention state) کو high-bandwidth memory سے پڑھتا ہے۔ اس لیے decoding عموماً memory-bound ہوتی ہے: حد اس بات سے متعین ہوتی ہے کہ weights اور cached state کو کتنی تیزی سے منتقل کیا جا سکتا ہے، نہ کہ ان پر کتنی تیزی سے multiplication کی جا سکتی ہے۔ طویل contexts میں NVIDIA خاص طور پر KV cache reads کو bottleneck قرار دیتا ہے۔ Prefill کے دوران جتنا weight traffic پورے prompt کے لیے استعمال ہوتا ہے، decoding کے دوران وہی traffic آپ کو صرف ایک token دیتا ہے۔

Speculative decoding اس اصول کو توڑنے کے بجائے اس میں لچک پیدا کرتی ہے۔ ایک چھوٹا draft model کئی tokens آگے کا اندازہ لگاتا ہے، اور بڑا model ایک ہی pass میں ان سب کو parallel طور پر check کرتا ہے۔ NVIDIA کے مطابق اس سے decode کا کام compute-bound سمت میں جا سکتا ہے۔ بڑا model پھر بھی ان اندازوں کو ترتیب سے قبول کرتا ہے اور پہلے غلط اندازے پر رک جاتا ہے، اس لیے طویل جواب کے لیے اب بھی بہت سے passes درکار ہوتے ہیں۔

Serving systems batching کے ذریعے اس مسئلے کا ازالہ کرتے ہیں۔ متعدد requests ایک ساتھ decode ہوتی ہیں، اس لیے weights کو ایک بار پڑھنے سے batch میں موجود ہر request کے لیے ایک token تیار ہو جاتا ہے۔ اسی وجہ سے decoding قابلِ عمل رہتی ہے۔ حد پھر memory بن جاتی ہے۔ ہر زیرِ عمل request اپنا KV cache رکھتی ہے، یہ cache تیار ہونے والے ہر token کے ساتھ بڑھتا ہے، اور جب یہ accelerator کو بھر دیتا ہے تو batch مزید بڑا نہیں ہو سکتا۔

ان میں سے کوئی بات آپ کو exact number نہیں دیتی، اور 5x کو hardware ratio کی measured قدر نہیں سمجھنا چاہیے۔ یہ Anthropic کی مقرر کردہ قیمت ہے، جس کی بنیاد اس asymmetry پر ہے۔ آپ خود جس چیز کی تصدیق کر سکتے ہیں وہ سمت ہے، اور اس میں تقریباً ایک منٹ لگتا ہے۔

اپنا input اور output gap خود ناپیں

کسی بھی Ubuntu box پر tools install کریں:

sudo apt update && sudo apt install -y curl jq moreutils

اب ایک مختصر prompt stream کریں جو طویل جواب طلب کرے، اور ہر line پر اس کے موصول ہونے کا وقت درج کریں۔

curl -sN https://api.anthropic.com/v1/messages \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "content-type: application/json" \
  -d '{"model":"claude-sonnet-5","max_tokens":1000,"stream":true,
       "messages":[{"role":"user","content":"Count from 1 to 300, one number per line."}]}' \
  | ts -s '%.s'

ts -s ہر line کے آغاز میں command شروع ہونے کے بعد گزرنے والے seconds درج کرتا ہے۔ اس output سے دو چیزیں پڑھنا مفید ہے۔ پہلی content_block_delta line تک پہنچنے میں لگنے والا وقت آپ کا first token time ہے، اور تمام prefill اسی کے اندر مکمل ہوا۔ اس کے بعد ہر line decoding کے ایک مختصر step کی نمائندگی کرتی ہے، اور stamps اس وقت تک بڑھتے رہتے ہیں جب تک message_stop نہ آ جائے۔

اب شکل الٹ دیں۔ prompt میں ایک طویل document رکھیں اور جواب کو چند tokens تک محدود کریں۔

curl -sN https://api.anthropic.com/v1/messages \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "content-type: application/json" \
  -d "$(jq -n --rawfile doc ./long-document.txt \
       '{model:"claude-sonnet-5", max_tokens:16, stream:true,
         messages:[{role:"user", content:("Answer in one word. Is this document about networking?\n\n" + $doc)}]}')" \
  | ts -s '%.s'

پہلا delta مختصر prompt کے مقابلے میں زیادہ وقت لیتا ہے، کیونکہ prefill کو کہیں زیادہ text پڑھنا ہوتا ہے۔ اس کے بعد response تقریباً فوراً ختم ہو جاتا ہے، کیونکہ decode کرنے کے لیے صرف چند tokens باقی رہتے ہیں۔ دسیوں ہزار tokens داخل ہوئے، مگر clock بمشکل آگے بڑھی۔ چند سو tokens باہر آئے، اور clock پورے وقت چلتی رہی۔

ہر non-streaming response کے اختتام پر وہ numbers موجود ہوتے ہیں جن کی بنیاد پر billing ہوتی ہے۔

{
  "usage": {
    "input_tokens": 41283,
    "output_tokens": 6,
    "cache_creation_input_tokens": 0,
    "cache_read_input_tokens": 0
  }
}

ہر request کے لیے چاروں fields log کریں۔ output_tokens میں thinking tokens بھی شامل ہوتے ہیں، اس لیے جو model جواب دینے سے پہلے سوچتا ہے، اس thinking کی billing output rate پر ہوتی ہے۔ request بھیجنے سے پہلے prompt کی قیمت معلوم کرنے کے لیے POST /v1/messages/count_tokens زیادہ تر requests میں وہی request body لیتا ہے، model چلائے بغیر {"input_tokens": N} کو estimate کے طور پر واپس کرتا ہے، اور اپنی rate limit کے اندر free ہے۔ یہ کچھ ایسی bodies مسترد کرتا ہے جنہیں Messages API قبول کرتی ہے: زیادہ تر server tools، مثلاً web search، MCP connector، اور image یا document blocks جن کا source url یا file ہو۔ اس لیے counting کے وقت images اور PDFs کو base64 کے طور پر بھیجیں۔ API کا یہ واحد حصہ نہیں جس کی کوئی لاگت نہیں، اور Claude API کے کن حصوں کی آپ سے کبھی billing نہیں ہوتی پہلے project کا budget بنانے سے پہلے دیکھنا مفید ہے۔

اکتوبر 2026 تک دس لاکھ tokens کے حساب سے Claude کی قیمت

چارٹClaude API list rates, US dollars per million tokens, October 2026
اس چارٹ کے پیچھے کا ڈیٹا
[
  {
    "label": "Haiku 4.5",
    "input_usd": 1,
    "output_usd": 5,
    "output_multiple": 5
  },
  {
    "label": "Sonnet 5",
    "input_usd": 2,
    "output_usd": 10,
    "output_multiple": 5
  },
  {
    "label": "Opus 5",
    "input_usd": 5,
    "output_usd": 25,
    "output_multiple": 5
  },
  {
    "label": "Fable 5",
    "input_usd": 10,
    "output_usd": 50,
    "output_multiple": 5
  }
]

آخری column، input کے مقابلے میں output کا تناسب ہے، اور ہر row میں یہ 5 دکھاتا ہے۔ Haiku 4.5 کے لیے $1 input اور $5 output کے حساب سے فیس لی جاتی ہے۔ Opus 5 کے لیے $5 اور $25 فیس ہے۔ سب سے مہنگا ماڈل Fable 5، $10 input اور $50 output لیتا ہے، اور Fable 5 کی یہ قیمتیں آپ کو کیا فراہم کرتی ہیں کو اس اوپری row کو مسترد کرنے سے پہلے پڑھنا مفید ہے۔ range میں اوپر جانے سے دونوں جانب ایک ہی factor سے اضافہ ہوتا ہے، اس لیے total بدلتا ہے لیکن input اور output کی تقسیم بالکل وہی رہتی ہے۔

Sonnet 5 کے لیے $2 input اور $10 output کی فیس ہے۔ Anthropic نے اسے 31 August 2026 تک introductory pricing کے طور پر اس rate پر جاری کیا تھا۔ 1 September کو یہ rate بڑھ کر $3 اور $15 ہونا تھا، لیکن اس کے بجائے $2 اور $10 کو standard price بنا دیا گیا۔ اضافہ کبھی نافذ نہیں ہوا، اس لیے نیچے دی گئی ہر worked example میں وہی rate استعمال ہوا ہے جو آپ آج ادا کرتے ہیں۔

اس صفحے کے پہلی بار شائع ہونے کے بعد Anthropic نے نئے models بھی جاری کیے ہیں، اور claude.com/pricing اب اوپر دیے گئے چار models کو legacy models کے طور پر دکھاتا ہے، جو اب بھی دستیاب ہیں۔ نئے models بھی وہی 5x ratio رکھتے ہیں۔ Opus 5.5 کے لیے $4 اور $20، Sonnet 5.5 کے لیے $2 اور $10، اور Fable 5.1 کے لیے $10 اور $50 کی فیس ہے۔ Haiku 5.5، 100,000 tokens تک کے prompts کے لیے $0.10 اور $0.50 لیتا ہے؛ اس حد سے زیادہ پر یہ فیس $0.50 اور $2.50 ہو جاتی ہے۔ نیچے calculate کیا گیا 60,000 token agent step اس حد سے کم ہے، لیکن جس agent کی history مسلسل بڑھتی رہے وہ آخرکار اس حد کو عبور کر لے گا۔ Haiku 5.5 کے دو price tiers حقیقی کاموں پر کیسے اثر انداز ہوتے ہیں دکھاتا ہے کہ اس اضافے سے bill پر کیا اثر پڑتا ہے۔ Opus 5.5 کے base input اور output rates، Opus 5 کے مقابلے میں 20% کم ہیں، اس لیے نیچے Opus 5 کے ہر uncached figure کی Opus 5.5 پر قیمت 20% کم ہوگی۔ Cached figures مزید کم ہوں گے، کیونکہ Opus 5.5، cache hits کو فی دس لاکھ tokens $0.20 پر پڑھتا ہے، جبکہ Opus 5 پر یہ قیمت $0.50 ہے؛ یعنی 60% کمی۔ نیچے Opus 5 پر جس cached agent step کی قیمت $0.0725 ہے، Opus 5.5 پر اس کی قیمت تقریباً $0.047 ہوگی، یعنی تقریباً 35% کم۔

Rates تبدیل ہوتے رہتے ہیں، اور انہیں check کرنے کے لیے یہ صفحہ قابل اعتماد ذریعہ نہیں ہے۔ claude.com/pricing اصل ماخذ ہے۔ قیمت تبدیل ہونے کے بعد بھی طریقۂ حساب برقرار رہتا ہے۔

ایک اہم caveat Anthropic کی price table کے نیچے موجود notes میں ہے، rates میں نہیں۔ Anthropic کا pricing page بتاتا ہے کہ Claude 4.7 اور اس کے بعد کے models ایک نیا tokenizer استعمال کرتے ہیں، جو Sonnet 4.6 اور اس سے پہلے کے tokenizer کے مقابلے میں ایک ہی text کے لیے تقریباً 30% زیادہ tokens بناتا ہے۔ صرف فی دس لاکھ tokens قیمت کا موازنہ کرنے سے نیا model بظاہر سستا لگے گا، کیونکہ اسی document کے لیے اس میں tokens زیادہ ہوں گے۔ موازنہ مکمل ہونے والے task کی لاگت پر کریں، اور اپنے حقیقی prompts کو اسی model کے مطابق count کریں جسے آپ استعمال کرنے کا ارادہ رکھتے ہیں۔ Providers کے درمیان بھی یہی مسئلہ موجود ہے، کیونکہ ان کے tokenizers بھی ایک دوسرے سے مختلف ہوتے ہیں۔ اس لیے Claude اور ChatGPT پر حقیقی کام کی لاگت کا موازنہ دونوں rate cards کو ساتھ رکھنے سے زیادہ مفید ہے۔ حقیقی text میں Claude کے دس لاکھ tokens کی قدر بتاتا ہے کہ عملی طور پر یہ volume کیسا دکھائی دیتا ہے۔

آپ کے بل پر output کب غالب آنا شروع ہوتا ہے؟

جب output کی قیمت input کے مقابلے میں 5 گنا ہو، تو break-even تناسب ذہن میں رکھنا آسان ہوتا ہے۔ اپنے input tokens کو I اور output tokens کو O کہیں۔ Input کی لاگت I ہے۔ Output کی لاگت 5 گنا O ہے۔ جب 5 گنا O، I سے زیادہ ہو جائے تو آپ کے کل خرچ میں output کا حصہ نصف سے بڑھ جاتا ہے۔ اس کے لیے token ratio 5 input سے 1 output ہے۔

لہٰذا اگر آپ کا prompt، reply سے 5 گنا سے زیادہ طویل ہے تو input خرچ کی بڑی مد ہے۔ اس سے کم تناسب پر output بڑی مد ہے۔

چارٹShare of spend by input to output token ratio, at 5x output pricing
اس چارٹ کے پیچھے کا ڈیٹا
[
  {
    "label": "100:1",
    "input_share_pct": 95.2,
    "output_share_pct": 4.8
  },
  {
    "label": "75:1",
    "input_share_pct": 93.75,
    "output_share_pct": 6.25
  },
  {
    "label": "20:1",
    "input_share_pct": 80,
    "output_share_pct": 20
  },
  {
    "label": "10:1",
    "input_share_pct": 66.7,
    "output_share_pct": 33.3
  },
  {
    "label": "5:1",
    "input_share_pct": 50,
    "output_share_pct": 50
  },
  {
    "label": "1:1",
    "input_share_pct": 16.7,
    "output_share_pct": 83.3
  },
  {
    "label": "1:6",
    "input_share_pct": 3.2,
    "output_share_pct": 96.8
  }
]

100 سے 1 کے تناسب پر output کل خرچ کا 4.8% ہوتا ہے، اور prompt مختصر کرنا ہی واحد قابلِ قدر کام ہوتا ہے۔ 5 سے 1 کے تناسب پر دونوں جانب کا خرچ برابر ہوتا ہے۔ 1 سے 6 کے تناسب پر output کا حصہ 96.8% ہوتا ہے اور prompt کی لاگت round-off error کے برابر رہ جاتی ہے۔ اکثر لوگ اپنے اصل تناسب کا غلط اندازہ لگاتے ہیں، اس لیے کسی بھی optimization سے پہلے اسے اپنے logs سے معلوم کریں۔

ایک agent workload: طویل context اندر، مختصر جواب باہر

retrieval agent کا ایک step لیں: retrieved documents اور conversation history کے 60,000 input tokens، اور 800 tokens کا جواب۔ یہ 75 کے مقابلے میں 1 ہے، جو ہر اس workload کے لیے معمول ہے جو لکھنے سے پہلے پڑھتا ہے۔

چارٹOne agent step, 60,000 input and 800 output tokens, US dollars per call
اس چارٹ کے پیچھے کا ڈیٹا
[
  {
    "label": "Haiku 4.5",
    "input_cost": 0.06,
    "output_cost": 0.004,
    "total_cost": 0.064
  },
  {
    "label": "Sonnet 5",
    "input_cost": 0.12,
    "output_cost": 0.008,
    "total_cost": 0.128
  },
  {
    "label": "Opus 5",
    "input_cost": 0.3,
    "output_cost": 0.02,
    "total_cost": 0.32
  },
  {
    "label": "Fable 5",
    "input_cost": 0.6,
    "output_cost": 0.04,
    "total_cost": 0.64
  }
]

ہر model پر output اس call کا 6.25% ہے، کیونکہ پورے price list میں یہ ratio یکساں رہتا ہے۔ اس call کی لاگت Opus 5 پر $0.32، Sonnet 5 پر $0.128، اور Haiku 4.5 پر $0.064 ہے۔ Opus 5 پر روزانہ ایسے 200 steps کی لاگت روزانہ $64 ہے۔

تقسیم دیکھنے کے بعد اہم اقدام واضح ہو جاتا ہے۔ جواب کو 800 tokens سے 400 tokens کرنے سے call کی لاگت تقریباً 3% کم ہوتی ہے۔ prompt سے 20,000 tokens کا پرانا context نکالنے سے لاگت تقریباً ایک تہائی کم ہوتی ہے۔ read-heavy agent میں output length کم کرنا تقریباً بے فائدہ کوشش ہے۔ coding agent کے tokens اصل میں کہاں خرچ ہوتے ہیں اس بات کی تفصیل دیتا ہے کہ prompt میں ابتدا ہی سے کیا کچھ شامل ہوتا ہے۔

ایک generation workload: مختصر prompt، طویل draft

اب صورتِ حال بدلیں۔ 2,000 tokens کا brief اور 12,000 tokens کا draft، یعنی 1 سے 6 کا تناسب۔

چارٹOne draft, 2,000 input and 12,000 output tokens, US dollars per draft
اس چارٹ کے پیچھے کا ڈیٹا
[
  {
    "label": "Haiku 4.5",
    "input_cost": 0.002,
    "output_cost": 0.06,
    "total_cost": 0.062,
    "batch_total_cost": 0.031
  },
  {
    "label": "Sonnet 5",
    "input_cost": 0.004,
    "output_cost": 0.12,
    "total_cost": 0.124,
    "batch_total_cost": 0.062
  },
  {
    "label": "Opus 5",
    "input_cost": 0.01,
    "output_cost": 0.3,
    "total_cost": 0.31,
    "batch_total_cost": 0.155
  },
  {
    "label": "Fable 5",
    "input_cost": 0.02,
    "output_cost": 0.6,
    "total_cost": 0.62,
    "batch_total_cost": 0.31
  }
]

Output اس bill کا 96.8% ہے۔ Opus 5 کی فی draft لاگت $0.31 ہے، جبکہ Haiku 4.5 پر یہی لاگت $0.062 ہے۔ پانچ گنا کا یہ فرق تقریباً مکمل طور پر output کی وجہ سے ہے، اور یہی وہ حصہ ہے جہاں سستا model آپ کی سب سے زیادہ بچت کرتا ہے۔

آخری column میں یہی کام Batch API کے ذریعے دکھایا گیا ہے، جو input اور output دونوں پر 50% رعایت دیتا ہے۔ Opus 5 کی فی draft لاگت کم ہو کر $0.155 رہ جاتی ہے۔ Batch فوری طور پر نہیں بلکہ asynchronous طریقے سے کام کرتا ہے۔ Anthropic کے مطابق زیادہ تر batches ایک گھنٹے سے کم وقت میں مکمل ہو جاتے ہیں، لیکن 24 گھنٹے بعد بھی processing میں موجود batch expire ہو جاتا ہے۔ اس وقت تک جن requests پر عمل نہیں ہوا ہوتا، وہ expired، unbilled اور message کے بغیر واپس آتی ہیں۔ اس لیے یہ رات بھر report generation اور bulk classification کے لیے موزوں ہے، بشرطیکہ expire ہونے والی requests کو دوبارہ submit کیا جائے۔ یہ ایسے کام کے لیے موزوں نہیں جس کے مکمل ہونے کا کوئی شخص بیٹھ کر انتظار کر رہا ہو۔

یہاں model routing agent step کے برعکس مؤثر ثابت ہوتی ہے۔ اگر کام کا تفصیلی حصہ mechanical ہو، مثلاً text کو دوبارہ format کرنا یا پہلے سے منظور شدہ outline کو expand کرنا، تو سستا model یہ tokens قیمت کے پانچویں حصے میں تیار کر دیتا ہے۔ Opus، Sonnet اور Haiku میں انتخاب میں بتایا گیا ہے کہ quality کی حد حقیقت میں کہاں قائم ہوتی ہے۔

کیشنگ صرف input کے اخراجات کم کرتی ہے

Prompt caching آپ کے prompt کے ایک prefix کو server پر محفوظ کرتی ہے اور اسے دوبارہ پڑھنے کے لیے input rate کا ایک حصہ وصول کرتی ہے۔ 27 October 2026 تک، اس صفحے پر قیمت والے models کے لیے multipliers یہ ہیں: 5 minute cache لکھنے کے لیے base input rate کا 1.25x، 1 hour cache لکھنے کے لیے 2x، اور cache hit پڑھنے کے لیے 0.1x۔ نئے models میں cache hits پڑھنے کی قیمت مزید کم ہے: Opus 5.5 اور Sonnet 5.5 پر 0.05x، جبکہ Fable 5.1 پر 0.025x۔

Output اس رعایت میں شامل نہیں ہے۔ Cached output نام کی کوئی چیز نہیں ہے۔ Model جتنے بھی tokens لکھتا ہے، ہر بار ان پر مکمل output rate کے مطابق billing ہوتی ہے، خواہ prompt کا کتنا ہی حصہ cache hit کے طور پر واپس آیا ہو۔

Opus 5 پر یہی agent step لیں، جس میں 60,000 input tokens میں سے 55,000 warm cache سے فراہم کیے جاتے ہیں۔

چارٹThe same Opus 5 agent step, with and without a warm 55,000 token cache, US dollars
اس چارٹ کے پیچھے کا ڈیٹا
[
  {
    "label": "No cache",
    "input_cost": 0.3,
    "output_cost": 0.02,
    "total_cost": 0.32
  },
  {
    "label": "55k prefix cache read",
    "input_cost": 0.0525,
    "output_cost": 0.02,
    "total_cost": 0.0725
  }
]

Call کی لاگت $0.32 سے کم ہو کر $0.0725 رہ جاتی ہے۔ Output کی لاگت تبدیل نہیں ہوتی: پہلے $0.02، اور بعد میں بھی $0.02۔ Caching bill کم کرتی ہے اور اس کی ساخت تبدیل کر دیتی ہے۔ اس call کی لاگت میں output کا حصہ 6.25% تھا۔ اب یہ call کے ایک چوتھائی سے زیادہ ہے، اس لیے اگلا مؤثر قدم بھی بدل جاتا ہے۔

پہلی call میں cache لکھنے کی لاگت شامل ہوتی ہے۔ 5 minute cache لکھنے کی لاگت base input کی 1.25x ہوتی ہے، اس لیے ایک hit کے بعد ہی یہ لاگت پوری ہو جاتی ہے۔ 1 hour cache لکھنے کی لاگت 2x ہوتی ہے، اس لیے اسے پورا کرنے کے لیے دو hits درکار ہوتے ہیں۔ write اور read multipliers، اور caching کب فائدہ دینا بند کرتی ہے میں اس حساب کی مکمل وضاحت ہے۔

چار طریقے جنہیں آپ کنٹرول کر سکتے ہیں

  1. max_tokens کو model maximum کے بجائے اپنی p95 output length پر مقرر کریں۔
  2. زیادہ تفصیلی مراحل کو کم لاگت والے model پر route کریں۔
  3. جس کام کا کوئی انتظار نہیں کر رہا، اسے batch کریں۔
  4. وہ instructions حذف کریں جو replies کو غیر ضروری طور پر طویل بناتی ہیں۔

max_tokens ایک سخت بالائی حد ہے۔ اسے زیادہ مقرر کرنے کی اپنی کوئی لاگت نہیں، کیونکہ billing تیار کیے گئے tokens پر ہوتی ہے، اس بالائی حد پر نہیں۔ فراخ cap صرف اس reply کی حد ختم کرتی ہے جو غلط سمت میں طویل ہو جائے۔ اپنے logs سے output_tokens distribution نکالیں، cap کو 95th percentile سے کچھ اوپر مقرر کریں، اور stop_reason: "max_tokens" کو code میں handle کریں: response جاری رکھیں یا دوبارہ کوشش کریں۔ جس truncation کا آپ بروقت پتا لگا لیتے ہیں، اس کی لاگت اس 4,000 token کے غیر ضروری طویل جواب سے کم ہوتی ہے جس کی ادائیگی بھی ہو اور جسے ضائع بھی کرنا پڑے۔ Thinking بھی output_tokens میں شامل ہوتی ہے اور max_tokens کے خلاف شمار ہوتی ہے، اس لیے cap کا سائز اسی evidence کی بنیاد پر مقرر کریں۔ Adaptive thinking والے models میں، اگر thinking بار بار reply کا زیادہ حصہ لے رہی ہو تو effort level کم کریں۔

Routing اس وقت مؤثر ہوتی ہے جب کسی step کا مہنگا حصہ judgement کے بجائے volume ہو۔ فیصلہ strong model سے کروائیں اور typing کسی کم لاگت والے model کے سپرد کریں۔ پہلے اپنے evaluation set پر routed version کی پیمائش کریں، کیونکہ اہم عدد مکمل کیے گئے task کی فی task لاگت ہے۔ اوپر بیان کیے گئے agent step میں، دو Haiku 4.5 attempts کی لاگت $0.128 تھی، جبکہ ایک Opus 5 attempt کی لاگت $0.32 تھی؛ اس لیے قیمت کا فرق ایک یا دو retry کی لاگت پوری کر دیتا ہے۔ لیکن ایسا غلط جواب اس فرق سے پورا نہیں ہوتا جسے کوئی پکڑ نہ سکے۔

Batching output پر discount دینے والا واحد طریقہ ہے۔ دونوں سمتوں پر 50% رعایت ملتی ہے، زیادہ تر batches ایک گھنٹے کے اندر مکمل ہو جاتی ہیں، اور مقررہ schedule پر چلنے والا ہر کام اہل ہوتا ہے، بشرطیکہ job 24 hour کی حد پر expire ہونے والی ہر چیز دوبارہ submit کرے۔

آخری طریقہ وہ ہے جسے لوگ نظرانداز کر دیتے ہیں۔ "be thorough" اور "explain your reasoning" جیسے جملے آپ کی ہر call پر output length مقرر کرتے ہیں۔ ان کی جگہ مطلوبہ format واضح کریں: "Answer in at most three sentences" یا "Return only the JSON object, with no preamble"۔ ایسا system prompt جو ہر reply میں 300 tokens شامل کرے، prompt میں شامل کیے گئے انہی 300 tokens کے مقابلے میں پانچ گنا لاگت رکھتا ہے۔ running agent کے اخراجات کو قابو میں رکھنا monitoring کے پہلو کا احاطہ کرتا ہے، اور یہ طے کرنا کہ آپ کے pattern کے لیے API سستی ہے یا flat subscription اس سے پہلے طے کر لینا بہتر ہے کہ آپ per-token spend کو fine-tune کرنے میں ایک ہفتہ صرف کریں، جسے subscription پہلے ہی پورا کر دیتی۔ ایک developer کے لیے معاملہ زیادہ تر اس بات تک محدود ہے کہ Claude Pro کی $20 ماہانہ فیس اور اس کے ساتھ ملنے والی usage limits اس کام کے لیے کافی ہیں یا نہیں، جسے آپ بصورت دیگر meter کر رہے ہوتے۔ اگر آپ پہلے ہی session کے دوران ان limits تک پہنچ رہے ہیں تو یہ معلوم کرنا کہ آپ کس window کا انتظار کر رہے ہیں پہلے آتا ہے، کیونکہ اس کے بعد حل کم لاگت والا model، ہلکا context، اضافی usage credits، یا اس کام کو metered API پر منتقل کرنا ہو سکتا ہے۔ اگر metered API اس کام کے لیے سستا انتخاب ثابت ہو تو چھوٹے plan پر آ جانا یا اسے cancel کرنا پہلے سے ادا کیے گئے مہینے کو برقرار رکھتا ہے، اس لیے منتقلی کے وقت آپ کی کوئی لاگت نہیں ہوتی۔ اگر آپ جس plan کا Pro سے موازنہ کر رہے ہیں وہ metered API کے بجائے ChatGPT کا plan ہے تو دونوں subscription ladders کی side-by-side قیمتیں دکھاتی ہیں کہ coding work کے لیے کون سا سستا ہے۔ اگر یہ سوال ایک developer کے بجائے team کے لیے پوچھا جا رہا ہو تو یاد رکھیں کہ Claude Enterprise فی seat fee کو انہی API rates پر metered tokens کے ساتھ جوڑتا ہے، اس لیے اس page کا ہر طریقہ bill کے metered حصے پر اب بھی لاگو ہوتا ہے۔

FAQ

output tokens کی لاگت input tokens سے زیادہ کیوں ہوتی ہے؟

انہیں generate کرنے کے لیے فی token کہیں زیادہ accelerator وقت درکار ہوتا ہے۔ Prompt کو پورے متن پر ایک forward pass میں process کیا جاتا ہے، اس لیے model weights کو ایک بار پڑھنے سے ہزاروں tokens cover ہو جاتے ہیں اور hardware عموماً multiply throughput سے محدود ہوتا ہے۔ عام decoding میں reply ایک وقت میں ایک token بنا کر تیار کیا جاتا ہے۔ ہر token کے لیے الگ forward pass درکار ہوتا ہے، جس میں model weights اور بڑھتا ہوا KV cache دوبارہ پڑھا جاتا ہے۔ اس لیے hardware عموماً memory bandwidth سے محدود ہوتا ہے۔ speculative decoding جیسی تکنیکیں اس فرق کو کم کرتی ہیں، مگر ختم نہیں کرتیں۔ Anthropic موجودہ مکمل catalogue میں input کے مقابلے میں output کی قیمت پانچ گنا رکھتا ہے، Haiku 5.5 سے Fable 5.1 تک۔

کیا prompt caching سے output tokens سستے ہو جاتے ہیں؟

نہیں۔ Prompt caching صرف input پر لاگو ہوتی ہے۔ 27 October 2026 تک زیادہ تر models میں cache read کی لاگت base input rate کا 0.1x ہے، جبکہ Opus 5.5 اور Sonnet 5.5 پر 0.05x، اور Fable 5.1 پر 0.025x ہے۔ cache writes کی لاگت 5 minute duration کے لیے 1.25x اور 1 hour duration کے لیے 2x ہے۔ ہر call پر output کی مکمل rate کے مطابق billing ہوتی ہے، چاہے cache نے کچھ بھی کیا ہو۔ اسی لیے caching آپ کے bill کے حجم کے ساتھ اس کی تقسیم بھی بدلتی ہے: جب input کا حصہ بہت کم رہ جائے تو output وہ حصہ بن جاتا ہے جسے کم کرنا فائدہ مند ہوتا ہے۔

اگر reply مختصر ہو تو کیا زیادہ max_tokens کی وجہ سے مجھ سے رقم وصول ہوگی؟

نہیں۔ آپ سے ان tokens کی billing ہوتی ہے جو model حقیقتاً produce کرتا ہے، اس لیے max_tokens ایک حد ہے، پہلے سے محفوظ کی گئی مقدار نہیں۔ پھر بھی یہ اہم ہے، کیونکہ بے قابو طور پر بڑھنے والے reply کے لیے یہی واحد سخت limit ہے۔ اسے اپنے مشاہدہ کردہ output_tokens کے 95th percentile سے کچھ زیادہ مقرر کریں، پھر stop_reason: "max_tokens" کو code میں handle کریں، تاکہ خاموشی سے truncated جواب بھیجنے سے بچا جا سکے۔

میں اپنا input سے output token ratio کیسے معلوم کروں؟

ہر response کے usage object سے input_tokens، output_tokens، cache_read_input_tokens اور cache_creation_input_tokens log کریں، پھر ایک ہفتے کے totals کو divide کریں۔ اگر ratio 5 input سے 1 output سے زیادہ ہے تو خرچ prompt میں ہے؛ مستحکم حصے کو cache کریں اور باقی کو مختصر کریں۔ اگر ratio اس سے کم ہے تو خرچ reply میں ہے؛ اس کی لمبائی محدود کریں اور وہ steps جو زیادہ output generate کرتے ہیں، کسی سستے model یا Batch API پر منتقل کریں۔

کیا یہ مضمون مفید تھا؟