כמה עולה מיליון טוקנים ב־Claude? חישוב עלות

כמה עולים 1M tokens ב־Claude?

1M tokens הם מיליון tokens, וזוהי היחידה שלפיה נקוב המחיר בכל API של Claude (ממשק תכנות יישומים). אין מחיר יחיד ליחידה זו, משום ש־input ו־output מחויבים בתעריפים שונים, ולכל model יש צמד תעריפים משלו. נכון ל־August 2026, מיליון input tokens עולים $1 ב־Claude Haiku 4.5, $2 ב־Claude Sonnet 5 ו־$5 ב־Claude Opus 5.

ה־output הוא החלק היקר יותר. בכל model נוכחי, תעריף ה־output גבוה פי 5 מתעריף ה־input, ולכן היחס בין השניים משפיע על החשבון יותר מהמחיר הראשי. יישום ששולח מסמכים ארוכים ומחזיר תשובות קצרות מתנהג מבחינת עלויות באופן שונה מאוד מיישום שמפיק תשובות ארוכות מתוך prompt קצר.

העמוד הזה עוסק בכלכלת יחידות: כמה עולה token, וכיצד להעריך את החשבון לפני שבונים את היישום. כדי להבין לאן ה־tokens עוברים בפועל במהלך העבודה, קראו לאן עוברים ה־tokens בתוך סשן של Claude Code.

איך נראים 1M טוקנים

טוקן הוא קטע טקסט שהמודל קורא או כותב. ההערכה הכללית של Anthropic היא טוקן אחד לכל 4 תווים, או כ־0.75 מילים באנגלית. לכן מיליון טוקנים הם בערך 750,000 מילים, או כ־4 MB של טקסט פשוט.

הערכות שפורסמו עבור קלטים נפוצים ממחישות טוב יותר את קנה המידה.

[
  {
    "label": "Average web page (10 kB)",
    "tokens": "2,500"
  },
  {
    "label": "Documentation page (100 kB)",
    "tokens": "25,000"
  },
  {
    "label": "Research paper PDF (500 kB)",
    "tokens": "125,000"
  }
]

בקצב הזה, 1M טוקנים הם בערך 400 דפי אינטרנט ממוצעים שנקראו פעם אחת, או שמונה מאמרי מחקר בהיקף כזה. מדובר במעבר יחיד על בסיס קוד בינוני, או בחודש של שימוש מתון בצ'אט עבור אדם אחד.

יש להתייחס לכל הנתונים האלה כהערכה. קוד, JSON וטקסט בשפות שאינן אנגלית מכילים פחות מילים בכל טוקן, ולכן היחס 0.75 הוא הקצה האופטימי. יש גורם נוסף שמשנה את הספירה: Claude Opus 4.7 ואילך, כולל Opus 5 ו־Sonnet 5, משתמשים ב־tokenizer חדש יותר שמפיק בערך 30 אחוז יותר טוקנים עבור אותו טקסט, בהשוואה ל־Sonnet 4.6 ולגרסאות קודמות. Claude Haiku 4.5 משתמש ב־tokenizer הישן. לכן ספירה שמדדתם ב־Haiku 4.5 נמוכה מהספירה שתתקבל ב־Sonnet 5 עבור קלט זהה, ולכן השוואה ישירה של מחיר למיליון טוקנים בין שתי קבוצות אלה אינה הוגנת. ספרו את אותו prompt מול שני המודלים לפני שתקבלו החלטה.

מה Claude גובה לכל מיליון טוקנים

[
  {
    "label": "Haiku 4.5",
    "input_usd": 1,
    "output_usd": 5
  },
  {
    "label": "Sonnet 5 (to 31 Aug 2026)",
    "input_usd": 2,
    "output_usd": 10
  },
  {
    "label": "Sonnet 5 (from 1 Sep 2026)",
    "input_usd": 3,
    "output_usd": 15
  },
  {
    "label": "Opus 5",
    "input_usd": 5,
    "output_usd": 25
  }
]

Claude Sonnet 5 מתומחר בתקופת השקה במחיר של $2 עבור טוקני קלט ושל $10 עבור טוקני פלט, עד 31 August 2026. החל מ־1 September 2026 יחול התעריף הרגיל: $3 עבור טוקני קלט ו־$15 עבור טוקני פלט. Claude Opus 5 מתומחר ב־$5 וב־$25.

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

