כמה עולים מיליון טוקנים ב-Claude? מדריך תמחור

כמה עולה 1M tokens ב-Claude?

1M tokens פירושם מיליון tokens, וזו יחידת התמחור שבה מצוינים מחירי המודלים של Claude API (application programming interface). אין מחיר יחיד ליחידה הזו, משום ש-tokens של קלט ושל פלט מחויבים בתעריפים שונים, ולכל מודל יש זוג תעריפים משלו. ל-Claude Haiku 5.5 יש שני זוגות תעריפים: אחד עבור prompts של עד 100,000 tokens, ואחר, גבוה יותר, עבור prompts של יותר מכך. נכון ל-October 2026, מיליון input tokens עולים $1 ב-Claude Haiku 4.5, $2 ב-Claude Sonnet 5 ו-$5 ב-Claude Opus 5.

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

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

איך נראה נפח של 1M טוקנים

טוקן הוא מקטע טקסט שהמודל קורא או כותב. המילון המונחים של Anthropic מגדיר טוקן אחד ככ-3.5 תווים באנגלית במודלים שקדמו ל-Claude 4.7. סקירת המודלים של Anthropic מציינת שמיליון טוקנים מכילים כ-750,000 מילים במודלים אלו, ועם 3.5 תווים לטוקן מדובר בכ-3.5 מיליון תווים, שהם כ-3.5 MB של טקסט אנגלי פשוט. בטוקנייזר החדש שהוצג עם Claude Opus 4.7, אותו מיליון טוקנים מכיל כ-555,000 מילים, או כ-2.5 מיליון תווים.

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

