מהם tokens ב־Claude ואיך Claude Code מחשב עלות

מהם tokens ב־Claude?

token הוא יחידת הטקסט ש־Claude קורא וכותב: חלק ממילה. במילון המונחים של Anthropic מצוין כי במודלים שקדמו ל־Claude Opus 4.7 מדובר בכ־3.5 תווים באנגלית. ב־tokenizer הנוכחי היחס קרוב יותר ל־2.5, משום ש־Anthropic מגדירה 1M tokens ככ־2.5M תווים. בכל מקרה, לאחר שסופרים גם רווחים וסימני פיסוק, מתקבלים הרבה יותר מ־token אחד לכל מילה. לכן אלף מילים של טקסט רציף הן בנוחות יותר מ־1,300 tokens. קוד צורך יותר tokens בכל שורה: סוגריים מסולסלים, אופרטורים, קווים תחתונים והזחה מתפצלים ליותר tokens לכל תו מאשר באנגלית. קובץ מקור בן כמה מאות שורות מכיל בדרך כלל כמה אלפי tokens. קובץ בן 2,000 שורות שהסוכן מחליט לקרוא עולה חמש ספרות של tokens עוד לפני שנכתבה שורת קוד חדשה.

יש שני דברים ב־tokenizers שמבלבלים משתמשים. ראשית, הם ייחודיים לכל מודל. נכון ל־October 2026, Claude Opus 4.7 וכל מודל מאוחר יותר, כולל Fable 5.1, Opus 5.5, Sonnet 5.5 ו־Haiku 5.5 הנוכחיים, משתמשים ב־tokenizer חדש יותר שמפיק בערך 30% יותר tokens עבור אותו טקסט לעומת מודלים קודמים של Claude, כגון Haiku 4.5. העלייה המדויקת משתנה לפי התוכן. לכן כל אומדן המבוסס על tokens משתנה, אף שהמחירים לכל token לא עלו בהתאם. שנית, tiktoken, הספרייה שאליה פונה כמעט כל פוסט בבלוג, היא tokenizer של OpenAI ולא של Claude. לכן הספירות שלה לא יתאימו לחיוב של Anthropic. הספירה היחידה שאפשר לסמוך עליה מתקבלת מנקודת הקצה count_tokens, שמוסברת בהמשך.

הסיבה שסשן הקידוד שלך עולה כפי שהוא עולה

כל חשבון של Claude, בין שמדובר בחשבונית API ובין במגבלת מנוי, מבוסס בעיקר על מדד אחד: טוקנים נכנסים וטוקנים יוצאים. כמה מכלי ה־API מוסיפים חיוב נפרד משלהם; חיפוש באינטרנט, למשל, עולה $10 לכל 1,000 חיפושים נכון ל־October 2026, נוסף על הטוקנים שהתוצאות שלו מוסיפות. עם זאת, בסשן קידוד המדד שקובע את העלות הוא מדד הטוקנים. דף התמחור מציג זאת בפשטות: סכום מסוים בדולרים לכל מיליון טוקני קלט, וסכום אחר לכל מיליון טוקני פלט. מה שהוא אינו מסביר הוא שבסשן קידוד agentic צד הקלט של המדד פועל בהיקף גדול בהרבה מכפי שנדמה באופן אינטואיטיבי, משום שכל השיחה נשלחת מחדש בכל תור. אני מוכר תשתיות מחויבות לפי שימוש כבר 15 שנה, וטוקנים הם המדד הראשון שראיתי שבו רוב הלקוחות באמת אינם יכולים לומר מה גורם לו להתקדם. זהו השיעור בקריאת מדדים: מה נחשב קלט ומה נחשב פלט בסשן agentic, מדוע לולאת השליחה מחדש יקרה כל כך, כיצד prompt caching משנה את החישוב, ואילו מנופים אכן משפיעים על המספר.

הכול הוא קלט: מה המונה סופר בפועל

