למה טוקנים של פלט ב-Claude יקרים פי 5 מטוקנים של קלט?

מדוע טוקנים של פלט יקרים יותר מטוקנים של קלט

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

יחס זה זהה בכל שורה במחירון, לכן הדגם שתבחרו אינו משנה איזה חלק מהחשבון שלכם מוקצה לפלט. מבנה עומס העבודה שלכם הוא שקובע זאת. שלב של סוכן (agent) שקורא 60,000 טוקנים ועונה ב-800 כמעט אינו מוציא דבר על פלט. משימת כתיבה שקוראת 2,000 טוקנים וכותבת 12,000 כמעט אינה מוציאה דבר על קלט. שני המקרים מחושבים להלן לפי התעריפים שפרסמה Anthropic באוגוסט 2026.

שלב ה-Prefill מתבצע פעם אחת, שלב ה-Decoding מתבצע פעם אחת לכל טוקן

שרת הסקה (inference server) מטפל בבקשה בשני שלבים בעלי עלויות שונות בתכלית. שלב ה-Prefill קורא את ה-prompt. שלב ה-Decoding כותב את התשובה.

שלב ה-Prefill מעבד את כל ה-prompt בבת אחת. כל טוקן ב-prompt נכנס לרשת באותו forward pass, כך שהעבודה על ה-attention וה-feed-forward הופכת למספר קטן של כפל מטריצות גדול המכסה אלפי טוקנים בכל פעם. קריאה אחת של משקולות המודל מהזיכרון משרתת את כל ה-prompt. יחידות המטריצה של המאיץ נשארות עמוסות, מה שאומר ש-prefill מוגבל על ידי כוח חישוב (compute-bound): המגבלה היא המהירות שבה השבב מסוגל לבצע כפל.

שלב ה-Decoding אינו יכול לעבוד כך, כיוון שטוקן 2 תלוי בטוקן 1. הטוקן שהמודל הרגע הפיק הופך לחלק מהקלט לשלב הבא, ולכן השלבים אינם יכולים לרוץ במקביל. כל טוקן פלט מקבל forward pass משלו, וכל אחד מהמעברים הללו קורא את מלוא סט משקולות המודל מהזיכרון בעל רוחב הפס הגבוה (high-bandwidth memory) כדי להפיק טוקן בודד. עובדה זו הופכת את ה-decoding למוגבל על ידי זיכרון (memory-bound): המגבלה היא המהירות שבה ניתן להעביר משקולות, ולא המהירות שבה ניתן להכפיל אותן. אותה תעבורת משקולות שצרכה prompt שלם במהלך ה-prefill, מעניקה לך טוקן אחד בלבד במהלך ה-decoding.

מערכות הגשה (serving systems) נלחמות בכך באמצעות batching. בקשות רבות עוברות decoding יחד, כך שקריאה אחת של המשקולות מפיקה טוקן אחד עבור כל בקשה ב-batch. זו הסיבה ש-decoding הוא בכלל בר-ביצוע. התקרה היא שוב הזיכרון. כל בקשה פעילה מחזיקה KV cache (מטמון מפתח/ערך, מצב ה-attention שנשמר עבור כל טוקן עד כה); מטמון זה גדל עם כל טוקן שנוצר, וכאשר הוא ממלא את המאיץ, ה-batch אינו יכול לגדול עוד.

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

מדדו בעצמכם את הפער בין הקלט לפלט

התקינו את הכלים על כל מכונת Ubuntu:

sudo apt update && sudo apt install -y curl jq moreutils

כעת, הזרימו (stream) הנחיה קצרה המבקשת תשובה ארוכה, וציינו בכל שורה את זמן הגעתה.

curl -sN https://api.anthropic.com/v1/messages \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "content-type: application/json" \
  -d '{"model":"claude-sonnet-5","max_tokens":1000,"stream":true,
       "messages":[{"role":"user","content":"Count from 1 to 300, one number per line."}]}' \
  | ts -s '%.s'

ts -s מוסיף לכל שורה את מספר השניות שחלפו מאז תחילת הפקודה. שני נתונים מתוך הפלט הזה ראויים לתשומת לב. השורה הראשונה של content_block_delta היא הזמן עד לקבלת ה־token הראשון, ובתוכה התרחש כל שלב ה־prefill. כל שורה לאחר מכן היא צעד קטן של פענוח (decoding), והחותמות ממשיכות לעלות עד להגעת message_stop.

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

