מהם tokens ב-Claude ואיך הם משפיעים על העלות

מהם tokens ב-Claude?

token הוא יחידת הטקסט ש-Claude קורא וכותב: שברי מילה, בערך 3.5 תווים באנגלית. נתון זה מגיע מהמילון של Anthropic, וכאשר סופרים רווחים וסימני פיסוק, התוצאה היא הרבה יותר מ-token אחד לכל מילה. לכן, אלף מילים של פרוזה הן מעל 1,300 tokens בביטחון. קוד צורך יותר tokens לכל שורה: סוגריים, אופרטורים, קווים תחתיים והזחות (indentation) מתפצלים ליותר tokens לכל תו בהשוואה לאנגלית. קובץ מקור בן כמה מאות שורות שוקל בדרך כלל כמה אלפי tokens. קובץ בן 2,000 שורות שהסוכן (agent) מחליט לקרוא דורש רכישה של עשרת אלפים tokens לפחות, עוד לפני שמישהו כתב שורה אחת של קוד חדש.

שני דברים לגבי tokenizer עלולים להטעות משתמשים. ראשית, הם ספציפיים למודל. החל מיולי 2026, Opus 4.7 ומעלה, Sonnet 5, ו-Fable 5 משתמשים ב-tokenizer חדש יותר המייצר בערך 30% יותר tokens עבור אותו טקסט בהשוואה למודלי Claude מוקדמים יותר (העלייה המדויקת משתנה לפי התוכן). דבר זה משנה כל תקציב שמתכננים ב-tokens, למרות שמחירי ה-per-token לא עלו יחד איתו. שנית, tiktoken, הספרייה שכל פוסט בבלוג משתמש בה, היא ה-tokenizer של OpenAI, והיא ממעיטה בספירה עבור Claude בכ-15–20% בטקסט רגיל, ויותר בכתיבת קוד. הספירה היחידה המהימנה היא באמצעות ה-endpoint של count_tokens, המפורט להלן.

למה מפגש הפיתוח שלך עולה את מה שהוא עולה

כל חשבון Claude, בין אם מדובר בחשבונית API או במגבלת מנוי, תלוי במדד אחד: tokens נכנסים ו-tokens יוצאים. דף המחירים מציג זאת כדבר פשוט: מחיר מסוים למיליון input tokens ומחיר מסוים למיליון output tokens. מה שהוא לא מציין הוא שבמפגש פיתוח מבוסס סוכנים (agentic coding session), צד ה-input של המדד פועל בעצימות גבוהה בהרבה ממה שניתן לצפות, מכיוון שכל השיחה נשלחת מחדש בכל שלב. אני מוכר תשתית מבוססת מדידה מזה חמש עשרה שנה, וה-tokens הם המדד הראשון שראיתי שבו רוב הלקוחות אינם יכולים לומר באמת מה גורם לצריכה לעלות. זהו שיעור בקריאת מדדים: מה נחשב כ-input ו-output במפגש agentic, מדוע לולאת השליחה מחדש יקרה כל כך, מדוע prompt caching משנה את החישוב, ואילו מנופים משפיעים בפועל על המספר.

Everything is input: מה המונה סופר בפועל

משתמשים מניחים שהם משלמים על הקוד ש-Claude כותב. במפגש (session) של סוכן (agent), זהו רק חלק קטן מהעלות. טוקנים של קלט (Input tokens) — בעלות נמוכה יותר אך בנפח גבוה בהרבה — כוללים:

• The system prompt. הוראות המערכת של Claude Code, בתוספת קובצי ה-CLAUDE.md והזיכרון שלך, הטעונים בתחילת המפגש ונמצאים בכל בקשה לאחר מכן.
• Tool definitions. כל סכימת כלי (tool schema) שהסוכן יכול לקרוא לה. כל MCP server שאתה מחבר מוסיף לעלות קבועה זו — אם כי Claude Code דוחה כעת הגדרות MCP מלאות כברירת מחדל, כך שרק שמות הכלים נמצאים בהקשר (context) עד לשימוש ראשון בכלי, מה שמפחית אך לא מבטל את העלות.
• כל קובץ שהסוכן קורא. Read של קובץ מקור מכניס את כולו להקשר, והוא נשאר שם.
• כל תוצאת כלי. הרצות בדיקות, פלט grep, פלט טרמינל, לוגים של build — הכל חוזר כטוקנים של קלט. ערכת בדיקות שנכשלת ומדפיסה 8,000 שורות גובה ממך תשלום עבור ספר קטן.
• כל השיחה עד כה, שנשלחת מחדש בכל שלב. סעיף זה ראוי לפירוט נפרד.