אנשים מניחים שהם משלמים על הקוד ש־Claude כותב. בסשן agentic זהו הסעיף הקטן. טוקני קלט, בתעריף הזול יותר אך בנפח גדול בהרבה, כוללים:

• ה־system prompt. הוראות ה־harness של Claude Code עצמו, וכן קובצי CLAUDE.md והזיכרון שלך, שנטענים בתחילת הסשן ונכללים בכל בקשה לאחר מכן.
• הגדרות כלים. כל סכימת כלי שהסוכן יכול להפעיל. כל שרת MCP שאליו מתחברים מוסיף לתקורה הקבועה הזו, אף ש־Claude Code דוחה כעת כברירת מחדל טעינה של הגדרות MCP מלאות לכלים. לכן רק שמות הכלים נמצאים ב־context עד שכלי מופעל לראשונה. הדבר מפחית את העלות, אך אינו מבטל אותה.
• כל קובץ שהסוכן קורא. Read של קובץ מקור מכניס את הקובץ כולו ל־context, והוא נשאר שם.
• כל תוצאת כלי. הרצות בדיקות, פלט של grep, פלט מסוף, לוגים של build — הכול חוזר כטוקני קלט. חבילת בדיקות כושלת שמדפיסה 8,000 שורות היא ספר קצר. נכון ל־October 2026, Claude Code מעביר כברירת מחדל כ־30,000 תווים של פלט פקודה ישירות, וכל פלט ארוך יותר מגיע כקובץ שנשמר בצירוף תצוגה מקדימה של עד 2,000 תווים. עם זאת, כל פלט שמתחת למגבלה הזו, וכל קריאה מאוחרת של הקובץ שנשמר, מחויבים במלואם.
• כל השיחה עד אותו רגע, שנשלחת מחדש בכל תור. לנושא הזה מגיע סעיף נפרד משל עצמו.

השליחה החוזרת שאיש אינו מתמחר

ה־Claude API הוא חסר מצב. הוא אינו זוכר את הסשן שלכם בין בקשות, ולמעשה שום רכיב אחר אינו עושה זאת. לכן בתור 2 הלקוח שולח את תור 1, את התגובה של המודל ואת ההודעה החדשה שלכם. בתור 50 הוא שולח מחדש את כל מה שעדיין נמצא בהקשר מתורות 1 עד 49, כולל כל קובץ שנקרא, כל תוצאת כלי וכל diff שלא הוסרו בתהליך הדחיסה, וכן את תור 50. הדחיסה מחליפה היסטוריה ישנה בסיכום, וקריאות הקבצים של subagent נשארות בהקשר שלו; רק התוצאה שלו חוזרת. המודל קורא מחדש את כל התמליל שנשמר בכל פעם, וכל אחד מהטוקנים האלה מחויב כקלט.

התוצאה היא שהעלות לכל תור גדלה בקירוב באופן ליניארי עם אורך הסשן, ואילו העלות הכוללת של הסשן גדלה בקירוב באופן ריבועי. הודעה שעלתה חצי סנט בתור 3 עלולה לעלות פי 20 בתור 60, אף שמדובר באותה שאלה בת שורה אחת, משום שהיא נושאת איתה את המטען של 60 תורות. זו העובדה היחידה שמסבירה את רוב הפניות בנוסח "למה החשבון שלי היה כל כך גבוה", ואין זו ייחודיות של Claude; כל מוצר LLM שנראה כאילו הוא שומר מצב משתמש למעשה ב־API חסר מצב, שמתחתיו פועל מנגנון שליחה חוזרת.

פלט: מה שאתה רואה, בתוספת תהליך החשיבה שאינך רואה