אורך ההקשר אינו משנה את התעריף. ב־Claude 4.6 ובגרסאות מאוחרות יותר, חלון ההקשר המלא של 1M טוקנים מחויב לפי התמחור הרגיל. לכן בקשה של 900,000 טוקנים עולה אותו מחיר לטוקן כמו בקשה של 9,000 טוקנים. prompt ארוך עולה יותר משום שהוא מכיל יותר טוקנים, ולא חל תעריף נפרד להקשר ארוך.

החישוב שנשאר נכון לאחר שינוי מחיר

כל חשבון מורכב משתי פעולות כפל ומפעולת חיבור אחת.

cost = (input_tokens  / 1,000,000) * input_rate
     + (output_tokens / 1,000,000) * output_rate

כך נראה הקוד שאפשר להריץ:

INPUT_RATE = 2.00    # USD per million input tokens, Sonnet 5, August 2026
OUTPUT_RATE = 10.00  # USD per million output tokens

def cost(input_tokens, output_tokens):
    return (input_tokens * INPUT_RATE + output_tokens * OUTPUT_RATE) / 1_000_000

print(f"{cost(4300, 400):.4f}")

הקוד מדפיס 0.0126. בקשה ששולחת 4,300 טוקני קלט ומקבלת 400 טוקני פלט עולה כ־1.3 סנט ב־Sonnet 5. שמרו את שני התעריפים במקום אחד בקוד. כאשר המחיר משתנה, עורכים שתי שורות, וכל האומדנים במערכת מתעדכנים בהתאם.

דוגמה מלאה להערכת עלויות עבור יישום אמיתי

נבחן עוזר תמיכה. ה־system prompt והתיעוד של המוצר כוללים יחד 4,000 טוקנים, והם נשלחים בכל בקשה, משום ש־Messages API הוא stateless והמודל אינו זוכר דבר בין קריאות. שאלת משתמש מוסיפה כ־300 טוקנים. תשובה כוללת בדרך כלל כ־400 טוקנים. לכן, כל בקשה כוללת 4,300 טוקנים בקלט ו־400 טוקנים בפלט.

מיליון טוקנים בקלט מספיקים לכ־232 בקשות במבנה הזה. ב־1,000 בקשות ביום, היישום צורך 4.3 מיליון טוקנים בקלט מדי יום, ולכן "1M tokens" מספיקים לפחות משש שעות תעבורה.

[
  {
    "label": "Opus 5, list rates",
    "cost_per_1k_usd": "31.50"
  },
  {
    "label": "Sonnet 5, list rates",
    "cost_per_1k_usd": "12.60"
  },
  {
    "label": "Sonnet 5, Batch API",
    "cost_per_1k_usd": "6.30"
  },
  {
    "label": "Haiku 4.5, list rates",
    "cost_per_1k_usd": "6.30"
  },
  {
    "label": "Sonnet 5, warm prompt cache",
    "cost_per_1k_usd": "5.40"
  }
]

ב־Claude Opus 5, תעבורה זו עולה $31.50 לכל 1,000 בקשות. ב־Sonnet 5 העלות היא $12.60. מעבר ל־Claude Haiku 4.5 מוריד את העלות ל־$6.30, ושימוש ב־prompt cache חם ב־Sonnet 5 מוריד אותה עוד יותר, ל־$5.40.

הכפילו את הסכום ב־30 כדי לחשב חודש של תעבורה כזו. Sonnet 5, לפי מחירי המחירון, עולה כ־$378 בחודש. אותו יישום עם cache חם עולה כ־$162. בחירת המודל וההחלטה אם להשתמש ב־cache שוות כל אחת יותר מכל תעריף שתוכלו להשיג במשא ומתן בהיקף כזה. השאלה איזה מודל להפעיל עומדת בפני עצמה, והמודל הזול ביותר שעובר את הבדיקות שלכם הוא הבחירה המתאימה: בחירה בין Opus, Sonnet ו־Haiku מסביר כיצד לבדוק זאת כראוי.

אחסון במטמון של פרומפטים מקצץ את החלק החוזר

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

קריאת מטמון עולה 0.1 מתעריף הקלט הבסיסי. כתיבת המטמון עולה 1.25 מתעריף הבסיס למשך 5 דקות, או 2 מתעריף הבסיס למשך שעה. לכן מטמון של 5 דקות מחזיר את עלותו כבר לאחר קריאה אחת, משום שהכתיבה עולה 0.25 נוסף, וכל קריאה חוסכת 0.9. מטמון של שעה דורש שתי קריאות כדי להגיע לנקודת האיזון.

הדרך הפשוטה ביותר להפעיל זאת היא באמצעות שדה יחיד ברמה העליונה:

curl https://api.anthropic.com/v1/messages \
  -H "content-type: application/json" \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -d '{
    "model": "claude-opus-5",
    "max_tokens": 1024,
    "cache_control": {"type": "ephemeral"},
    "system": "You are a helpful assistant.",
    "messages": [
      {"role": "user", "content": "What are the key themes in Pride and Prejudice?"}
    ]
  }'

לאחר מכן קראו את בלוק usage שמוחזר:

{
  "usage": {
    "cache_creation_input_tokens": 5120,
    "cache_read_input_tokens": 1800,
    "input_tokens": 50,
    "output_tokens": 503
  }
}

שלושת מוני הקלט האלה מחויבים לפי שלושה תעריפים שונים, וביחד הם מסתכמים בנפח הקלט בפועל: total_input_tokens = cache_read_input_tokens + cache_creation_input_tokens + input_tokens. אומדן עלות שקורא רק את input_tokens יהיה שגוי מאוד לאחר הפעלת האחסון במטמון.

שני דברים מונעים מהמטמון להחזיר את עלותו, ושניהם נכשלים ללא הודעה.

הקידומת חייבת להיות זהה ברמת הבתים. חיפוש במטמון מתבצע לפי התאמת קידומת, ולכן חותמת זמן או שם המשתמש בראש ה־system prompt משנים אותה בכל בקשה. במקרה כזה אתם משלמים בכל פעם 1.25 מתעריף קלט הבסיס, ולעולם אינכם מבצעים קריאה מהמטמון. הסימן לכך הוא ש־cache_creation_input_tokens נשאר גבוה, בעוד ש־cache_read_input_tokens נשאר 0. הציבו את cache_control בבלוק האחרון שהתוכן שלו זהה בין הבקשות, והוסיפו אחריו את כל מה שמשתנה. שינוי ההגדרות של tools מבטל את כל המטמון שמתחתיהן, משום שהביטול מתבצע לפי הסדר: כלים, לאחר מכן system, ולאחר מכן messages.

הקידומת חייבת להיות ארוכה מספיק. האורך המינימלי שניתן לשמור במטמון הוא 512 טוקנים ב־Opus 5, ‏1,024 ב־Sonnet 5 ו־4,096 ב־Haiku 4.5. פרומפט קצר יותר אינו נשמר במטמון, ולא מוחזרת שגיאה. הקידומת באורך 4,000 טוקנים בדוגמה שלמעלה נשמרת במטמון ב־Sonnet 5, אך לא ב־Haiku 4.5, משום ש־4,000 נמוך מסף המינימום של מודל זה. כאשר שני המונים מציגים 0, שום דבר לא נשמר במטמון.

עיבוד באצווה חוצה את התעריף

ה־Batch API מעבד בקשות באופן אסינכרוני, בהנחה של 50 אחוז הן על קלט והן על פלט. בדוגמה שלעיל, הדבר הופך עלות של $12.60 לכל 1,000 בקשות ל־$6.30. ההנחה מצטברת עם prompt caching, ולכן עבודת batch שנשמרה במטמון היא הדרך הזולה ביותר להריץ עיבוד בכמות גדולה.

המחיר הוא זמן ההשהיה, ולכן batch אינו מתאים לכל פעולה שאדם ממתין לתוצאותיה. הוא מתאים לסיווג לילי ולהשלמת עיבוד של מסמכים.

מדוע עלות הצ'אט גדלה בתוך שיחה אחת

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

נניח שבכל תור נשלחים בממוצע 500 טוקנים. בתור 1 נשלחים 500 טוקני קלט. בתור 2 נשלחים 1,000. בתור 20 נשלחים 10,000. סכימה לפי n(n+1)/2 מראה ששיחה בת 20 תורים שלחה כ־105,000 טוקני קלט, אף שהתמליל עצמו באורך 10,000 טוקנים בלבד.

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

ספרו את ה־tokens לפני שאתם מנחשים

הפסיקו להסיק את מספר ה־tokens ממספר המילים. ה־API סופר אותם עבורכם ללא עלות, במסגרת rate limit נפרדת מיצירת הודעות.

curl https://api.anthropic.com/v1/messages/count_tokens \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "content-type: application/json" \
  -H "anthropic-version: 2023-06-01" \
  -d '{
    "model": "claude-opus-5",
    "system": "You are a scientist",
    "messages": [{
      "role": "user",
      "content": "Hello, Claude"
    }]
  }'

התגובה כוללת שדה אחד:

{ "input_tokens": 14 }

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

אי־אפשר לספור מראש את פלט ה־tokens, משום שהם עדיין אינם קיימים. הגבילו אותם באמצעות max_tokens, ולאחר מכן מדדו את ההתפלגות בפועל באמצעות usage.output_tokens בתעבורת production.