[
  {
    "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 וטקסט בשפות שאינן אנגלית דוחסים פחות מילים לתוך טוקן, לכן ספירות המילים הללו הן הצד האופטימי. גורם נוסף משנה את הספירה: Claude Opus 4.7 ומעלה, הכוללים את Opus 5 ו-Sonnet 5, משתמשים בטוקנייזר חדש שמייצר כ-30 אחוז יותר טוקנים עבור אותו טקסט בהשוואה ל-Sonnet 4.6 ומטה. Claude Haiku 4.5 משתמש בטוקנייזר הישן. לכן, ספירה שמדדתם ב-Haiku 4.5 תהיה נמוכה מהספירה ב-Sonnet 5 עבור קלט זהה, מה שאומר שהשוואת מחיר ישירה למיליון טוקנים מעבר לגבול הזה אינה הוגנת. ספרו את אותו ה-prompt מול שני המודלים לפני שתחליטו.

מה Claude גובה לכל מיליון tokens

[
  {
    "label": "Haiku 4.5",
    "input_usd": 1,
    "output_usd": 5
  },
  {
    "label": "Sonnet 5",
    "input_usd": 2,
    "output_usd": 10
  },
  {
    "label": "Sonnet 4.6",
    "input_usd": 3,
    "output_usd": 15
  },
  {
    "label": "Opus 5",
    "input_usd": 5,
    "output_usd": 25
  }
]

Claude Sonnet 5 עולה $2 עבור קלט ו־$10 עבור פלט. Anthropic שיווקה תחילה את המחיר הזה כתעריף היכרות עד 31 באוגוסט 2026, ולאחר מכן הפכה אותו למחיר הסטנדרטי וביטלה את העלייה המתוכננת ל־$3 ול־$15. Claude Opus 5 עולה $5 עבור קלט ו־$25 עבור פלט. מודלי Fable נמצאים מעל הטווח הזה: Claude Fable 5 וגם Claude Fable 5.1 החדש יותר מתומחרים ב־$10 עבור קלט וב־$50 עבור פלט, ולכן השאלה אם כדאי לשלם את התעריפים האלה תלויה במשימות שאליהן תנתבו אותם בפועל.

היצע המודלים הנוכחי של Anthropic חדש יותר מהמודלים שהתמחור שלהם מופיע בדף הזה. Claude Opus 5.5 מתומחר ב־$4 עבור קלט וב־$20 עבור פלט, Claude Sonnet 5.5 ב־$2 וב־$10, ו־Claude Haiku 5.5 החל מ־$0.10 וב־$0.50. Opus 5, Sonnet 5, Haiku 4.5 ו־Fable 5 מופיעים כעת כמודלים מדור קודם שעדיין זמינים, ולכן הדוגמאות המחושבות שלהלן עדיין פועלות כפי שהן כתובות. מה עולה Haiku 5.5 ולאן הוא מתאים עוסק בזול מבין המודלים החדשים.

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

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

אורך ההקשר אינו משנה את התעריף, למעט חריג אחד. במודלים Claude 4.6 ואילך, למעט Claude Haiku 5.5, חלון ההקשר המלא של 1M tokens מחויב לפי התמחור הסטנדרטי, ולכן בקשה של 900,000 tokens עולה אותו מחיר לכל token כמו בקשה של 9,000 tokens. Prompt ארוך עולה יותר משום שיש בו יותר tokens, ולא חל תעריף נפרד להקשר ארוך. Claude Haiku 5.5 מתומחר במקום זאת לפי אורך ה־prompt: בקשה שה־prompt שלה כולל יותר מ־100,000 tokens מחויבת ב־$0.50 עבור קלט וב־$2.50 עבור פלט לכל מיליון, במקום $0.10 ו־$0.50, וקריאות וכתיבות למטמון נספרות במסגרת הסף הזה.

החישוב שנשאר תקף לאחר שינוי מחיר

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

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

אומדן מפורט עבור יישום אמיתי

נבחן עוזר תמיכה. הנחיית המערכת והתיעוד של המוצר שלו מסתכמים ב־4,000 טוקנים, והם נשלחים בכל בקשה, משום ש־Messages API הוא חסר מצב והמודל אינו זוכר דבר בין קריאות. שאלת משתמש מוסיפה כ־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, ושימוש במטמון הנחיה חם ב־Sonnet 5 מוריד אותה עוד יותר, ל־$5.40.

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

מנגנון Prompt caching חוסך את החלק החוזר

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

בדגמים המופיעים בטבלת המחירים ובדוגמאות העבודה בעמוד זה (Haiku 4.5, Sonnet 5, Sonnet 4.6 ו-Opus 5), וכן ב-Fable 5, קריאת מטמון עולה פי 0.1 מתעריף הקלט הבסיסי. חלק מהדגמים החדשים יותר גובים פחות עבור קריאה: Opus 5.5 ו-Sonnet 5.5 גובים פי 0.05, ו-Fable 5.1 ו-Mythos 5.1 גובים פי 0.025. כתיבה למטמון עולה פי 1.25 מהבסיס עבור זמן חיים של 5 דקות, או פי 2 מהבסיס עבור זמן חיים של שעה. לכן, בדגמים שבהם העלות היא פי 0.1, המטמון ל-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 תהיה שגויה באופן משמעותי ברגע שה-caching מופעל.

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

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

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

עיבוד אצווה (Batch) מקצץ את התעריף בחצי

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

הוויתור הוא על זמן תגובה (latency), מה שהופך את עיבוד האצווה ללא מתאים לכל תהליך שבו משתמש ממתין לתוצאה. הוא מתאים למשימות כמו סיווג לילי או השלמת נתונים (backfills) למסמכים.

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

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

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

זו הסיבה שתכונת צ'אט עולה יותר ממה שהתמליל מרמז, וזו הסיבה ששמירה ב-cache של הקידומת היציבה או סיכום פניות ישנות משתלמים בשרשורים ארוכים. סוכן (agent) שמבצע לולאות של קריאות לכלים (tool calls) סובל מאותה בעיה, ואף גרוע מכך: כל תוצאה של כלי נשארת בהיסטוריה ונשלחת מחדש בכל פנייה עוקבת. הגדרת מגבלת הוצאות קשיחה על סוכן שאתם מריצים בעצמכם היא קריטית במקרה זה, כיוון שהגידול הזה הוא אוטומטי ואף אחד לא מנטר אותו.

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

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

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

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

מה עוד נכלל בחשבונית

אסימונים (tokens) מהווים את רוב החשבונית. כמה פריטים אינם אסימונים, והם נוטים להפתיע משתמשים.

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

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

FAQ

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

המחיר תלוי במודל ובשאלה אם ה־tokens הם קלט או פלט. נכון ל־October 2026, מיליון tokens של קלט עולים $1 ב־Claude Haiku 4.5, $2 ב־Claude Sonnet 5, ו־$5 ב־Claude Opus 5. ה־Claude Haiku 5.5 החדש מתחיל ב־$0.10 למיליון tokens של קלט עבור prompts של עד 100,000 tokens, וגובה $0.50 מעל כמות זו. עלות הפלט גבוהה פי חמישה מתעריף הקלט בכל אחד מהמודלים האלה. התעריפים משתנים, לכן יש לאמת אותם בדף התמחור הרשמי לפני שמקצים סכום בתקציב.

האם 1M tokens הם כמו 1M מילים?

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

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

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

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

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