הסיבה לכך שהמחיר אינו קבוע

ה-Claude API הוא stateless. הוא אינו זוכר את הסשן (session) בין בקשות — שום דבר אינו נשמר. לכן, בתור 2, הלקוח שולח את תור 1 בתוספת התגובה שלו וההודעה החדשה שלך. בתור 50, הוא שולח מחדש את תור 1 עד 49 — כל קריאת קובץ, כל תוצאת כלי (tool result) וכל diff — בתוספת תור 50. המודל קורא מחדש את כל התמלול בכל פעם, וכל אחד מהטוקנים (tokens) הללו נחשב כ-input בתשלום.

התוצאה: העלות לכל תור גדלה באופן ליניארי עם אורך הסשן, והעלות הכוללת של הסשן גדלה באופן ריבועי בערך. הודעה שעולה חצי סנט בתור 3 יכולה לעלות פי עשרים בתור 60, עבור אותה שאלה בת שורה אחת, מכיוון שהיא נושאת עליה נתונים משישים תורים. זהו העובדה המרכזית שמסבירה את רוב הפניות בנושא "מדוע החיוב שלי היה כל כך גבוה", וזו אינה תכונה ייחודית של Claude — כל מוצר LLM שמרגיש stateful הוא למעשה stateless API עם לולאת שליחה מחדש (resend loop) מתחת לפני השטח.

Output: מה שאתה רואה, פלוס מה שאתה לא רואה

Output tokens הם היקרים ביותר — פי חמישה מהקצב של ה-input בכל סדרת המוצרים הנוכחית ($5/$25 ב-Opus 4.8, $3/$15 ב-Sonnet 5, $1/$5 ב-Haiku 4.5, נכון ליולי 2026). ה-Output כולל את הטקסט והקוד ש-Claude מייצר, וגם thinking tokens: ההיגיון הפנימי שהמודל מבצע לפני המענה. שני עובדות חשובות כאן. ה-Thinking נגבה לפי תעריפי ה-output ונחשב כחלק מ-max_tokens — תגובת API שנגמרת ב-stop_reason: "max_tokens" ותשובה מקוטעת משמעותן שה-thinking צרך את התקציב לפני שהתשובה הסתיימה. ובמודלים הנוכחיים, ייתכן שסיכום ההיגיון לא יוצג כלל — Opus 4.8, Sonnet 5, ו-Fable 5 משמיטים אותו כברירת מחדל — אך ה-thinking עדיין התבצע ועדיין נגבה. מה שאינו נראה אינו בחינם.

Claude Code מאפשר extended thinking כברירת מחדל מכיוון שהוא משפר באופן מדיד עבודה רב-שלבית, והתקציב الاברירת מחדל יכול להגיע לעשרות אלפי tokens לבקשה. במשימות פשוטות יותר ניתן להפחית זאת: ניתן להוריד את רמת המאמץ באמצעות /effort או ב-/model, או לשנות את הגדרות ה-thinking ב-/config. זהו כלי שליטה אמיתי בעלויות, לא אמונה טפלה.

Prompt caching משנה את החישובים

Prompt caching הוא הסיבה לכך שחזרות על בקשות (resend loop) לא יגרמו להוצאות כספיות מופרזות. ה-API יכול לשמור בזיכרון (cache) קידומת קבועה של ה-prompt שלך — system prompt, הגדרות כלים (tool definitions) והיסטוריית שיחה — ובבקשה הבאה להגיש אותה בחלק קטן מהמחיר. החל מיולי 2026 המכפילים הם: פעולת cache write עולה 1.25× ממחיר ה-input הבסיסי (2× עבור הגרסה של שעה אחת), ופעולת cache read עולה 0.1× בלבד. פעולות כתיבה הן יקרות יותר; פעולות קריאה מקבלות הנחה של 90%. קריאה אחת כבר מחזירה את העלות הנוספת של כתיבה למשך 5 דקות.

