מהם tokens ב-Claude וכמה עולה סשן קידוד

מהם tokens ב־Claude?

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

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

העלות של סשן הקידוד שלך

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

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

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

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

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

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

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

פלט: מה שאתם רואים, וגם החשיבה שאינכם רואים

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

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

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

מטמון prompts הוא הסיבה שלולאת השליחה החוזרת אינה מרוששת את כולם. ה־API יכול לשמור במטמון prefix יציב של ה־prompt, של ה־system prompt, של הגדרות הכלים ושל היסטוריית השיחה, ובבקשה הבאה להגיש אותו במחיר של חלק קטן מהמחיר המקורי. נכון ל־July 2026, המכפילים הם: כתיבה למטמון עולה 1.25× מתעריף הקלט הבסיסי (2× עבור הווריאנט של שעה אחת), וקריאה מהמטמון עולה 0.1×. כתיבות הן בתעריף מוגדל; קריאות מזכות בהנחה של 90%. קריאה יחידה כבר מחזירה יותר מהעלות הנוספת של כתיבה לחמש דקות.

Claude Code מנהל את המטמון עבורך, ובסשן תקין כמעט כל השליחה החוזרת הגדולה מוגשת מהמטמון. עם זאת, המטמון המוגדר כברירת מחדל נשמר למשך חמש דקות מהשימוש האחרון. התרחקת להפסקת קפה שהתארכה, חזרת ושלחת הודעה — המטמון פג, וכל ה־prefix שנצבר נכתב מחדש בתעריף של 1.25× במקום להיקרא בתעריף של 0.1×. בסשן של 150K טוקנים, תור קר יחיד כזה עולה יותר מתריסר תורים חמים. זו התוצאה המנוגדת לאינטואיציה שכדאי להפנים: קצב עבודה של הפסקה ולאחריה המשך עלול לעלות יותר מעבודה רציפה, משום שכל פער חוסר פעילות שעובר את ה־TTL הופך את התור הבא מקריאה זולה לכתיבה מחדש ויקרה. עבדו במקטעים; אל תזינו סשן גדול בהדרגה, הודעה אחת בכל עשר דקות.

אם אתם קוראים ל־API מתוך היישום שלכם ב־VPS, אינכם מקבלים דבר מזה בחינם, והטעות העצמית הקלאסית היא שילוב של חותמת זמן או מזהה בקשה בתוך ה־system prompt. פעולה זו משנה את בתי ה־prefix בכל בקשה ומשביתה את המטמון בשקט. הסימן לכך הוא usage.cache_read_input_tokens שנשאר על אפס בקריאות שנראות זהות.

הנוסחה, עם דוגמה מחושבת

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

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, שמחירו נכון ל־July 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. כעת נבחן את אותו תור לאחר שתוקף המטמון פג: כתיבה מחדש של כל 80,000 הטוקנים במחיר של $6.25/M עולה $0.50 עוד לפני הפלט — בערך פי חמישה מהעלות של כל התור כשהמטמון חם, עבור אותה עבודה בדיוק. הפער הזה מציג את כל סיפור המטמון במספר אחד. אותן ארבע שורות הן גם הדרך היחידה להשוואה הוגנת בין ספקים, משום שמחירי המחירון מתעלמים לחלוטין מקריאות מהמטמון ומטוקני חשיבה; והרצת החישוב על שלוש משימות אמיתיות מראה היכן החשבון של Claude גבוה או נמוך מזה של OpenAI.

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

הצגת נתוני השימוש שלך

ב־Claude Code, הפקודה היא /usage. גם /cost עדיין פועלת, והיא כינוי. המקטע Session בחלק העליון מציג נתוני token והערכת עלות שמחושבת מקומית עבור הסשן הנוכחי. בתוכניות מינוי, אותו מסך מציג גם את סרגלי מגבלת התוכנית ופירוט שמייחס את השימוש האחרון ל־skills, ל־subagents, ל־plugins ולשרתי MCP נפרדים. בחשבונות API, דף השימוש ב־Claude Console הוא מקור האמת לחיוב. הנתון שמציג ה־CLI הוא הערכה. /context מציירת רשת צבעונית של התוכן שתופס מקום בחלון ההקשר, כולל system prompt, כלים, הגדרות MCP, קבצים והיסטוריה. זו הדרך המהירה ביותר לזהות 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 הוא רק השארית שאינה במטמון. גודל ה־prompt האמיתי הוא הסכום של כל שלושת שדות הקלט. סוכן שפעל במשך שעה ומציג input_tokens: 4000 אינו זול; 200,000 ה־tokens האחרים סופקו מהמטמון. כדי להעריך את הכמות לפני השליחה, השתמשו ב־endpoint לספירת tokens. אפשר לקרוא לו ללא עלות, הוא כפוף למגבלת rate limit נפרדת, והוא סופר באמצעות ה־tokenizer של המודל שתציינו. התייחסו לתוצאה כהערכה קרובה; החיוב משקף את הבקשה בפועל:

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

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

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

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

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

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

FAQ

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

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

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

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

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

משום שה־API הוא חסר־מצב: בכל סבב נשלחים מחדש כל השיחה, כל קובץ שנקרא, כל תוצאת כלי וכל חילופי הדברים הקודמים, והם מחויבים כקלט. לכן סבב 50 כולל את סבבים 1 עד 49. שמירת prompt במטמון מגישה את הקידומת החוזרת בכעשירית ממחיר הקלט הבסיסי, אך הקידומת עצמה ממשיכה לגדול. בנוסף, כל פרק זמן לא פעיל שחורג מ־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.