מעקב אחר הוצאות ב-Claude Code: השוואת כלים ושיטות

מה באמת קורא כלי המעקב אחר הוצאות של 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) שמעולם לא הקלדת. במנוי אין נתון דולרי כלל, אלא רק סרגל שימוש שמתרוקן בימים מסוימים מהר יותר מאשר באחרים. כל אחד משלושת הכלים ממלא חלק אחר בפער הזה.

צורה 1: מנתח לוגים מקומי שמציג את עלות השימוש היומית

Claude Code שומר כל שיחה כקובץ JSON Lines (JSONL) בנתיב ~/.claude/projects/<project>/<session-id>.jsonl, כאשר <project> הוא נתיב תיקיית העבודה שלכם, שבו תווים שאינם אלפא-נומריים הוחלפו ב--. כל תגובה של ה-assistant בקובץ זה כוללת את ספירת ה-tokens עבור הבקשה שלה. מנתח לוגים מסכם אותם ומחשב את העלות.

ccusage הוא הכלי הנפוץ ביותר. הוא אינו דורש התקנה:

npx ccusage@latest daily
npx ccusage@latest daily --breakdown
npx ccusage@latest blocks
npx ccusage@latest session --json

daily מסכם עלויות לפי תאריך. --breakdown מפצל כל שורה לפי מודל, וכך תגלו ששימוש ב-Opus אחר הצהריים אחד מהווה את רוב עלות השבוע. blocks מקבץ לפי חלון של חמש שעות, שבו מתבצע איפוס המנוי. session מסכם לפי שיחה, ו---instances מקבץ לפי פרויקט, כך שתוכלו לראות איזה repository הוא היקר ביותר. הוסיפו את --since ו---until כדי להגדיר טווח, והריצו את npx ccusage@latest daily --help עבור פורמט התאריך שהגרסה שלכם מצפה לו. נכון לאוגוסט 2026, הכלי קורא גם נתונים מ-CLIs של סוכנים אחרים, כולל Codex ו-OpenCode, מה שחשוב אם אתם מבצעים השוואה ביניהם.

התמחור נגזר מטבלת מחירי מודלים, ולכלי יש שלושה מצבי עלות. --mode auto משתמש בערך costUSD ש-Claude Code כתב לקובץ כשהוא קיים, ומבצע חישוב לפי ספירת tokens כשאינו קיים. --mode calculate תמיד מחשב לפי tokens ומתעלם מכל עלות מתועדת. --mode display מציג רק עלויות מתועדות ומדפיס $0.00 עבור שורות שאין להן עלות. אם סיכום נראה שגוי, הריצו את אותו דוח תחת calculate ולאחר מכן תחת display. פער גדול ביניהם מעיד על כך שרוב הרשומות אינן מכילות עלות מתועדת, ולכן כל מה שאתם קוראים הוא הערכה בלבד.

ניתן להזין את אותם נתונים ל-prompt שלכם. ccusage statusline מדפיס שורה תמציתית עבור שורת הסטטוס של Claude Code, המחוברת ל-~/.claude/settings.json כמו כל פקודת שורת סטטוס אחרת. ראו בניית שורת סטטוס ל-Claude Code עבור בלוק ההגדרות והשדות שהוא מקבל.

מה שמנתח לוגים אינו יכול לראות הוא כל מה שלא התרחש במכונה זו. מחשב נייד שני, סשן ב-claude.ai, או עבודה של חבר לצוות: תעתיקים אלו נשמרים על הדיסקים שלהם. נתונים ישנים חסרים גם הם, כיוון שתעתיקים נמחקים לאחר 30 יום כברירת מחדל תחת הגדרת cleanupPeriodDays, כך שהרבעון הקודם אבד אלא אם כן ארכבתם אותו.