Claude Code מנהל את ה-caching עבורך, ובסשן תקין כמעט כל ההודעות החוזרות מוגשות מה-cache. אך ה-cache ברירת המחדל תקף למשך חמש דקות מהשימוש האחרון. אם תתרחקו להפסקה ארוכה ותחזרו לשלוח הודעה — ה-cache יפוג, וכל הקידומת שנצברה תיכתב מחדש ב-1.25× במקום להיקרא ב-0.1×. בסשן של 150K-token, פנייה אחת "קרה" (cold turn) עולה יותר מתריסר פניות "חמות" (warm turns). זהו תוצאה המנוגדת לאינטואיציה שחשוב להבין: קצב עבודה של הפסקות וחידושים עלול לעלות יותר מעבודה רציפה, מכיוון שכל הפסקה מעבר ל-TTL הופכת את הפנייה הבאה שלך מקריאה זולה לכתיבה יקרה. עבדו במנות; אל תשלחו הודעה אחת בכל עשר דקות בסשן ענק.

אם אתם קוראים ל-API מתוך האפליקציה שלכם ב-VPS, אתם לא מקבלים את היתרונות הללו בחינם — והטעות הנפוצה היא שילוב של timestamp או request ID בתוך ה-system prompt. הדבר משנה את הבתים (bytes) של הקידומת בכל בקשה ומבטל את ה-caching בשקט. הסימן לכך הוא usage.cache_read_input_tokens שנשאר על אפס לאורך קריאות שנראות זהות.

הנוסחה, עם דוגמה מפורטת

התעלמו מכל מי שטוען ש"סשן עולה $X". עלויות הסשנים משתנות בשינויים משמעותיים של סדרי גודל. מה שקבוע הוא הנוסחה:

turn cost = (uncached input      x base input price)
          + (cache writes        x 1.25 x base input price)
          + (cache reads         x 0.10 x base input price)
          + (output incl. thinking x output price)

session cost = sum over all turns

דוגמה מפורטת על Claude Opus 4.8, אשר נכון ליולי 2026 עולה $5 למיליון input tokens ו-$25 למיליון output tokens. שלב (turn) באמצע סשן הכולל 80,000 tokens של הקשר (context) מצטבר: 75,000 נקראו מה-cache, 3,000 נכתבו מחדש, 2,000 הם input חדש שלא היה ב-cache, ו-1,500 הם output tokens כולל thinking.

• Cache reads: 75,000 × $0.50/M = $0.0375
• Cache writes: 3,000 × $6.25/M = $0.019
• Uncached input: 2,000 × $5/M = $0.010
• Output: 1,500 × $25/M = $0.0375

כ-$0.10 עבור ה-turn; חמישים turns דומים יkosעלו כ-5$. כעת, אותו turn לאחר פקיעת תוקף ה-cache: כל ה-80,000 tokens נכתבים מחדש בעלות של $6.25/M, מה שנותן $0.50 לפני ה-output — בערך פי חמישה מה-turn המקורי, עבור אותה עבודה בדיוק. הפער הזה הוא תמצית נושא ה-caching במספר אחד.

לצורך כיול ולא לחיזוי: הנתונים שפרסמה Anthropic עבור פריסות Claude Code בארגונים, נכון ליולי 2026, עומדים בממוצע על כ-$13 למפתח ליום פעיל — $150–250 לחודש — כאשר 90% מהמשתמשים נשארים מתחת ל-$30 ליום. העלות בפועל תלויה בבחירת המודל, בניהול נכון של הסשנים (session hygiene) ובגודל ה-codebase, וזו בדיוק הסיבה שהכלים להלן חשובים.

צפייה בשימוש האישי שלך

ב-Claude Code, הפקודה היא /usage (גם /cost עדיין עובדת — זוהי פקודת קיצור). בלוק ה-Session בחלק העליון מציג סטטיסטיקות טוקנים והערכת עלות מחושבת מקומית עבור הסשן הנוכחי; בתוכניות מנוי, אותו מסך מציג את סרטי המגבלה של התוכנית שלך ופירוט של השימוש האחרון לפי skills, subagents, plugins ושרתי MCP בודדים. עבור חיוב רשמי בחשבונות API, עמוד ה-usage ב-Claude Console הוא המקור המהימן — הנתון ב-CLI הוא הערכה בלבד. הפקודה /context מציגה רשת צבעונית של מה תופס את ה-context window — system prompt, tools, MCP definitions, files ו-history — וזו הדרך המהירה ביותר לזהות CLAUDE.md מנופח או שרת MCP פעיל מדי; השתמש ב-all כדי להציג פירוט מלא לכל פריט.