curl -sN https://api.anthropic.com/v1/messages \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "content-type: application/json" \
  -d "$(jq -n --rawfile doc ./long-document.txt \
       '{model:"claude-sonnet-5", max_tokens:16, stream:true,
         messages:[{role:"user", content:("Answer in one word. Is this document about networking?\n\n" + $doc)}]}')" \
  | ts -s '%.s'

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

כל תגובה שאינה מוזרמת (non-streaming) מסתיימת במספרים שלפיהם אתם מחויבים בתשלום.

{
  "usage": {
    "input_tokens": 41283,
    "output_tokens": 6,
    "cache_creation_input_tokens": 0,
    "cache_read_input_tokens": 0
  }
}

תעדו את כל ארבעת השדות עבור כל בקשה. output_tokens כולל חשיבה מורחבת, לכן מודל שחושב לפני שהוא עונה מחייב על חשיבה זו לפי תעריף הפלט. כדי לתמחר הנחיה לפני שליחתה, POST /v1/messages/count_tokens מקבל את אותו גוף בקשה, מחזיר את {"input_tokens": N} מבלי להריץ את המודל, והוא ללא עלות. זהו אינו החלק היחיד ב־API שאינו עולה כסף, וכדאי לבדוק אילו חלקים ב־Claude API אינם מחויבים בתשלום לפני שמתקצבים פרויקט ראשון.

עלויות Claude למיליון טוקנים נכון לאוגוסט 2026

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

העמודה האחרונה מציגה את היחס בין פלט לקלט, והיא מציגה 5 בכל שורה. עבור Haiku 4.5, התעריף הוא $1 לקלט ו-$5 לפלט. עבור Opus 5, התעריף הוא $5 ו-$25. המודל היקר ביותר, Fable 5, מתומחר ב-$10 ו-$50, ומומלץ לקרוא מה מקבלים תמורת התעריפים של Fable 5 לפני שפוסלים את השורה הראשונה. מעבר בין מודלים בטווח מכפיל את שני הצדדים באותו גורם, כך שהעלות הכוללת משתנה אך היחס בין הקלט לפלט נשאר זהה.

המודל Sonnet 5 מופיע פעמיים כיוון שתעריף ההשקה שלו עומד לפוג. עד ה-31 באוגוסט 2026, התעריף הוא $2 לקלט ו-$10 לפלט. החל מה-1 בספטמבר 2026 יחול התעריף הסטנדרטי של $3 לקלט ו-$15 לפלט, המהווה עלייה של 50% בשני הצדדים. כל הדוגמאות המחושבות להלן משתמשות בתעריפי אוגוסט.

תעריפים משתנים, ודף זה אינו המקום לבדוק אותם. claude.com/pricing הוא המקור הרשמי. מה ששורד שינויי מחירים הוא המתודולוגיה.

סייג אחד שאינו מופיע במחירון: התיעוד של Anthropic מציין כי Claude 4.7 ומודלים מאוחרים יותר משתמשים ב-tokenizer חדש, המייצר כ-30% יותר טוקנים עבור אותו טקסט בהשוואה ל-tokenizer של Sonnet 4.6 ומודלים קודמים. השוואת מחירים למיליון טוקנים בלבד תציג את המודל החדש באור חיובי יותר, כיוון שאותו מסמך מתורגם ליותר טוקנים. בצעו השוואה לפי עלות למשימה שהושלמה, ובחנו את ה-prompts האמיתיים שלכם מול המודל שבו אתם מתכננים להשתמש. מלכודת דומה קיימת בין ספקי שירות שונים, שה-tokenizers שלהם נבדלים זה מזה בשיעורים גבוהים אף יותר, לכן חישוב עלות של משימה אמיתית ב-Claude וב-ChatGPT יספק לכם מידע רב יותר מאשר הצבת שני מחירונים זה לצד זה. המאמר מה שווה מיליון טוקנים של Claude בטקסט אמיתי מפרט כיצד נפח זה נראה בפועל.

מתי ה-output מתחיל להוות את עיקר העלות בחשבונית שלכם?

כאשר ה-output מתומחר פי 5 מה-input, קל לחשב את נקודת האיזון בראש. נסמן את טוקני ה-input ב-I ואת טוקני ה-output ב-O. עלות ה-input היא I. עלות ה-output היא פי 5 מ-O. ה-output מהווה יותר ממחצית ההוצאה כאשר 5 פעמים O גדול מ-I, כלומר יחס של 5 טוקני input על כל 1 טוקן output.

לכן, אם ה-prompt שלכם ארוך פי יותר מ-5 מהתשובה, ה-input הוא סעיף ההוצאה המשמעותי יותר. מתחת ליחס זה, ה-output הוא הסעיף המשמעותי.