קיים סיכון נוסף, והוא מבני. התיעוד של Anthropic מציין שפורמט הרשומות הוא פנימי ל-Claude Code ומשתנה בין גרסאות, לכן סקריפטים שמנתחים קבצים אלו ישירות עלולים להישבר בכל שחרור גרסה. זה תקף לכל כלי מסוג זה. זו גם הסיבה ש-one-liner מסוג jq שנכתב ידנית על גבי ה-JSONL הוא רעיון גרוע ממה שהוא נראה: המנתחים המתוחזקים עוקבים אחר שינויי הפורמט עבורכם, בעוד ה-one-liner שלכם ידווח על מספר שגוי בביטחון מלא ביום שבו שדה כלשהו ישנה את שמו.

לבסוף, נדרשת הסתייגות לגבי הערך הדולרי במנוי. אתם לא מחויבים לפי token בתוכניות Pro או Max, לכן המספר מייצג את מה שה-tokens שלכם היו עולים לפי מחירי ה-API הרשמיים. הוא מודד את עוצמת השימוש שלכם. זה אינו החשבון שלכם. אם השאלה האמיתית היא באיזו תוכנית כדאי להיות, השוואה זו היא תהליך נפרד: ראו חיוב API מול מנוי Claude.

צורה 2: מסכי השימוש המובנים מציגים איזה מודל צרך את התקציב

Claude Code כולל כלי דיווח מובנים, אך רוב המשתמשים אינם פותחים אותם. הריצו את /usage בתוך סשן. בלוק ה-Session בחלק העליון מציג את כמות ה-tokens לפי מודל ואת העלות בדולרים עבור הסשן הנוכחי, המחושבת מקומית לפי ספירת tokens ותעריפי מחירון סטנדרטיים. נתון זה אינו משקף הנחות או תמחור מבצעי, ולכן הוא עשוי להיות שונה מהחשבונית שלכם. הסיכומים מתאפסים כאשר /clear מתחיל שיחה חדשה.

בתוכניות Pro, Max, Team או Enterprise, אותו מסך מציג כמה ממכסת התוכנית שלכם נוצל, ומייחס את השימוש האחרון ל-skills, ל-subagents, ל-plugins ולשרתי MCP בודדים כאחוז מהסך הכולל. המערכת מסמנת התנהגויות האחראיות ל-10% או יותר מהשימוש האחרון, כגון הקשר (context) ארוך או cache misses. לחצו על d או w כדי לעבור בין תצוגת 24 השעות האחרונות לבין 7 הימים האחרונים. נתונים אלו הם הערכות המחושבות מהיסטוריית הסשנים המקומית במכונה זו, ולכן מכשיר שני אינו נספר. כאשר סרגל זה ריק ולא רק נמוך, המסך מציין שהחלון נסגר אך לא כיצד להמשיך לעבוד, ו-מה לעשות לאחר הגעה למכסה היא החלטה נפרדת הנוגעת למודל, להקשר ולתוכנית.

מעבר למפתח בודד, הנתונים עוברים לרמת החשבון. ארגון API מקבל גישה לדף השימוש ב-Console, לוח מחוונים של Claude Code עם נתוני הוצאות ושורות קוד מאושרות לכל חבר צוות, ו-Claude Code Analytics API שמחזיר את אותם מדדים יומיים לכל משתמש באמצעות מפתח ניהול (admin key). תוכניות Team ו-Enterprise מקבלות דוח הוצאות ב-admin console עם אפשרות לייצוא ל-CSV, המתעדכן מדי יום, וגרסת ה-Enterprise מוסיפה API לניתוח נתונים. מה שאתם רואים תלוי בדרך שבה כל מפתח התחבר, כך שארגון מעורב קורא שני דוחות ומחבר אותם ידנית.

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