אסימוני פלט (output tokens) הם היקרים ביותר, פי חמישה מתעריף הקלט בכל סדרת הדגמים הנוכחית (נכון לאוקטובר 2026: 10$ ל-50$ ב-Fable 5.1, 4$ ל-20$ ב-Opus 5.5, 2$ ל-10$ ב-Sonnet 5.5, ו-0.10$ ל-0.50$ ב-Haiku 5.5 עבור פרומפטים של עד 100,000 אסימונים). הפלט כולל את הטקסט והקוד ש-Claude מייצר, וכן אסימוני חשיבה (thinking tokens): תהליך ההסקה הפנימי שהמודל מבצע לפני מתן תשובה. שתי עובדות חשובות כאן: החשיבה מחויבת לפי תעריפי פלט ונספרת כחלק מ-max_tokens. תגובת API שמסתיימת ב-stop_reason: "max_tokens" ותשובה קטועה מעידות לעיתים קרובות על כך שהחשיבה צרכה את התקציב לפני שהתשובה הספיקה להסתיים. במודלים הנוכחיים, ייתכן שסיכום תהליך החשיבה כלל לא יוצג; ה-API משמיט אותו כברירת מחדל ב-Fable 5.1, Opus 5.5, Sonnet 5.5, Haiku 5.5 ובדגמים מוקדמים יותר עד Opus 4.7, אך החשיבה עדיין התרחשה והיא עדיין מחויבת בתשלום. מה שאינו נראה לעין אינו בחינם.

Claude Code מאפשר חשיבה מורחבת כברירת מחדל מכיוון שהיא משפרת משמעותית עבודה רב-שלבית, ותקציב ברירת המחדל יכול להגיע לעשרות אלפי אסימונים לכל בקשה. במשימות פשוטות יותר ניתן להפחית את המאמץ: הנמיכו את רמת המאמץ באמצעות /effort או ב-/model, או כבו את החשיבה ב-/config במודלים המאפשרים זאת. נכון לאוקטובר 2026, Claude Code אינו יכול לכבות את החשיבה ב-Opus 5.5, Sonnet 5.5, Haiku 5.5 או בדגמי Fable, לכן רמת המאמץ היא הכלי לשליטה בעלויות. ה-API מעניק לכם יותר מרחב פעולה בשניים מהם: Haiku 5.5 מקבל את thinking: {"type": "disabled"} ברמת מאמץ גבוהה ומטה, וכך גם Opus 5 הישן, בעוד ש-Sonnet 5 הישן מקבל זאת בכל רמת מאמץ, כולל xhigh ו-max. המודל Sonnet 5.5 דוחה את "disabled" ומקבל במקום זאת את thinking: {"type": "between_tools"}, שמבטל חשיבה מוקדמת ברמות מאמץ נמוכה, בינונית או גבוהה, כך שבקשה ללא כלים מקבלת תשובה ללא חשיבה מקדימה. רק Opus 5.5 ודגמי Fable שומרים על חשיבה פעילה בכל בקשה. זהו כלי אמיתי לשליטה בעלויות, לא אמונה טפלה.

מטמון prompts משנה את החשבון

מטמון prompts הוא הסיבה שלולאת השליחה החוזרת אינה מרוששת את כולם. ה־API יכול לשמור במטמון תחילית יציבה של ה־prompt, ה־system prompt, הגדרות הכלים והיסטוריית השיחה, ובבקשה הבאה להגיש אותה במחיר של חלק קטן מהמחיר הרגיל. נכון לאוקטובר 2026, המכפילים הם: כתיבה למטמון עולה 1.25× מתעריף קלט הבסיס (2× בגרסה של שעה אחת), וקריאה מהמטמון עולה 0.1× ברוב המודלים, 0.05× ב־Claude Opus 5.5 וב־Claude Sonnet 5.5, ו־0.025× ב־Claude Fable 5.1. כתיבות הן בתעריף פרמיום; קריאות מעניקות הנחה של 90% ברוב המודלים, 95% ב־Opus 5.5 וב־Sonnet 5.5, ו־97.5% ב־Fable 5.1. תעריף הקריאה של Sonnet 5.5 הופחת מ־0.1× ל־0.05× ב־7 באוקטובר 2026. קריאה יחידה כבר מחזירה יותר מעלות הפרמיום של כתיבה לחמש דקות.