[
  {
    "label": "100:1",
    "input_share_pct": 95.2,
    "output_share_pct": 4.8
  },
  {
    "label": "75:1",
    "input_share_pct": 93.75,
    "output_share_pct": 6.25
  },
  {
    "label": "20:1",
    "input_share_pct": 80,
    "output_share_pct": 20
  },
  {
    "label": "10:1",
    "input_share_pct": 66.7,
    "output_share_pct": 33.3
  },
  {
    "label": "5:1",
    "input_share_pct": 50,
    "output_share_pct": 50
  },
  {
    "label": "1:1",
    "input_share_pct": 16.7,
    "output_share_pct": 83.3
  },
  {
    "label": "1:6",
    "input_share_pct": 3.2,
    "output_share_pct": 96.8
  }
]

ביחס של 100 ל-1, ה-output מהווה 4.8% מההוצאה, וצמצום ה-prompt הוא הפעולה היחידה ששווה להשקיע בה. ביחס של 5 ל-1 שני הצדדים שווים. ביחס של 1 ל-6, ה-output מהווה 96.8% וה-prompt הוא טעות עיגול בלבד. רוב האנשים מעריכים לא נכון את היחס שלהם, לכן כדאי להפיק נתונים מה-logs לפני שמתחילים לבצע אופטימיזציה כלשהי.

עומס עבודה של סוכן: קלט ארוך, פלט קצר

קחו צעד אחד של סוכן שליפת מידע: 60,000 טוקנים של קלט המורכבים ממסמכים שנשלפו והיסטוריית שיחה, ותשובה של 800 טוקנים. זהו יחס של 75 ל-1, יחס סטנדרטי לכל תהליך שקורא לפני שהוא כותב.

[
  {
    "label": "Haiku 4.5",
    "input_cost": 0.06,
    "output_cost": 0.004,
    "total_cost": 0.064
  },
  {
    "label": "Sonnet 5 (Aug)",
    "input_cost": 0.12,
    "output_cost": 0.008,
    "total_cost": 0.128
  },
  {
    "label": "Opus 5",
    "input_cost": 0.3,
    "output_cost": 0.02,
    "total_cost": 0.32
  },
  {
    "label": "Fable 5",
    "input_cost": 0.6,
    "output_cost": 0.04,
    "total_cost": 0.64
  }
]

הפלט מהווה 6.25% מעלות הקריאה בכל מודל, כיוון שהיחס קבוע לאורך כל מחירון השירותים. הקריאה עולה $0.32 ב-Opus 5, $0.128 ב-Sonnet 5 לפי התעריף של אוגוסט, ו-$0.064 ב-Haiku 4.5. מאתיים צעדים כאלו ביום ב-Opus 5 יעלו 64$ ליום.

מנוף ההשפעה ברור ברגע שמבינים את החלוקה. קיצור התשובה מ-800 טוקנים ל-400 חוסך כ-3% מעלות הקריאה. הסרה של 20,000 טוקנים של הקשר (context) לא רלוונטי מה-prompt חוסכת כשליש מהעלות. צמצום אורך הפלט בסוכן שמתבסס בעיקר על קריאה הוא מאמץ שכמעט אינו משתלם. לאן הולכים הטוקנים של סוכן תכנות בפועל מפרט מה ממלא את ה-prompt מלכתחילה.

עומס עבודה של יצירת תוכן: הנחיה קצרה, טיוטה ארוכה

כעת נהפוך את היחס. תדריך של 2,000 אסימונים (tokens), טיוטה של 12,000 אסימונים, יחס של 1 ל-6.

[
  {
    "label": "Haiku 4.5",
    "input_cost": 0.002,
    "output_cost": 0.06,
    "total_cost": 0.062,
    "batch_total_cost": 0.031
  },
  {
    "label": "Sonnet 5 (Aug)",
    "input_cost": 0.004,
    "output_cost": 0.12,
    "total_cost": 0.124,
    "batch_total_cost": 0.062
  },
  {
    "label": "Opus 5",
    "input_cost": 0.01,
    "output_cost": 0.3,
    "total_cost": 0.31,
    "batch_total_cost": 0.155
  },
  {
    "label": "Fable 5",
    "input_cost": 0.02,
    "output_cost": 0.6,
    "total_cost": 0.62,
    "batch_total_cost": 0.31
  }
]