דרך ה-API, כל תגובה מציינת בדיוק מה קרה:

response = client.messages.create(model="claude-sonnet-5", max_tokens=2048,
                                  messages=messages)
u = response.usage
total_prompt = u.input_tokens + u.cache_creation_input_tokens + u.cache_read_input_tokens
print(f"uncached={u.input_tokens} written={u.cache_creation_input_tokens} "
      f"read={u.cache_read_input_tokens} output={u.output_tokens}")

שים לב ש-input_tokens מייצג רק את השארית שלא נשמרה ב-cache — גודל ה-prompt האמיתי הוא סכום כל שלושת שדות הקלט. סוכן (agent) שרץ במשך שעה והציג input_tokens: 4000 אינו זול; 200,000 הטוקנים האחרים נשלחו מה-cache. כדי לבצע הערכה לפני השליחה, השתמש ב-endpoint של ספירת טוקנים — הקריאה אליו היא בחינם, היא פועלת תחת מגבלת קצב (rate limit) נפרדת, והיא סופרת באמצעות ה-tokenizer של המודל שתציין (התייחס לתוצאה כהערכה קרובה; החיוב משקף את הבקשה בפועל):

count = client.messages.count_tokens(model="claude-sonnet-5",
                                     messages=[{"role": "user", "content": big_file}])
print(count.input_tokens)

לעולם אל תשתמש ב-tiktoken, מהסיבה שצוינה לעיל.

תוכניות מנוי לעומת תשלום לפי שימוש (pay-as-you-go)

המנגנונים במדריך זה זהים בכל מקום; רק אופן התשלום שונה. עם מפתח API, Anthropic מחייבת לפי שימוש (pay-as-you-go), לפי טוקן, לפי התעריפים המפורסמים — כל מספר לעיל מייצג כסף אמיתי. במנוי Claude (כגון Pro, Max, Team, Enterprise), השימוש ב-Claude Code נגרר מהמכסה הכלולה בתוכנית שלך: החל מיולי 2026, מדובר בחלון זמן של חמש שעות מתגלגל בתוספת חלון שבועי, המשותף למודלים ולצ'אט ב-claude.ai, והסכום של /usage דולר הוא לידיעה בלבד ולא עבור חשבון. אם תסיים חלון זמן, תראה את ההודעה "You've hit your session limit" או "You've hit your weekly limit" עם זמן איפוס — והחלפת מודלים באמצעות /model לא תשחזר את הגישה, כיוון שחלונות הזמן משותפים לכל המודלים. ניתן להפעיל באופן אופציונלי קרדיטים לשימוש, המנוהלים באמצעות /usage-credits, כדי לרכוש שימוש מעבר לתקרה. אני לא מציין במכוון את מכסות התוכנית: אלו המספרים המשתנים ביותר בנושא זה, לכן בדוק את claude.com/pricing ואת סרטי ה-/usage שלך במקום. מנגנון הטוקנים עדיין רלוונטי גם במנוי — סשן בזבזני צורך את חלון הזמן שלך בדיוק כפי שהיה צורך דולרים. לצד המנוי, ראה איזה מנוי Claude מתאים לשימוש שלך.

המנופים שעובדים בפועל