מה שלוחות המחוונים אינם יכולים לראות הוא כל מה שמתחת לרמת היום והאדם. הם יגידו לכם ש-Opus היה אחראי לרוב השימוש ביום שלישי. הם לא יגידו לכם איזה prompt, איזה repository או איזה job ב-CI גרמו לכך. הם גם סובלים מפיגור, כיוון שדוחות הארגון מתעדכנים מדי יום, כך שהם כלי לסקירה ולא דרך לעצור סוכן שיצא משליטה באותו אחר צהריים. עצירת סוכן כזה דורשת הגבלות, לא דוחות, וזהו הנושא של שמירה על עלויות סוכנים בגבולות מוגדרים ב-VPS.

צורה 3: מחסנית OpenTelemetry עצמאית מאפשרת לזהות אילו הנחיות (prompts) גרמו לנסיגה בביצועים

Claude Code מפיק מדדים ואירועי OpenTelemetry ברגע שמגדירים משתנה סביבה אחד. זו האפשרות היחידה להזרים נתוני טוקנים ועלויות לפי משתמש למערכת שבשליטתכם, בזמן אמת כמעט. המדדים כוללים את 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. זה מספיק כדי לענות על שאלות שאף לוח בקרה (dashboard) לא יכול להגיע אליהן: איזה חלק מהחשבון נובע מסוכני משנה (subagents) לעומת הפעולות שלכם, האם שרת MCP מסוים הכפיל את טוקני הקלט שלכם, או האם קריאות מהמטמון (cache) צנחו לאחר שמישהו ערך את הקובץ CLAUDE.md. התנהגות המטמון היא בדרך כלל המקום שבו מסתתרות הפתעות, והמאמר מתי שימוש ב-prompt caching משתלם מסביר מה עליכם לחפש.

תיקון אחד שחשוב לבצע, כיוון שהוא עולה בכל דיון בנושא: Langfuse הוא backend טוב למעקב (tracing) באירוח עצמי, והרצתו על גבי VPS מוסברת ב-אירוח עצמי של Langfuse למעקב אחר סוכנים. נקודת הקצה (endpoint) מסוג OTLP שלו מקבלת עקבות (traces) בלבד. Claude Code מייצא מדדים ואירועי לוג, לא spans, לכן הפניית OTEL_EXPORTER_OTLP_ENDPOINT אל Langfuse תשאיר את הפרויקט ריק ולא תציג שגיאה בעלת משמעות. 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 ולוג הניפוי (debug log) ידווח על שגיאות ייצוא של OTel.

עבור מכונה אחת ללא שרת, דלגו על כל האמור לעיל. הגדירו את OTEL_METRICS_EXPORTER=prometheus ו־Claude Code יחשוף נקודת קצה (scrape endpoint) ב־http://localhost:9464/metrics בעצמו. כאשר prometheus הוא האקספורטר היחיד ברשימה, Claude Code משמיט את היחידות USD, tokens ו־s משמות המדדים כדי שה־scrape יישאר בפורמט טקסט תקין של Prometheus.

החלטת פרטיות אחת מגיעה עם מבנה זה. כברירת מחדל, רק מונים עוזבים את המכונה, ללא טקסט של הנחיות וללא פלט של כלים. OTEL_LOG_USER_PROMPTS=1 ו־OTEL_LOG_TOOL_CONTENT=1 משנים זאת, ואז שרת המדדים שלכם יחזיק קוד מקור וכל דבר אחר שהיה בהקשר (context). הפעילו אותם במכוון, וקראו תחילה את שמירה על סודות מחוץ להקשר של סוכן.

מעקב אחר הוצאות עבור הרצות סקריפטים ו־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 יכולה לתעד את ההוצאה של עצמה ללא צורך בלוח בקרה. צרפו את הערך לקובץ, או דחפו אותו כמדד (metric) לאוסף הנתונים שצוין לעיל. זהו המעקב היעיל והזול ביותר אחר הוצאות, והוא עולה קריאת jq אחת לכל הרצה.

מצבי כשל ומה תראו