הפלט מהווה 96.8% מהחשבון הזה. Opus 5 עולה $0.31 לטיוטה לעומת $0.062 ב-Haiku 4.5. פער של פי חמישה זה נובע כמעט כולו מצד הפלט, וזה בדיוק המקום שבו מודל זול יותר חוסך לכם הכי הרבה.

העמודה האחרונה מציגה את אותה משימה דרך ה-Batch API, שמפחית 50% מעלות הקלט והפלט. העלות של Opus 5 יורדת ל-$0.155 לטיוטה. Batch מחזיר תוצאות בתוך 24 שעות במקום באופן מיידי, לכן הוא מתאים ליצירת דוחות ליליים וסיווג בכמויות גדולות. הוא אינו מתאים למשימות שבהן אדם יושב וממתין לתוצאה.

ניתוב מודלים משתלם כאן באופן שאינו קיים בשלב ה-agent. אם החלק המילולי של המשימה הוא מכני, כמו עיצוב מחדש של טקסט או הרחבת ראשי פרקים שכבר אישרתם, המודל הזול מייצר את האסימונים הללו בחמישית מהמחיר. בחירה בין Opus, Sonnet ו-Haiku מפרט היכן עובר קו האיכות בפועל.

הנחות בגין מטמון (Caching) חלות על קלט בלבד

מנגנון ה־prompt caching שומר קידומת של ה־prompt בשרת ומחייב בתעריף חלקי בלבד עבור קריאה חוזרת שלו. נכון לאוגוסט 2026, המכפילים הם 1.25x מתעריף הקלט הבסיסי לכתיבת מטמון ל־5 דקות, 2x לכתיבת מטמון לשעה, ו־0.1x עבור קריאה מוצלחת (hit).

פלט אינו כלול בהסדר זה. אין מטמון לפלט. כל אסימון (token) שהמודל כותב מחויב בתעריף הפלט המלא, בכל פעם, ללא קשר לכמות ה־prompt שחזרה כ־cache hit.

נבחן את אותו שלב של סוכן (agent) ב־Opus 5, כאשר 55,000 מתוך 60,000 אסימוני הקלט מגיעים ממטמון פעיל.

[
  {
    "label": "No cache",
    "input_cost": 0.3,
    "output_cost": 0.02,
    "total_cost": 0.32
  },
  {
    "label": "55k prefix cache read",
    "input_cost": 0.0525,
    "output_cost": 0.02,
    "total_cost": 0.0725
  }
]

עלות הקריאה יורדת מ-$0.32 ל-$0.0725. שורת הפלט אינה משתנה: $0.02 לפני, ו-$0.02 אחרי. השימוש במטמון מקטין את החשבונית ומשנה את הרכבה. הפלט היווה 6.25% מאותה קריאה. כעת הוא מהווה יותר מרבע ממנה, מה שמשנה את סדרי העדיפויות לביצוע אופטימיזציה.

הקריאה הראשונה מכסה את עלות הכתיבה. כתיבה למטמון ל־5 דקות עולה 1.25x מקלט בסיסי, לכן היא מחזירה את עצמה לאחר hit אחד בלבד. כתיבה לשעה עולה 2x, ולכן נדרשים שני hits. מכפילי הכתיבה והקריאה, והנקודה שבה המטמון מפסיק להיות משתלם מפרט את החישובים הללו.

ארבעה מנופים בשליטתך

1. הגדר את max_tokens לפי אורך הפלט ב-p95, ולא לפי המקסימום של המודל.
2. נתב שלבים מפורטים למודל זול יותר.
3. בצע Batch לכל משימה שאיש אינו ממתין לתוצאותיה.
4. מחק הנחיות שמנפחות את התשובות.

max_tokens הוא תקרה קשיחה, והגדרתו על ערך גבוה אינה עולה דבר כשלעצמה, שכן החיוב מתבצע לפי טוקנים שיוצרו ולא לפי התקרה. תפקידו של גבול נדיב הוא להסיר מגבלה מתשובה שמשתבשת. חלץ את התפלגות ה-output_tokens מהלוגים שלך, הגדר את התקרה מעט מעל האחוזון ה-95, וטפל ב-stop_reason: "max_tokens" בקוד באמצעות המשך התגובה או ניסיון חוזר. קיטוע שאתה מזהה עולה פחות מתגובה של 4,000 טוקנים שאתה משלם עליה וזורק. חשיבה מורחבת נכנסת גם היא ל-output_tokens, לכן הגדר את התקציב הזה על סמך אותן ראיות.

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

Batching הוא המנוף היחיד שמעניק הנחה על פלט. 50% הנחה על שני הצדדים, תוצאות בתוך 24 שעות, וכל משימה מתוזמנת מתאימה לכך.