Claude Code מנהל את המטמון עבורך, ובסשן תקין כמעט כל השליחה החוזרת הגדולה מוגשת מהמטמון. עם זאת, המטמון פג לאחר פרק זמן של חוסר פעילות. נכון לאוקטובר 2026, Claude Code מקצה לשיחה הראשית שלך מטמון לשעה אחת במינוי, במסגרת השימוש הכלול בתוכנית שלך, ומטמון של חמש דקות מרגע השימוש האחרון כאשר משתמשים במפתח API, בספק ענן, או לאחר שמתחילים לצרוך קרדיטי שימוש (ההגדרה promptCacheTtl יכולה לבקש שם מטמון לשעה, בתעריף כתיבה של 2×). במטמון של חמש דקות, אם יצאת להפסקת קפה שהתארכה, חזרת ושלחת הודעה, המטמון כבר פג, וכל התחילית שנצברה נכתבת מחדש במחיר של 1.25× במקום להיקרא בתעריף המטמון. בסשן של 150K טוקנים, תור קר יחיד כותב את כל 150K הטוקנים במחיר של 1.25×, בעוד שתור חם היה קורא אותם במחיר של 0.1× — הבדל של פי 12.5 בעלות התחילית (פי 25 ב־Opus 5.5 וב־Sonnet 5.5, ופי 50 ב־Fable 5.1). זו התוצאה המנוגדת לאינטואיציה שכדאי להפנים: קצב עבודה של חוסר פעילות ולאחר מכן חידוש עלול לעלות יותר מעבודה רציפה, משום שכל הפסקה ארוכה יותר מ־TTL הופכת את התור הבא מקריאה זולה לכתיבה מחדש ויקרה. עבדו במקטעים; במטמון של חמש דקות, אל תזינו סשן גדול בהדרגה באמצעות הודעה אחת בכל עשר דקות.

אם אתם קוראים ל־API מ־יישום משלכם על VPS, שום דבר מזה אינו מתרחש אוטומטית: עליכם להפעיל זאת באמצעות cache_control, והטעות הנפוצה שנגרמת באופן עצמי היא שילוב של חותמת זמן או מזהה בקשה ב־system prompt, אשר משנה את בתי התחילית בכל בקשה ומנטרלת את המטמון בשקט. הסימן לכך הוא 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 read multiplier x base input price)
          + (output incl. thinking x output price)

read multiplier = 0.10 on most models, 0.05 on Opus 5.5 and Sonnet 5.5, 0.025 on Fable 5.1
session cost = sum over all turns

דוגמה מחושבת באמצעות Claude Opus 4.8, שכיום הוא מודל מדור קודם אך עדיין זמין, ונכון ל־October 2026 עדיין עולה $5 לכל מיליון טוקני קלט ו־$25 לכל מיליון טוקני פלט. תור באמצע סשן, הכולל 80,000 טוקנים של הקשר שהצטבר: 75,000 שנקראו מהמטמון, 3,000 שנכתבו אליו זה עתה, 2,000 טוקני קלט חדשים שאינם במטמון, ו־1,500 טוקני פלט, כולל חשיבה.

• קריאות מהמטמון: 75,000 × $0.50/M = $0.0375
• כתיבות למטמון: 3,000 × $6.25/M = $0.019
• קלט שאינו במטמון: 2,000 × $5/M = $0.010
• פלט: 1,500 × $25/M = $0.0375

כ־$0.10 לתור; חמישים תורים כאלה עולים כ־$5. כעת נבחן את אותו תור לאחר שתוקף המטמון פג: 78,000 הטוקנים שניתנים לשמירה נכתבים מחדש בעלות של $6.25/M, ובנוסף 2,000 הטוקנים שאינם במטמון מחויבים לפי $5/M. יחד הם עולים כ־$0.50 לפני הפלט, כלומר בערך פי חמישה מהעלות של התור החם במלואו, עבור אותה עבודה. הפער הזה מסכם במספר אחד את כל הסיפור של caching. ב־Claude Opus 5.5 הנוכחי ($4/$20, עם קריאות מהמטמון בתעריף של 0.05×), אותו תור חם עולה כ־$0.07 (קריאות $0.015, כתיבות $0.015, קלט שאינו במטמון $0.008, פלט $0.030), והגרסה הקרה עולה $0.40 לפני הפלט, כלומר קרוב לפי שישה מהתור החם. אותן ארבע שורות הן גם הדרך היחידה להשוות בין ספקים באופן אמין, משום שהתעריפים המוצגים מתעלמים מקריאות מהמטמון ומחשיבה, והרצתן על שלוש עבודות אמיתיות מראה היכן חשבון Claude גבוה או נמוך מזה של OpenAI.