מה עוד נכלל בחשבון

רוב העלות נובעת מ־tokens. כמה רכיבים אינם tokens, והם מפתיעים משתמשים.

• הגדרות כלים הופכות ל־input tokens בכל בקשה. ה־system prompt של מערכת השימוש בכלים לבדו מוסיף בין 286 ל־406 tokens ב־Opus 5, עוד לפני ה־schemas שלכם. עשר הגדרות מפורטות של כלים עלולות להכפיל prompt קטן.
• חיפוש באינטרנט מחויב ב־$10 לכל 1,000 חיפושים, בנוסף ל־tokens שצורכים התוצאות כאשר הן נכנסות ל־context.
• שליפת תוכן מהאינטרנט אינה מוסיפה תשלום נפרד, אך הדף שנשלף הופך ל־input tokens. דף תיעוד בגודל 100 kB מכיל בערך 25,000 כאלה.
• בקשה ל־inference מארצות הברית בלבד באמצעות inference_geo ב־Claude 4.6 ואילך מחילה מכפיל של 1.1 על כל קטגוריית tokens, כולל קריאות וכתיבות של cache.

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

FAQ

כמה עולה 1M טוקנים ב-Claude?

העלות תלויה במודל ובשאלה אם הטוקנים הם טוקני קלט או פלט. נכון לאוגוסט 2026, מיליון טוקני קלט עולים $1 ב-Claude Haiku 4.5, $2 ב-Claude Sonnet 5 במסגרת תמחור ההשקה, ו-$5 ב-Claude Opus 5. עלות הפלט גבוהה פי 5 מעלות הקלט בכל אחד מהמודלים האלה. ב-1 September 2026 המחיר של Sonnet 5 יעבור ל-$3 עבור קלט ול-$15 עבור פלט. התעריפים עשויים להשתנות, לכן יש לאמת אותם בדף התמחור הרשמי לפני שמכניסים סכום לתקציב.

האם 1M טוקנים זהה ל-1M מילים?

לא. טוקן אחד הוא בערך 4 תווים באנגלית, או כ-0.75 מילים, ולכן מיליון טוקנים הם בערך 750,000 מילים. זהו אומדן בלבד. קוד, JSON ושפות שאינן אנגלית צורכים יותר טוקנים לכל מילה. Claude Opus 4.7 ומעלה משתמשים גם ב-tokenizer חדש יותר, שמייצר בערך 30 אחוז יותר טוקנים עבור טקסט זהה בהשוואה ל-Claude Sonnet 4.6 ומטה. לכן אי אפשר להעביר את הספירות בין דורות של מודלים. מדדו באמצעות נקודת הקצה החינמית /v1/messages/count_tokens, תוך העברת המודל שאתם מתכננים להפעיל.

האם prompt caching תמיד חוסך כסף?

לא. כתיבה ל-cache למשך 5 דקות עולה פי 1.25 מתעריף הקלט הבסיסי. לכן prefix שנכתב אך מעולם לא נקרא עולה 25 אחוז יותר משליחה רגילה שלו. העלות מתקזזת כבר בקריאה הראשונה. המנגנון עלול להיכשל בשתי דרכים, בלי להציג שגיאה. אם ה-prefix המאוחסן משתנה בין בקשות, החיפוש אינו מוצא התאמה, משום שנדרשת התאמה מדויקת ל-prefix. אם ה-prefix קצר מהאורך המינימלי שהמודל מאפשר לשמור ב-cache — 1,024 טוקנים ב-Sonnet 5 ו-4,096 ב-Haiku 4.5 — דבר אינו נשמר ב-cache ולא מוחזרת שגיאה. כאשר cache_creation_input_tokens וגם cache_read_input_tokens מציגים 0, ה-cache אינו עושה דבר.

מדוע החשבון שלי גדל מהר יותר ממספר ההודעות?

משום שכל השיחה נשלחת מחדש בכל תור. ה-Messages API אינו שומר מצב, ולכן תור 20 בשיחה כולל שוב את כל 19 התורות הקודמים כקלט. כאשר כל תור כולל בממוצע 500 טוקנים, שיחה בת 20 תורות שולחת בערך 105,000 טוקני קלט, אף שהתמליל כולו כולל רק 10,000 טוקנים. לולאות של סוכנים פועלות באותו אופן, משום שכל תוצאת כלי נשארת בהיסטוריה. שמרו ב-cache את ה-prefix היציב, או סכמו תורות ישנים יותר והסירו אותם מהבקשה.