הדוח ריק. npx ccusage@latest daily הדפסה ללא שורות משמעה שהכלי אינו קורא מהמיקום שבו Claude Code כותב. CLAUDE_CONFIG_DIR משנה את המיקום הזה, ויש להגדיר זאת ל־parser. אם קיימות שורות אך הן נעצרות לפני כחודש, זהו cleanupPeriodDays הפועל כמתוכנן: תמלילים מוסרים כברירת מחדל לאחר 30 יום.

שני מחשבים מדווחים על סכומים שונים. זהו מצב צפוי ואינו באג. גם /usage וגם כל parser של לוגים קוראים את היסטוריית הסשנים המקומית בלבד, לכן שימוש ממכשיר אחר או מ־claude.ai אינו מופיע באף אחד מהם.

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

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

יום עם סוכני משנה נראה בלתי אפשרי. כל סוכן משנה מריץ חלון הקשר (context window) משלו, לכן השימוש בטוקנים גדל בהתאם למספר הסוכנים שרצו ולמשך הזמן של כל אחד מהם. רק נתוני ה־OTel מפרידים ביניהם, באמצעות המאפיין query_source על גבי claude_code.token.usage. ה־parser של הלוגים יציג לכם את הסך הכולל וישאיר אתכם לנחש.

FAQ

האם ccusage מציג את החיוב בפועל בתוכנית Max?

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

היכן Claude Code שומר את קובצי הסשן שהכלים הללו קוראים?

ב-~/.claude/projects/<project>/<session-id>.jsonl, כאשר <project> הוא נתיב תיקיית העבודה שבו תווים שאינם אלפא-נומריים הוחלפו ב--. כל שורה היא אובייקט JSON המייצג הודעה, שימוש בכלי או רשומת מטא-דאטה. CLAUDE_CONFIG_DIR מעביר את כל התיקייה, ו-cleanupPeriodDays בתוך settings.json שולט על שמירת הנתונים למשך 30 יום. Anthropic מגדירה את פורמט הרשומות כפנימי וככזה שעשוי להשתנות בין גרסאות, לכן מומלץ לנתח אותו באמצעות כלי מתוחזק ולא באמצעות סקריפט עצמאי.

האם ניתן לשלוח טלמטריה של Claude Code ל-Langfuse?

לא ישירות. נקודת הקצה OTLP של Langfuse מקבלת traces, בעוד ש-Claude Code מייצא מדדים (metrics) ואירועי לוג במקום spans, כך שאין לנתונים יעד מתאים. שלחו את המדדים של Claude Code ל-OpenTelemetry collector ושמרו אותם ב-Prometheus. השתמשו ב-Langfuse עבור סוכנים שאתם בונים בעצמכם על גבי ה-API, שם הקוד שלכם מפיק spans הכוללים את ה-prompt, המודל והעלות.

מדוע המספרים המקומיים שלי אינם תואמים לדף השימוש ב-Console?

מכיוון שהם מחושבים בדרכים שונות. /usage ומנתחי לוגים מסכמים את ספירת הטוקנים מקובצי הסשן במכונה שבה אתם עובדים, ואז מתמחרים אותם לפי תעריפי המחירון הרשמיים. ה-Console מדווח על מה שהארגון שלכם חויב בו בפועל, בכל המכונות ועם כל מפתח, לאחר הנחות. אי-התאמה היא תקינה. פער גדול מאוד מעיד בדרך כלל על מכשיר נוסף, CI runner, או חבר צוות אחר שמחייב את אותו חשבון.

כיצד ניתן לעקוב אחר העלות של הרצת claude -p ב-CI?

הריצו זאת עם --output-format json וקראו את total_cost_usd מהתוצאה, למשל באמצעות claude -p "..." --output-format json | jq '.total_cost_usd'. אותו payload כולל פירוט לפי מודל ואת מזהה הסשן (session ID). תעדו את הערך הזה עבור כל עבודה, וכך תקבלו את ההוצאה לפי pipeline ללא צורך בסוכן, לוח בקרה או שירות נוסף.