אם אתם רוצים להבין את יחידת החיוב עצמה, ולא רק תור יחיד, כמה עולים מיליון טוקנים במונחים של עמודים, קבצים ודולרים מבצע את אותו חישוב ברמה גבוהה יותר. לצורך אומדן ולא לצורך חיזוי: הנתונים שפרסמה Anthropic לגבי פריסות ארגוניות של Claude Code מצביעים, נכון ל־October 2026, על ממוצע של כ־$13 למפתח ליום פעילות, $150 עד $250 בחודש, כאשר 90% מהמשתמשים נשארים מתחת ל־$30 ליום. העלות בפועל תלויה בבחירת המודל, בניהול הסשנים ובגודל בסיס הקוד, ולכן למנופים שיוצגו להלן יש חשיבות.

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

ב-Claude Code, הפקודה היא /usage (גם /cost עובד, זהו כינוי). בלוק ה-Session בראש המסך מציג נתונים סטטיסטיים על אסימונים והערכת עלות מחושבת מקומית עבור הסשן הנוכחי; בתוכניות מנויים, אותו מסך מציג את פסי הגבלת התוכנית שלכם ופירוט המייחס שימוש אחרון לכישורים (skills), סוכני משנה (subagents), תוספים ושרתי MCP בודדים. בגרסאות עדכניות, בלוק ה-Session כולל גם שורת Prompt cache (main) המציגה את נתח הקלט שהוגש מהמטמון (cache), את החסרים (misses), ואם המטמון "חם" כרגע. לחיוב רשמי בחשבונות API, דף השימוש ב-Claude Console הוא המקור האמין ביותר; הנתון ב-CLI הוא הערכה בלבד. /context משרטט רשת צבעונית של מה שתופס את חלון ההקשר, פרומפט המערכת, כלים, הגדרות MCP, קבצים והיסטוריה, וזו הדרך המהירה ביותר לזהות CLAUDE.md מנופח או שרת MCP "פטפטן"; במצב מסך מלא הוא מצמצם את הפירוט לכל פריט, והעברת all מרחיבה אותו.

מה-API, כל תגובה אומרת לכם בדיוק מה קרה:

response = client.messages.create(model="claude-sonnet-5-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 הוא רק השארית שלא אוחסנה במטמון, גודל הפרומפט האמיתי הוא סכום כל שלושת שדות הקלט. סוכן שרץ במשך שעה ומציג input_tokens: 4000 אינו זול; 200,000 האסימונים האחרים הוגשו מהמטמון. כדי להעריך עלות לפני השליחה, השתמשו ב-endpoint של ספירת אסימונים; הקריאה אליו חינמית, הוא כפוף למגבלת קצב משלו, וסופר באמצעות ה-tokenizer של המודל שתציינו (התייחסו לתוצאה כאל הערכה קרובה; החיוב משקף את הבקשה בפועל):

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

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

תוכניות מנוי לעומת תשלום לפי שימוש

המנגנון במדריך הזהה בכל מקום; רק אופן החיוב שונה. עם מפתח API, Anthropic מחייבת לפי שימוש, עבור כל token, בהתאם לתעריפים שפורסמו. כל סכום שמופיע למעלה הוא כסף אמיתי. המונה מתחיל לפעול מוקדם מכפי שרוב המשתמשים מצפים, משום שאין שכבת שימוש חינמית שאפשר להסתמך עליה. יש רק זיכוי קטן בעת ההרשמה וכמה נקודות קצה שאינן מחויבות, וזהו מה שחשבון API חדש מקבל בפועל לפני שמוסיפים אליו כרטיס. החריג, החל מ־October 7, 2026, הוא מנוי Max או Team: תוכניות אלה כוללות כעת זיכויי API חודשיים עבור היישומים והסוכנים שלכם ב־Claude Platform — $100 לחודש ב־Max 5x ו־$200 ב־Max 20x, וב־Team $20 עבור כל מושב Standard ו־$100 עבור כל מושב Premium, במאגר משותף ובתקרה של $500. כדי לקבל אותם, מקשרים ארגון ב־Console. זיכויים שלא נוצלו פגים בסוף כל מחזור חיוב, והם אינם מכסים שימוש אינטראקטיבי ב־Claude Code. במנוי Claude ‏(Pro, Max, Team ותוכניות Enterprise מדור קודם המבוססות על מושבים), השימוש ב־Claude Code מנוכה במקום זאת מהמכסה הכלולה בתוכנית. נכון ל־October 2026, מדובר בחלון שימוש מתגלגל של חמש שעות ובחלון שבועי, המשותפים בין המודלים ובין הצ'אט ב־claude.ai. הסכום ב־/usage דולר הוא מידע בלבד ואינו חיוב. שני חריגים נוספים קיימים נכון ל־October 2026: מושבי Enterprise הנוכחיים המבוססים על שימוש אינם כוללים שימוש כלל, ולכן כל token מחויב לפי תעריפי API רגילים; ומודלי Fable אינם כלולים במכסה של Pro, של מושבי Team מסוג Standard או של מושבי Enterprise רגילים מדור קודם. במקרים אלה הם פועלים באמצעות זיכויי שימוש בתשלום לפי שימוש. כאשר חלון מסתיים, תראו "You've hit your session limit" או "You've hit your weekly limit", יחד עם מועד האיפוס. מעבר בין מודלים באמצעות /model לא יחזיר את הגישה, משום שהחלונות משותפים לכל המודלים. החלונות משויכים לחשבון ולא ללקוח שבו אתם משתמשים באותו רגע. חשוב לדעת זאת אם אתם עדיין בודקים מה פועל באופן טבעי ב־Linux ואיזו תוכנית מכסה כל ממשק. השאלה איזה משני החלונות מוצה בפועל קובעת כמה זמן תצטרכו להמתין ומה כדאי לעשות בינתיים. לכן כדאי להכיר את האפשרויות כאשר מגיעים למגבלה באמצע משימה. בתוכניות אפשר להפעיל, לפי הצורך, זיכויי שימוש המנוהלים באמצעות /usage-credits, כדי לרכוש שימוש מעבר למכסה. בכוונה איני מציג את מכסות התוכניות: אלה המספרים המשתנים ביותר בנושא כולו. בדקו במקום זאת את claude.com/pricing ואת פסי /usage שלכם. מנגנון ה־token עדיין חשוב גם במנוי. סשן בזבזני מנצל את חלון השימוש בדיוק כפי שהיה מנצל כסף. למידע על צד המנויים, ראו איזו תוכנית Claude מתאימה לדפוס השימוש שלכם.

המנופים שבאמת עובדים

• תחמו את המידע שהסוכן קורא. "תקן את באג האימות ב־auth.py" קורא קובץ אחד; "שפר את בסיס הקוד הזה" קורא ארבעים. שמרו על CLAUDE.md מצומצם. הוא נטען בכל סשן, ולכן השאירו בו רק את העיקר והעבירו הוראות ייחודיות לזרימת עבודה ל־skills שנטענים לפי דרישה.
• שמרו על הקשר ברור ותמציתי. /clear בין משימות שאינן קשורות גורם לשליחה חוזרת ולחיוב חוזר של הקשר המיושן בכל הודעה עוקבת. בתוך משימה ארוכה אחת, /compact Focus on the failing tests and the diff מסכם את ההיסטוריה ומונע מכם להיקלע לעקומה הריבועית.
• התאימו את גודל המודל. Sonnet מתאים לרוב משימות התכנות במחיר של $2/$10 למיליון טוקנים נכון ל־October 2026. זהו כעת מחיר רגיל ולא מחיר השקה: Sonnet 5.5 עולה $2/$10, ו־Sonnet 5 שמר על המחיר $2/$10 לאחר שבוטלה העלייה המתוכננת ב־September 1 ל־$3/$15. לשם השוואה, Opus 5.5 עולה $4/$20, ו־Haiku 5.5 עולה $0.10/$0.50 (עבור prompts של עד 100,000 טוקנים, ו־$0.50/$2.50 מעל לכך), ולכן הוא מתאים לעבודת subagent מכנית, כגון מיון ראשוני של לוגים. Fable 5.1 נמצא בקצה האחר במחיר של $10/$50, זהה למחיר של Fable 5 ופי שניים וחצי מ־Opus 5.5 בשני צדדי המונה. לכן כדאי לדעת אילו משימות באמת מצדיקות את המחיר הזה לפני שמשאירים אותו נבחר לעבודה שגרתית. /model מחליף מודל באמצע הסשן.
• סננו מראש פלט מפורט. hook שמסנן באמצעות grep הרצת בדיקות ומשאיר רק כשלים, לפני ש־Claude רואה אותה, מצמצם תוצאת כלי של 20,000 טוקנים ל־300. הוא עושה זאת בכל שליחה חוזרת עתידית של אותו תור.
• רכזו משימות שאינן אינטראקטיביות. בצינורות ה־API שלכם, כגון סיווג, סקירה בכמות גדולה ומשימות לילה, ה־Batches API מריץ את אותם מודלים בהנחה של 50% תמורת מסירה אסינכרונית.
• התחשבו בשעון המטמון. עבדו במקטעים רציפים. סשן Claude Code ב־tmux על VPS מנותק אינו עולה דבר בזמן שהוא במצב סרק; טוקנים נצרכים רק כאשר תור מופעל. עם זאת, זמן סרק שעובר את ה־cache TTL מבטל את המטמון החם, והתור הבא מחויב על כתיבת ההקשר מחדש.

FAQ

כמה טוקנים משתמשת סשן קידוד ב־Claude Code?

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

האם טוקני חשיבה עולים כסף גם כאשר איני יכול לראות אותם?

כן. טוקני חשיבה מחויבים כטוקני פלט, לפי התעריף היקר, ונכללים במסגרת max_tokens. מודלים נוכחיים מחייבים עבורם גם כאשר הממשק אינו מציג את סיכום ההיסק. אם תגובה נקטעת עם stop_reason: "max_tokens" לפני שהתשובה הגלויה מסתיימת, סביר שטוקני החשיבה צרכו את התקציב. ב־Claude Code, הורידו את רמת המאמץ באמצעות /effort עבור משימות שאינן דורשות היסק מעמיק.

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

משום שה־API הוא stateless: בכל תור נשלחת מחדש השיחה שעדיין נמצאת בהקשר, כולל כל קובץ שנקרא, כל תוצאת כלי וכל חילופי הדברים הקודמים שלא הוסרו באמצעות compact. כל אלה מחויבים כקלט, ולכן תור 50 נושא את תורים 1 עד 49 כמטען. Prompt caching מגיש את הקידומת החוזרת במחיר של עשירית ממחיר קלט הבסיס ברוב המודלים: 5% ב־Opus 5.5 וב־Sonnet 5.5, ו־2.5% ב־Fable 5.1. עם זאת, הקידומת עצמה ממשיכה לגדול, וכל הפסקה ארוכה יותר מ־cache TTL הופכת את התור הבא לכתיבה מחדש במחיר מלא. /compact מקטין את ההיסטוריה; /clear מאפס אותה.

כיצד בודקים את השימוש שלי בטוקנים ואת העלות ב־Claude?

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