מעקב אחר הוצאות ב-Claude Code: השוואת כלים ושיטות
איך לבחור כלי מעקב להוצאות ב-Claude Code? נשווה בין ניתוח לוגים מקומי, לוחות בקרה של Anthropic ומערכות OpenTelemetry כדי להבין מה כל כלי באמת מודד ואיפה הוא טועה.
מה באמת קורא כלי המעקב אחר הוצאות של Claude Code
כל כלי מעקב אחר הוצאות של Claude Code קורא את הנתונים מאחד משלושה מקורות, והמקור הוא שקובע אילו שאלות ניתן לשאול. מנתח לוגים (log parser) קורא את קובצי תמלול הסשן שנמצאים על הדיסק המקומי שלכם. לוח בקרה (dashboard) קורא את רשומות השימוש ש־Anthropic שומרת עבור החשבון או הארגון שלכם. מערכת ניטור (metrics backend) קוראת את זרם ה־OpenTelemetry (OTel) ש־Claude Code פולט כאשר הוא מופעל. שלושת המקורות יכולים להיות נכונים בו-זמנית ועדיין להציג נתונים שונים, כיוון שהם מודדים דברים שונים.
מדריך זה אינו מסביר מחדש מהם טוקנים. המאמר כיצד Claude Code מחשב שימוש בטוקנים מכסה קלט, פלט, כתיבה למטמון וקריאה מהמטמון, ושום לוח בקרה לא יהיה מובן עד שחלק זה לא יהיה ברור. השאלה כאן ממוקדת יותר: עבור כל סוג של כלי, מה הוא יכול לראות ומה הוא לעולם לא יוכל לראות.
מדוע הופיעו שלושה כלי מעקב אחר הוצאות עבור Claude Code באותו יום
שלושה כלי מעקב נפרדים אחר הוצאות ב-Claude Code פורסמו באותו יום. הם לא היו שלוש גרסאות של אותו כלי, וזהו החלק המועיל. אחד מהם ניתח את קובצי ה-session המקומיים. השני עטף את מסכי השימוש בחשבון. השלישי היה backend למעקב (tracing) שניתן להריץ באופן עצמאי.
הם הופיעו יחד מכיוון שהעלות של session של סוכן (agent) הפסיקה להיות ברורה מאליה. עלות של צ'אט היא בערך מה שניתן לראות על המסך. סוכן קורא עשרים קבצים, מריץ את חבילת הבדיקות (test suite) ושולח מחדש את כל השיחה בכל שלב, כך שהחשבון מושפע מהקשר (context) שמעולם לא הקלדת. במנוי, נתון הדולרים של ה-session ש-Claude Code מציג הוא הערכה ש-Anthropic מציינת שאינה רלוונטית לחיוב, והמספר שקובע הוא מדד שימוש שמתמלא מהר יותר בימים מסוימים מאשר באחרים. כל אחד משלושת הכלים הללו ממלא חלק אחר בפער הזה.
צורה 1: מנתח לוגים מקומי שמציג את העלות היומית
Claude Code שומר כל שיחה כקובץ JSON Lines ב-~/.claude/projects/<project>/<session-id>.jsonl, כאשר <project> הוא הנתיב לספריית העבודה שלך, שבו תווים שאינם אלפא-נומריים הוחלפו ב--. כל תגובה של העוזר בקובץ זה כוללת את ספירת הטוקנים עבור הבקשה שלו. מנתח לוגים מסכם אותם ומחשב את העלות.
ccusage הוא הכלי שרוב המשתמשים בוחרים בו. הוא אינו דורש התקנה:
npx ccusage@latest daily
npx ccusage@latest daily --breakdown
npx ccusage@latest blocks
npx ccusage@latest session --jsondaily מסכם לפי תאריך. --breakdown מפצל כל שורה לפי מודל, וכך תגלו שצהריים אחד עם Opus מהווים את רוב עלות השבוע. blocks מקבץ לפי חלון של חמש שעות שבו המנוי מתאפס. session מסכם לפי שיחה, ו-daily --instances מקבץ לפי פרויקט, כך שניתן לראות איזה מאגר קוד הוא יקר. הוסיפו את --since ו---until כדי להגביל את הטווח, והריצו את npx ccusage@latest daily --help עבור פורמט התאריך שהגרסה שלכם מצפה לו. נכון לאוקטובר 2026, הכלי קורא גם ממשקי CLI של סוכנים אחרים, כולל Codex ו-OpenCode, מה שחשוב אם אתם משווים ביניהם. דוחות ברירת המחדל משלבים את כל המקורות שזוהו; הוסיפו את claude לפני daily או session כדי להתמקד ב-Claude Code.
התמחור נגזר מטבלת מחירי מודלים, ולכלי יש שלושה מצבי עלות. --mode auto משתמש בערך costUSD ש-Claude Code כתב לקובץ כשהוא קיים, ומחשב לפי ספירת טוקנים כשאינו קיים. --mode calculate מחשב תמיד לפי טוקנים ומתעלם מכל עלות מתועדת. --mode display מציג רק עלויות מתועדות ומדפיס $0.00 עבור שורות שאין להן עלות. אם סיכום נראה שגוי, הריצו את אותו דוח תחת calculate ולאחר מכן תחת display. פער גדול ביניהם אומר שרוב הרשומות אינן נושאות עלות מתועדת, ולכן כל מה שאתם קוראים הוא הערכה בלבד. אם אתם משלמים לפי תעריפים חוזיים, pricingOverrides תחת defaults בקובץ תצורה ccusage.json יחליף את המחיר עבור מודלים בודדים.
ניתן להזין את אותם נתונים ל-prompt שלכם. ccusage statusline מדפיס שורה תמציתית עבור שורת הסטטוס של Claude Code, המחוברת ל-~/.claude/settings.json כמו כל פקודת שורת סטטוס אחרת. ראו בניית שורת סטטוס ל-Claude Code עבור בלוק ההגדרות והשדות שהוא מקבל.
מה שמנתח לוגים אינו יכול לראות הוא כל מה שלא קרה במכונה הזו. מחשב נייד שני, סשן ב-claude.ai, עבודה של חבר לצוות: התעתיקים האלה חיים על הדיסקים ההם. סשנים ישנים בטרמינל נמחקים כברירת מחדל לאחר 30 ימים של חוסר פעילות תחת cleanupPeriodDays, אך תקופת השמירה ניתנת להגדרה: השתמשו בערך גדול כמו 3650 כדי לשמור שנים של היסטוריה. תעתיקים של סשנים שהחלו או נמשכו לאחרונה ב-Desktop או ב-Cowork נשמרים מעבר לתקופה זו כברירת מחדל, עם חריגים כגון תצורות HIPAA.
קיים סיכון נוסף, והוא מבני. התיעוד של Anthropic מציין שפורמט הרשומות הוא פנימי ל-Claude Code ומשתנה בין גרסאות, לכן סקריפטים שמנתחים קבצים אלו ישירות עלולים להישבר בכל שחרור גרסה. זה תקף לכל כלי מסוג זה. זו גם הסיבה ש-one-liner מסוג jq שנכתב ידנית על ה-JSONL הוא רעיון גרוע ממה שהוא נראה: המנתחים המתוחזקים עוקבים אחר שינויי הפורמט עבורכם, וה-one-liner שלכם ידווח על מספר שגוי בביטחון מלא ביום שבו שדה כלשהו ישנה את שמו.
לבסוף, נתון הדולרים דורש הסתייגות לגבי מנוי. שימוש בתוך מגבלת תוכנית ה-Pro או ה-Max שלכם אינו מחויב לפי טוקן, לכן המספר מייצג את מה שהטוקנים שלכם היו עולים לפי תעריפי ה-API הרשמיים. הוא מודד עד כמה השימוש שלכם אינטנסיבי. זה אינו החשבון שלכם. החריג הוא קרדיטים לשימוש: אם תפעילו אותם, שימוש מעבר למגבלת התוכנית יחויב לפי תעריפי API סטנדרטיים כחיוב נפרד, ו-claude.ai יציג את ההוצאה של אותו חודש תחת Settings > Usage. אם השאלה האמיתית היא באיזו תוכנית לבחור, השוואה זו היא תרגיל בפני עצמו: ראו חיוב API מול מנוי Claude.
צורה 2: מסכי השימוש המובנים מציגים איזה מודל צרך את התקציב
Claude Code כולל כלי דיווח מובנים שרוב המשתמשים אינם פותחים. הריצו את /usage בתוך סשן. בלוק ה-Session בראש המסך מציג את כמות הטוקנים לפי מודל ואת העלות בדולרים עבור הסשן הנוכחי, המחושבת מקומית לפי תעריפי המחירון הסטנדרטיים, אלא אם מנהל המערכת הגדיר טבלת modelPricing בהגדרות המנוהלות; במקרה כזה, השורה Total cost תציג at your organization's configured rates. בכל מקרה, הסכום הוא הערכה בלבד ועשוי להיות שונה מהחשבונית הסופית. בתוכניות Pro או Max, חברת Anthropic מציינת כי נתון זה אינו רלוונטי לחיוב, שכן השימוש כלול בתוכנית. הסכומים מתאפסים כאשר /clear מתחיל שיחה חדשה.
בתוכניות Pro, Max, Team או Enterprise מבוססות מושבים (seats), אותו מסך מציג כמה ממכסת התוכנית נוצל. בתוכניות Enterprise מבוססות שימוש (usage-based) אין מכסה שניתן לחרוג ממנה, שכן כל טוקן מחויב לפי תעריפי ה-API. בתוכניות אלו, המסך משייך את השימוש האחרון ל-skills, סוכני משנה (subagents), תוספים ושרתי MCP בודדים כאחוז מהסך הכל. המערכת מסמנת התנהגויות האחראיות ל-10% או יותר מהשימוש האחרון, כגון הקשר (context) ארוך או החטאות מטמון (cache misses). לחצו על d או w כדי לעבור בין תצוגת 24 השעות האחרונות ל-7 הימים האחרונים. נתונים אלו הם מקורבים ומחושבים מתוך היסטוריית הסשנים המקומית במכשיר זה, ולכן שימוש במכשיר שני אינו נספר. כאשר המכסה מנוצלת, Claude Code מציין את המגבלה ומציג את זמן האיפוס שלה; סרגל צריכה ריק אינו מעיד על כך שהמכסה נוצלה. ניתן להמתין ולהמשיך את הסשן לאחר האיפוס, וההחלטה מה לעשות לאחר הגעה למגבלה היא החלטה נפרדת הנוגעת למודל, להקשר ולתוכנית.
מעבר לרמת המפתח הבודד, הנתונים עוברים לרמת החשבון. ארגון API מקבל גישה לדף ה-Console Cost, לוח מחוונים של Claude Code עם נתוני הוצאות ושורות קוד שאושרו לכל חבר צוות, ו-API לניתוח נתונים (Claude Code Analytics API) המחזיר את אותם מדדים יומיים לכל משתמש באמצעות מפתח מנהל. תוכניות Team ו-Enterprise מקבלות דוח הוצאות בקונסולת הניהול עם אפשרות לייצוא ל-CSV, המתעדכן מדי יום; הדוח מכסה הוצאות מתוך יתרת קרדיט בתוכניות מבוססות מושבים, ושימוש מלא בתוכניות Enterprise מבוססות שימוש. תוכנית Enterprise מוסיפה API לניתוח נתונים. הנתונים שיוצגו לכם תלויים בדרך שבה כל מפתח התחבר, כך שארגון מעורב יצטרך לקרוא שני דוחות ולחבר את הנתונים ידנית.
לצורך הערכת תקציב, הנתון שפורסם בתיעוד העלויות של Anthropic נכון לאוקטובר 2026 הוא ממוצע של כ-13 דולר למפתח ליום פעיל, ו-150 עד 250 דולר למפתח לחודש, כאשר 90% מהמשתמשים נמצאים מתחת ל-30 דולר ליום פעיל. התייחסו לנתון זה כאל מדד (benchmark) שפורסם מתוך פריסות ארגוניות, ולא כתחזית עבור הצוות שלכם. הריצו קבוצת פיילוט ומדדו את התוצאות לפני שתבצעו אקסטרפולציה.
לוחות המחוונים אינם יכולים לראות נתונים ברמה נמוכה יותר מיום או מאדם. הם יציינו ש-Opus צרך את רוב המשאבים ביום שלישי, אך לא יציינו איזה prompt, איזה מאגר (repository) או איזו משימת CI גרמו לכך. הנתונים גם סובלים מהשהיה, שכן דוחות הארגון מתעדכנים מדי יום, ולכן הם כלי לסקירה ולא דרך לעצור סוכן ש"יצא משליטה" באותו רגע. עצירת סוכן כזה דורשת מגבלות, לא דוחות, וזהו הנושא של שמירה על עלויות סוכנים בתוך גבולות ב-VPS.
תבנית 3: מערך OpenTelemetry עצמאי לזיהוי רגרסיה ב-prompts
Claude Code מפיק מדדים ואירועי OpenTelemetry ברגע שמפעילים טלמטריה ומגדירים exporters. זו האפשרות היחידה להזרמת נתוני אסימונים (tokens) ועלויות לפי משתמש למערכת שבשליטתכם בזמן אמת כמעט. המדדים כוללים claude_code.cost.usage בדולר ארה"ב, claude_code.token.usage באסימונים, claude_code.session.count ו-claude_code.active_time.total.
מדד האסימונים הוא המעניין ביותר בשל המאפיינים שלו. כל נקודת נתונים נושאת type, שהם input, output, cacheRead או cacheCreation, בתוספת model ו-query_source, שהם main, subagent או auxiliary. הוא נושא גם agent.name, skill.name, mcp_server.name ו-mcp_tool.name. שמות של שרתי MCP שהגדרתם בעצמכם ושמות של סוכני-משנה (subagents) מותאמים אישית מופיעים כ-custom, אלא אם הגדרתם OTEL_LOG_TOOL_DETAILS=1, שמוסיף גם פקודות Bash וקלט של כלים לאירועי הכלים. זה מספיק כדי לענות על שאלות שאף לוח בקרה לא יכול להגיע אליהן: איזה חלק מהחשבון נובע מסוכני-משנה לעומת הפעולות שלכם, האם שרת MCP מסוים הכפיל את אסימוני הקלט שלכם, או האם קריאות מהמטמון צנחו לאחר שמישהו ערך את CLAUDE.md. התנהגות המטמון היא בדרך כלל המקום שבו מסתתרת ההפתעה, והמאמר מתי שימוש ב-prompt caching משתלם מסביר מה עליכם לחפש.
תיקון אחד שראוי לציין, כיוון שהוא עולה בכל דיון בנושא זה: Langfuse הוא backend טוב לניטור (tracing) באירוח עצמי, והרצתו על גבי VPS מוסברת ב-אירוח עצמי של Langfuse לניטור סוכנים. נקודת הקצה מסוג OTLP שלו מקבלת traces בלבד. כברירת מחדל, Claude Code מייצא מדדים ואירועי לוג, לא spans, לכן הפניית OTEL_EXPORTER_OTLP_ENDPOINT אל Langfuse תשאיר את הפרויקט ריק ולא תציג שגיאה משמעותית. ייצוא spans אכן קיים, אך הוא נמצא בגרסת בטא שמושבתת עד שתגדירו CLAUDE_CODE_ENHANCED_TELEMETRY_BETA=1 ו-OTEL_TRACES_EXPORTER. האינטגרציה של Langfuse עם Claude Code פועלת בדרך אחרת: Stop hook, או תוסף שמתקין אחד כזה, קורא את תמלולי הסשן לאחר כל תגובה וממיר אותם ל-traces, כך שהוא חולק את המגבלות של מנתח לוגים מקומי בלבד. Langfuse הוא הכלי הנכון עבור סוכנים שאתם בונים בעצמכם על גבי ה-API, שבהם הקוד שלכם יוצר כל span עם ה-prompt, המודל והעלות שלו. עבור סיכומי הוצאות מתוך ה-CLI של Claude Code, מאגר מדדים (metrics store) הוא הפתרון המתאים.
הגדרת מעקב הוצאות עבור Claude Code בשרת VPS עצמאי
מספיקים שני שירותים: אספן (collector) לקבלת המדדים, ו-Prometheus לאחסונם. שמרו את שניהם מחוץ לאינטרנט הציבורי, כיוון שפורט OTLP פתוח מקבל כתיבות מכל מי שמוצא אותו. כתבו את /opt/ccmetrics/compose.yaml:
services:
collector:
image: otel/opentelemetry-collector-contrib:latest
command: ["--config=/etc/otel/config.yaml"]
volumes:
- ./collector.yaml:/etc/otel/config.yaml:ro
ports:
- "10.8.0.1:4318:4318"
restart: unless-stopped
prometheus:
image: prom/prometheus:latest
volumes:
- ./prometheus.yml:/etc/prometheus/prometheus.yml:ro
- prom-data:/prometheus
ports:
- "127.0.0.1:9090:9090"
restart: unless-stopped
volumes:
prom-data:10.8.0.1 הוא כתובת השרת בתוך מנהרת WireGuard, כך שהאספן נגיש מהמכונות שלכם בלבד ולא משום מקום אחר. הכתובת שלפני הפורט מבצעת כאן עבודה ממשית, כיוון שפורטים של Docker שפורסמו אינם מסוננים על ידי ufw: ראו מדוע פורטים של Docker שפורסמו עוקפים את ufw. הגדרת המנהרה עצמה מוסברת ב-הקמת VPN מסוג WireGuard בשרת VPS עצמאי.
/opt/ccmetrics/collector.yaml:
receivers:
otlp:
protocols:
http:
endpoint: 0.0.0.0:4318
processors:
batch:
exporters:
prometheus:
endpoint: 0.0.0.0:8889
service:
pipelines:
metrics:
receivers: [otlp]
processors: [batch]
exporters: [prometheus]/opt/ccmetrics/prometheus.yml. פורט 8889 לעולם אינו מפורסם למארח (host), כיוון ש-Prometheus מגיע לאספן דרך רשת ה-Compose לפי שם השירות:
global:
scrape_interval: 30s
scrape_configs:
- job_name: claude-code
static_configs:
- targets: ["collector:8889"]cd /opt/ccmetrics
docker compose up -d
docker compose logs collectorלוג האספן אמור להסתיים ב-Everything is ready. Begin running and processing data.. לוג שנעצר בשגיאת תצורה מעיד על כך שקובץ ה-YAML לא עבר פענוח, והמכולה תבצע הפעלה מחדש בלולאה.
כעת כוונו את Claude Code אליו. בכל מכונה שמריצה את Claude Code, הוסיפו את זה ל-~/.claude/settings.json:
{
"env": {
"CLAUDE_CODE_ENABLE_TELEMETRY": "1",
"OTEL_METRICS_EXPORTER": "otlp",
"OTEL_LOGS_EXPORTER": "none",
"OTEL_EXPORTER_OTLP_PROTOCOL": "http/protobuf",
"OTEL_EXPORTER_OTLP_ENDPOINT": "http://10.8.0.1:4318",
"OTEL_METRIC_EXPORT_INTERVAL": "10000"
}
}התחילו סשן, שלחו הנחיה (prompt) אחת, המתינו למרווח הייצוא (10 שניות כאן, 60 שניות כברירת מחדל), ואז שאלו את Prometheus מה הוא למד:
curl -s http://localhost:9090/api/v1/label/__name__/values | grep -o 'claude_code[a-z_]*'אתם אמורים לקבל כמה שמות שמתחילים ב-claude_code_. האקספורטר מחליף נקודות בקו תחתון ומוסיף את היחידה, לכן המחרוזות המדויקות תלויות בגרסת האספן שלכם. תוצאה ריקה משמעותה שלא הגיע דבר. בדקו שהפרוטוקול והפורט תואמים, כיוון ש-http/protobuf פונה ל-4318 ו-grpc פונה ל-4317, ואי-התאמה גורמת לכשל שקט. הריצו את claude --debug-file /tmp/claude-debug.log וחפשו בקובץ שורות [3P telemetry], שם Claude Code מדווח על שגיאות ייצוא של OTel.
עבור מכונה אחת ללא שרת, דלגו על כל האמור לעיל. הגדירו את CLAUDE_CODE_ENABLE_TELEMETRY=1 ו-OTEL_METRICS_EXPORTER=prometheus ו-Claude Code יחשוף נקודת קצה (scrape endpoint) ב-http://localhost:9464/metrics בעצמו. כאשר prometheus הוא האקספורטר היחיד שמוגדר, Claude Code משמיט את היחידות USD, tokens ו-s מהמדדים המיוצאים כדי שה-scrape יישאר בפורמט טקסט תקין של Prometheus. שמות המדדים אינם משתנים, והגדרה שמשלבת אקספורטרים, כגון otlp,prometheus, שומרת על היחידות.
החלטת פרטיות אחת מגיעה עם מבנה זה. כברירת מחדל, רק מונים ומטא-דאטה עוזבים את המכונה, ללא טקסט ההנחיה וללא פלט של כלים. OTEL_LOG_USER_PROMPTS=1 מוסיף טקסט הנחיה לאירועים מיוצאים וגם מאפשר ייצוא של טקסט תגובת העוזר, אלא אם OTEL_LOG_ASSISTANT_RESPONSES=0 דורס זאת. OTEL_LOG_TOOL_CONTENT=1 מוסיף פלט של כלים נבחרים ל-trace spans, עם החרגות וקיטום במגבלת התוכן (60 KB כברירת מחדל). דגלים אלו עלולים לחשוף קוד מקור וסודות בתוכן שהם בוחרים; הם אינם מייצאים אוטומטית את כל ההקשר. גופי שיחה מלאים דורשים את ההגדרה הנפרדת OTEL_LOG_RAW_API_BODIES. הפעילו אותם במכוון, וקראו תחילה את שמירה על סודות מחוץ להקשר של סוכן.
מעקב אחר הוצאות עבור הרצות סקריפטים ו־CI
הרצות לא אינטראקטיביות הן אלו שמפתיעות משתמשים, כיוון שאף אחד לא צופה במסך. claude -p עם --output-format json מדווח על עלות ההרצה בתוך ה־payload של התוצאה:
claude -p "summarise the failing tests" --output-format json | jq '.total_cost_usd'ה־payload נושא את total_cost_usd בתוספת פירוט לפי מודל, כך שעבודת CI יכולה לתעד את ההוצאה של עצמה ללא צורך בלוח בקרה. כמו כל נתון מקומי, מדובר בהערכה בצד הלקוח, והרצה שממשיכה שיחה עם --continue או --resume מדווחת על הסכום הכולל של השיחה כולה, כולל הרצות קודמות. ניתן לצרף את הערך לקובץ, או לדחוף אותו כמדד (metric) לאוסף הנתונים שצוין לעיל. זהו מעקב ההוצאות השימושי והזול ביותר שקיים, והוא עולה קריאת jq אחת לכל הרצה.
מצבי כשל ומה תראו
הדוח ריק. npx ccusage@latest daily הדפסה ללא שורות משמעותה שהכלי אינו קורא מהמיקום שבו Claude Code כותב. CLAUDE_CONFIG_DIR משנה את המיקום הזה, וגם ccusage קורא את המשתנה הזה, לכן הריצו את שניהם עם אותו ערך. אם סשנים ישנים חסרים, בדקו את cleanupPeriodDays: סשנים של טרמינל נמחקים כברירת מחדל לאחר 30 ימים של חוסר פעילות, בעוד תמלולי Desktop ו-Cowork נשמרים בדרך כלל מעבר לתקופה זו.
שני מחשבים מדווחים על סכומים שונים. זה צפוי ואינו באג. הפירוט ב-/usage וכל מנתח לוגים קוראים רק את היסטוריית הסשנים המקומית, לכן שימוש ממכשיר אחר או מ-claude.ai אינו מופיע באף אחד מהם.
הסכום המקומי אינו תואם לחשבונית. נתונים מקומיים מחושבים לפי ספירת טוקנים בתעריפי מחירון סטנדרטיים, אלא אם הגדרתם תעריפים חוזיים: טבלת modelPricing בהגדרות מנוהלות עבור /usage, או pricingOverrides עבור ccusage. במנוי, שימוש בתוך מגבלת התוכנית אינו מחויב לפי טוקן כלל, אלא רק יתרות שימוש. דף ה-Cost ב-Console הוא הקובע לחיוב ה-API.
העלות עלתה בזמן שביצעתם את אותה עבודה. בדקו את עמודות ה-cache לפני כל דבר אחר. סשן ארוך שולח מחדש את כל ההיסטוריה שלו בכל תור, במחיר של תעריף ה-cache כשהוא חם, ובמחיר קלט מלא ברגע שהוא מתקרר, לכן הפסקה ארוכה אחת גורמת לעיבוד מחדש של כל השיחה. זה מופיע כמספר קלט גדול לצד מספר פלט קטן, ו-תמחור טוקני קלט מול פלט מסביר מדוע השניים נעים באופן בלתי תלוי.
יום עם סוכני משנה נראה בלתי אפשרי. כל סוכן משנה מריץ חלון הקשר משלו, לכן השימוש בטוקנים גדל בהתאם לכמה סוכנים רצו וכמה זמן כל אחד מהם פעל. בתוכנית, שיוך ה-/usage מציג את חלקו של סוכן המשנה עבור מכונה זו באחוזים. לפירוט ברמת הבקשה, נתוני ה-OTel מפרידים ביניהם באמצעות מאפיין ה-query_source ב-claude_code.token.usage. מנתח לוגים יציג לכם את הסך הכל וישאיר אתכם לנחש.
FAQ
האם ccusage מציג את הסכום שאני מחויב בו בפועל בתוכנית Max?
לא. שימוש הנמצא בתוך מכסת התוכנית של המנוי אינו מחויב לפי טוקן, לכן מנתח לוגים מתמחר את הטוקנים שלכם לפי תעריפי ה-API הסטנדרטיים ומציג מה אותה עבודה הייתה עולה דרך ה-API. זהו מדד יחסי טוב לעומס של יום עבודה, והוא שימושי להשוואה בין פרויקטים או מודלים. לגבי הסכום לתשלום, דף ה-Cost ב-Console מכסה את חיוב ה-API ודף חיוב המנוי מכסה את דמי המנוי. אם הפעלתם זיכויי שימוש, שימוש מעבר למכסה מחויב לפי תעריפי ה-API הסטנדרטיים, ו-claude.ai מציג את ההוצאה הזו תחת Settings > Usage.
היכן Claude Code שומר את קובצי ה-session שכלים אלו קוראים?
ב-~/.claude/projects/<project>/<session-id>.jsonl, כאשר <project> הוא נתיב ספריית העבודה עם תווים שאינם אלפא-נומריים המוחלפים ב--. כל שורה היא אובייקט JSON עבור הודעה אחת, שימוש בכלי או רשומת מטא-דאטה. CLAUDE_CONFIG_DIR מעביר את כל הספרייה, ו-cleanupPeriodDays ב-settings.json שולט על שמירת הנתונים, שברירת המחדל שלה היא 30 ימי חוסר פעילות עבור סשנים בטרמינל; תמלולי Desktop ו-Cowork נשמרים בדרך כלל מעבר לתקופה זו. Anthropic מגדירה את פורמט הרשומות כפנימי וככזה שעשוי להשתנות בין גרסאות, לכן יש לנתח אותו בעזרת כלי מתוחזק ולא בעזרת סקריפט עצמאי.
האם ניתן לשלוח טלמטריה של Claude Code ל-Langfuse?
לא עם הטלמטריה המוגדרת כברירת מחדל. נקודת הקצה OTLP של Langfuse מקבלת עקבות (traces), וברירת המחדל של Claude Code היא ייצוא מדדים ואירועי לוג במקום spans, כך שאין ליעד נתונים זה מקום להיקלט. ייצוא spans הוא תכונת בטא שיש להפעיל, והאינטגרציה הייעודית של Langfuse ל-Claude Code משתמשת ב-hook מסוג Stop שממיר תמלולי סשן לעקבות במקום זאת. עבור סכומי הוצאות, שלחו מדדי Claude Code לאספן OpenTelemetry ושמרו אותם ב-Prometheus. השתמשו ב-Langfuse עבור סוכנים שאתם בונים בעצמכם על גבי ה-API, שבהם הקוד שלכם מפיק spans הנושאים את ה-prompt, המודל והעלות.
מדוע המספרים המקומיים שלי אינם תואמים לדף השימוש ב-Console?
מכיוון שהם מחושבים בצורה שונה. /usage ומנתחי לוגים מסכמים את ספירת הטוקנים מקובצי הסשן במכונה שבה אתם נמצאים, ואז מתמחרים אותם לפי תעריפי רשימה סטנדרטיים אלא אם הוגדרו תעריפים חוזיים, דרך modelPricing בהגדרות המנוהלות עבור /usage או pricingOverrides עבור ccusage. ה-Console מכסה את השימוש של הארגון שלכם בכל המכונות והמפתחות; השתמשו בדף ה-Cost שלו עבור עלויות API בפועל, שכן נתוני ההוצאות בלוח הבקרה של Claude Code הם הערכות בלבד. אי-התאמה היא מצב תקין. פער גדול מאוד מעיד בדרך כלל על מכונה נוספת, CI runner, או חבר צוות אחר שמחויב לאותו חשבון.
כיצד אוכל לעקוב אחר העלות של הרצת claude -p ב-CI?
הריצו זאת עם --output-format json וקראו את total_cost_usd מהתוצאה, למשל בעזרת claude -p "..." --output-format json | jq '.total_cost_usd'. אותו payload כולל פירוט לפי מודל ואת מזהה הסשן (session ID). תעדו ערך זה עבור כל עבודה וכך תקבלו את ההוצאה לפי pipeline ללא צורך בסוכן, לוח בקרה או שירות נוסף.