המנוף האחרון הוא זה שאנשים מדלגים עליו. ביטויים כמו "be thorough" או "explain your reasoning" קובעים את אורך הפלט שלך בכל קריאה שתבצע אי פעם. החלף אותם במבנה הרצוי: "Answer in at most three sentences", או "Return only the JSON object, with no preamble". הנחיית מערכת (system prompt) שמוסיפה 300 טוקנים לכל תשובה עולה פי חמישה מאותם 300 טוקנים בתוך ה-prompt עצמו. שמירה על עלויות של סוכן פעיל תחת שליטה מכסה את צד הניטור, וכדאי להכריע ב-האם ה-API או מנוי קבוע זולים יותר עבור דפוס העבודה שלך לפני שתשקיע שבוע בכוונון הוצאות לפי טוקן שמנוי היה סופג. עבור מפתח בודד, זה מסתכם לרוב בשאלה האם Claude Pro בעלות של 20 דולר לחודש ומגבלות השימוש הנלוות אליו מכסים את העבודה שהיית מחויב עליה לפי צריכה. אם אתה כבר מגיע למגבלות הללו באמצע סשן, הבנה על איזה חלון אתה ממתין היא הצעד הראשון, שכן הפתרון משם הוא מודל קטן יותר, הקשר (context) מצומצם יותר, תוספת קרדיטים לשימוש, או העברת העבודה ל-API לפי צריכה. אם ה-API לפי צריכה מתגלה כבית זול יותר לעבודה זו, מעבר לתוכנית קטנה יותר או ביטולה מותיר את החודש שכבר שילמת עליו בתוקף, כך שהמעבר אינו עולה לך דבר ביציאה. אם התוכנית שאתה שוקל מול Pro היא זו של ChatGPT ולא ה-API לפי צריכה, השוואת סולמות המנויים זה לצד זה מראה איזו מהן יוצאת זולה יותר עבור עבודת פיתוח. אם השאלה נשאלת עבור צוות ולא עבור מפתח בודד, שים לב ש-Claude Enterprise משלב תשלום לפי מושב עם טוקנים שמחויבים לפי אותם תעריפי API, כך שכל מנוף בדף זה עדיין חל על החלק המחויב לפי צריכה בחשבונית זו.

FAQ

מדוע אסימוני פלט (output tokens) יקרים יותר מאסימוני קלט (input tokens)?

יצירתם דורשת זמן רב יותר של המאיץ לכל אסימון. הנחיה (prompt) מעובדת במעבר קדימה (forward pass) אחד על פני כל התוכן, כך שקריאה בודדת של משקלי המודל מכסה אלפי אסימונים, והחומרה מוגבלת על ידי קצב הכפל. תשובה מופקת אסימון אחר אסימון, כאשר כל אסימון דורש מעבר קדימה משלו שקורא שוב את כל משקלי המודל; לכן, החומרה מוגבלת במקרה זה על ידי רוחב הפס של הזיכרון. Anthropic מתמחרת פלט פי 5 מקלט בכל הקטלוג הנוכחי, מ-Haiku 4.5 ועד Fable 5.

האם מטמון הנחיות (prompt caching) מוזיל את אסימוני הפלט?

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

האם max_tokens גבוה עולה לי כסף אם התשובה המתקבלת קצרה?

לא. החיוב מתבצע עבור האסימונים שהמודל מפיק בפועל, לכן max_tokens הוא תקרה ולא הזמנה מראש. הוא עדיין חשוב, כיוון שזהו הגבול הקשיח היחיד לתשובה שיוצאת משליטה. הגדירו אותו מעט מעל האחוזון ה-95 של ה-output_tokens שנצפה אצלכם, ולאחר מכן טפלו ב-stop_reason: "max_tokens" בקוד במקום לשלוח תשובה שנקטעה בשתיקה.

כיצד אמצא את יחס אסימוני הקלט לפלט שלי?

תעדו את input_tokens, output_tokens, cache_read_input_tokens ו-cache_creation_input_tokens מתוך האובייקט usage של כל תגובה, ולאחר מכן חלקו את הסכומים לאורך שבוע. מעל יחס של 5 אסימוני קלט ל-1 אסימון פלט, הכסף שלכם מושקע בהנחיה, לכן בצעו מטמון לחלק היציב וקצצו את השאר. מתחת ליחס זה, הכסף שלכם מושקע בתשובה, לכן הגבילו את אורכה והעבירו את השלבים שמייצרים את רוב הפלט למודל זול יותר או ל-Batch API.