• הגדרת היקף הקריאה של ה-agent. הפקודה "Fix the validation bug in auth.py" קוראת קובץ אחד; "improve this codebase" קוראת ארבעים. שמור על CLAUDE.md רזה — הוא נטען בכל session, לכן הגבל אותו רק לדברים חיוניים — והעבר הוראות ספציפיות ל-workflow לתוך skills שנטענים לפי דרישה.
• בהירות ותמציתיות. /clear בין משימות לא קשורות — context ישן נשלח מחדש, ונגבה מחדש, בכל הודעה עוקבת. בתוך משימה ארוכה אחת, /compact Focus on the failing tests and the diff מסכם את ההיסטוריה וממנע עלייה מעריכית בעלויות.
• בחירת גודל המודל המתאים. Sonnet מתאים לרוב משימות הקידוד בעלות של $2/$10 למיליון tokens במחירי ההיכרות נכון ליולי 2026 ($3/$15 במחיר הרגיל, לעומת Opus ב-$5/$25), ו-Haiku ב-$1/$5 הוא הכלי המתאים לעבודות subagent מכניות כמו triage של logs. /model מאפשר מעבר בין מודלים באמצע session.
• סינון מוקדם של פלט מפורט. שימוש ב-hook שמבצע grep לתוצאות בדיקה כדי להשאיר רק את הכשלים לפני שה-Claude רואה אותם, הופך 20,000 tokens של תוצאת כלי ל-300 tokens בלבד, והוא עושה זאת בכל שליחה חוזרת של אותו turn.
• עיבוד אצווה (Batch) לعملות שאינן אינטראקטיביות. עבור pipelines של ה-API שלך — סיווג, סקירה המונית, או משימות ליליות — ה-Batches API מריץ את אותם מודלים ב-50% הנחה בתמורה לעיבוד אסינכרוני.
• כיבוד זמן ה-cache. עבוד במשריגים רציפים. Claude Code session בתוך tmux על VPS אינו עולה דבר בזמן המתנה — tokens נשלחים רק כאשר turn רץ — אך זמן ההמתנה גורם לאובדן ה-warm cache, וה-turn הבא ישלם על כתיבה מחדש.

FAQ

כמה tokens צורך סשן תכנות ב-Claude Code?

אין מספר קבוע — תור (turn) אחד באמצע סשן עשוי להכיל עשרות אלפי prompt tokens לאחר הצטברות קבצים והיסטוריה. סשן עבודה מלא יכול להגיע למיליונים, כאשר רובם מוגשים מ-cache בעלות של עשירית מהתעריף הבסיסי. לצורך כיול, הנתונים שפרסמה Anthropic עבור ארגונים נכון ליולי 2026 עומדים בממוצע על כ-$13 למפתח ליום פעיל, כאשר 90% מהמשתמשים נמצאים מתחת ל-$30. הרץ /usage בסשן שלך; חמש דקות של מעקב אחריו עדיפות על כל ממוצע שפורסם.

האם thinking tokens עולים כסף גם כשאני לא רואה אותם?

כן. thinking tokens נגבים כ-output tokens — בתעריף הגבוה — ונחשבים כחלק מ-max_tokens. מודלים נוכחיים מחייבים עליהם גם כאשר הממשק אינו מציג את סיכום ההסבר (reasoning summary). אם תגובה נקטעת עם stop_reason: "max_tokens" לפני סיום התשובה הגלויה, סביר להניח ש-thinking צרך את התקציב. ב-Claude Code, ניתן להוריד את רמת המאמץ (effort level) באמצעות /effort עבור משימות שאינן דורשות הסקה עמוקה.

מדוע סשן Claude Code ארוך הופך ליקר יותר לכל הודעה?

מכיוון שה-API הוא stateless: כל תור שולח מחדש את כל השיחה — כל קובץ שנקרא, תוצאת כלי (tool result) וחילופי דברים קודמים — כ-input המחושב בתשלום. לכן, תור 50 כולל בתוכו את כל התורים מ-1 עד 49. prompt caching מספק את ה-prefix החוזר בעלות של בערך עשירית ממחיר ה-input הבסיסי, אך ה-prefix עצמו ממשיך לגדול. כל פער זמן מעבר ל-cache TTL יהפוך את התור הבא לכתיבה מחדש במחיר מלא. /compact מצמצם את ההיסטוריה; /clear מאפס אותה.

איך אני בודק את צריכת ה-tokens והעלות שלי ב-Claude?

ב-Claude Code, הפקודה /usage מציגה סטטיסטיקת tokens של הסשן, הערכת עלות מקומית, ופסים של מגבלות תוכנית במנויים (/cost הוא קיצור דרך); /context מציג מה ממלא את החלון. לקבלת נתוני חיוב API רשמיים, השתמש בדף ה-usage ב-Claude Console. בקוד שלך, קרא את response.usage — סיכום של input_tokens, cache_creation_input_tokens ו-cache_read_input_tokens ייתן את גודל ה-prompt האמיתי — והערך מראש באמצעות ה-endpoint של count_tokens, לעולם לא באמצעות tiktoken.