GPU VPS או API: מתי משתלם יותר להריץ מודל עצמאית?

היכן נמצאת נקודת האיזון בפועל

שרת GPU VPS עדיף על חיוב API לפי טוקנים בנקודה אחת: כאשר העלות החודשית הקבועה, מחולקת במספר הטוקנים שהופקו בפועל באותו חודש, נמוכה מהמחיר שגובה ה-API עבור אותה כמות טוקנים. שכר הדירה אינו משתנה. חשבון ה-API משתנה עם כל בקשה. לכן, התשובה היא תמיד נפח חודשי, ולא תשובה פשוטה של כן או לא.

נבצע את החישוב עבור שרת GPU VPS בדרג ביניים בעלות של $0.50 לשעה, שהם $365 עבור חודש של 730 שעות. מול ה-API של מודל חזיתי (frontier model), נקודת האיזון היא 24.3 מיליון טוקנים מופקים בחודש. מול מודל מסחרי קטן, הנקודה היא 73 מיליון. מול מודל בקוד פתוח (open-weight) באותו גודל המתארח בשרת, לעולם לא תגיעו לנקודת איזון, כיוון שכרטיס אחד אינו מסוגל להפיק מספיק טוקנים בחודש כדי להגיע לנקודת המפגש.

מחקרים שפורסמו בנושא נקודת האיזון אינם עונים על שאלה זו. שניים מהם, שפורסמו מוקדם יותר בשנת 2026, מציבים את נקודת המפגש סביב 72% ניצולת מתמשכת ב-H200, ובין 22% ל-48% מחזור עבודה (duty cycle) ב-MI300X. שניהם משווים את הנתונים מול מוצר ה-serverless של אותו ספק, ושניהם מתמחרים מאיצים שעולים לשעה יותר ממה שרוב הקוראים כאן מוציאים בחודש. החישוב האריתמטי זהה. מה שמופיע להלן מבצע את החישוב מחדש עבור כרטיס אחד, מודל פתוח אחד בטווח של 7B עד 30B, וחיוב API רגיל לפי שימוש.

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

הנוסחה, כדי שתוכל להציב מספרים משלך

cost_per_million = (hourly_rate * 1000000) / (tokens_per_second * 3600 * duty_cycle)

breakeven_millions_per_month = (hourly_rate * hours_per_month) / api_price_per_million

capacity_millions_per_month = (tokens_per_second * 3600 * hours_per_month) / 1000000

required_duty_cycle = breakeven_millions_per_month / capacity_millions_per_month

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

• hourly_rate הוא העלות לשעה של ה-GPU VPS, כולל השעות שבהן הוא אינו בשימוש. אם התשלום חודשי, חלק את המחיר החודשי ב-730.
• tokens_per_second הוא קצב הפלט המצטבר שהשרת שלך מקיים תחת רמת ה-concurrency האמיתית שלך. זהו אינו הנתון של זרם יחיד מתוך טבלת נתונים של ספק.
• duty_cycle הוא שיעור הזמן בחודש שבו ה-GPU מייצר טוקנים. שרת ששכרת לכל החודש ואתה משתמש בו שעתיים ביום נמצא בשיעור של 8.3%.
• api_price_per_million הוא המחיר הנמדד שאתה משווה אליו, עבור טוקני פלט.

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

כיצד למדוד tokens per second לפני שמסתמכים על החישוב

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

Ollama מספקת את נתון ה-single-stream בפקודה אחת:

ollama run qwen3:8b --verbose "Write 400 words about disk latency."

--verbose מדפיס בלוק תזמון לאחר התשובה. השורה החשובה היא eval rate, המציינת tokens per second, וסופרת את שלב ה-generation בלבד. prompt eval rate היא מהירות ה-prefill והיא בדרך כלל גבוהה בהרבה. המספרים שלכם יהיו שונים מאלו:

eval count:       412 token(s)
eval duration:    9.612s
eval rate:        42.86 tokens/s

Single stream הוא נתון שגוי עבור מודל עלויות, כיוון שהוא מודד בקשה אחת בכל פעם על כרטיס שמסוגל לשרת בקשות רבות במקביל. עבור הנתון המצטבר, הריצו את המודל עם vLLM וקראו את ה-throughput שהשרת מדווח על עצמו:

pip install vllm
vllm serve Qwen/Qwen3-8B --max-model-len 8192

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

Avg prompt throughput: 812.4 tokens/s, Avg generation throughput: 396.1 tokens/s, Running: 16 reqs, Waiting: 0 reqs, GPU KV cache usage: 21.7%

Avg generation throughput הוא המספר שהנוסחה דורשת. הוא עולה ככל שמוסיפים בקשות במקביל עד ש-KV cache (זיכרון ה-key-value, מצב ה-attention לכל בקשה ש-vLLM שומר ב-VRAM) מתמלא, ואז העלייה נעצרת. אם תעברו את הנקודה הזו, הבקשות ימתינו בתור במקום לעבור מהר יותר, מה שיתבטא בעלייה בערך Waiting. ב-vLLM כלול גם מחולל עומסים, vllm bench serve. הדגלים שלו משתנים בין גרסאות, לכן הריצו vllm bench serve --help על הגרסה שהתקנתם במקום להעתיק פקודה מפוסט בבלוג.

עקבו אחר הכרטיס בזמן שהבדיקה רצה:

nvidia-smi --query-gpu=utilization.gpu,memory.used,power.draw --format=csv -l 5

אם utilization.gpu נשאר קרוב ל-100% במהלך ה-generation, אתם מוגבלים על ידי ה-throughput והמספר שמדדתם הוא התקרה האמיתית. אם הוא נשאר נמוך, משהו אחר מהווה את המגבלה: מעט מדי בקשות במקביל, לקוח איטי, או מודל שאינו נכנס ב-VRAM ומועבר בחלקו ל-system RAM. Ollama ו-vLLM מבצעים פשרות שונות מאוד כאן, והפער ביניהם על אותו כרטיס גדול מספיק כדי לשנות את נקודת האיזון שלכם פי כמה.

איך נראה החשבון לאורך חודש

הדוגמה המעשית היא שרת VPS עם GPU בנפח 24 GB בעלות של $0.50 לשעה, המריץ מודל פתוח של 8B באמצעות vLLM, עם קצב מדידה של 400 טוקנים של פלט בשנייה במצטבר עבור 16 בקשות במקביל. דמי השכירות קבועים ללא קשר לשימוש בכרטיס. הקיבולת בקצב זה היא 1,051 מיליון טוקנים של פלט בחודש, וזהו התפוקה המקסימלית של הכרטיס אם הוא פועל ללא הפסקה.

[
  {
    "output_tokens_millions": 5,
    "gpu_vps_usd": 365,
    "open_api_usd": 1,
    "small_api_usd": 25,
    "frontier_api_usd": 75
  },
  {
    "output_tokens_millions": 10,
    "gpu_vps_usd": 365,
    "open_api_usd": 2,
    "small_api_usd": 50,
    "frontier_api_usd": 150
  },
  {
    "output_tokens_millions": 25,
    "gpu_vps_usd": 365,
    "open_api_usd": 5,
    "small_api_usd": 125,
    "frontier_api_usd": 375
  },
  {
    "output_tokens_millions": 50,
    "gpu_vps_usd": 365,
    "open_api_usd": 10,
    "small_api_usd": 250,
    "frontier_api_usd": 750
  },
  {
    "output_tokens_millions": 100,
    "gpu_vps_usd": 365,
    "open_api_usd": 20,
    "small_api_usd": 500,
    "frontier_api_usd": 1500
  },
  {
    "output_tokens_millions": 250,
    "gpu_vps_usd": 365,
    "open_api_usd": 50,
    "small_api_usd": 1250,
    "frontier_api_usd": 3750
  },
  {
    "output_tokens_millions": 500,
    "gpu_vps_usd": 365,
    "open_api_usd": 100,
    "small_api_usd": 2500,
    "frontier_api_usd": 7500
  },
  {
    "output_tokens_millions": 1000,
    "gpu_vps_usd": 365,
    "open_api_usd": 200,
    "small_api_usd": 5000,
    "frontier_api_usd": 15000
  }
]

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

בנפח של 25 מיליון טוקנים של פלט בחודש, ה-API של מודל חזיתי (frontier) מחייב ב-375 דולרים, כך שההפרש בין שתי האפשרויות הוא פחות מעשרה דולרים. בנפח של 50 מיליון, המודל המסחרי הקטן מחייב ב-250 דולרים ועדיין מהווה את האופציה הזולה יותר. בנפח של 1000 מיליון טוקנים של פלט, הדורש מהכרטיס להיות פעיל ב-95% מהחודש, ה-API המארח מודל בקוד פתוח מחייב ב-200 דולרים מול אותם דמי שכירות. הכרטיס מפסיד בפער של כמעט פי שניים בדיוק בנפח העבודה שבו הוא מנוצל בצורה המקסימלית.

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

עלות למיליון טוקנים של פלט בכל מחזור עבודה

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

[
  {
    "label": "100% duty",
    "self_host_usd_per_million": "0.35",
    "open_api_usd_per_million": "0.20",
    "small_api_usd_per_million": "5.00",
    "frontier_api_usd_per_million": "15.00"
  },
  {
    "label": "50% duty",
    "self_host_usd_per_million": "0.69",
    "open_api_usd_per_million": "0.20",
    "small_api_usd_per_million": "5.00",
    "frontier_api_usd_per_million": "15.00"
  },
  {
    "label": "25% duty",
    "self_host_usd_per_million": "1.39",
    "open_api_usd_per_million": "0.20",
    "small_api_usd_per_million": "5.00",
    "frontier_api_usd_per_million": "15.00"
  },
  {
    "label": "10% duty",
    "self_host_usd_per_million": "3.47",
    "open_api_usd_per_million": "0.20",
    "small_api_usd_per_million": "5.00",
    "frontier_api_usd_per_million": "15.00"
  },
  {
    "label": "5% duty",
    "self_host_usd_per_million": "6.94",
    "open_api_usd_per_million": "0.20",
    "small_api_usd_per_million": "5.00",
    "frontier_api_usd_per_million": "15.00"
  },
  {
    "label": "2% duty",
    "self_host_usd_per_million": "17.36",
    "open_api_usd_per_million": "0.20",
    "small_api_usd_per_million": "5.00",
    "frontier_api_usd_per_million": "15.00"
  }
]

שלוש עמודות ה-API מציגות מחירי מחירון טיפוסיים נכון לאוגוסט 2026: 0.20 דולרים למיליון טוקנים של פלט עבור מודל 8B בעל משקולות פתוחות המתארח בענן, 5.00 דולרים עבור מודל מסחרי קטן, ו-15.00 דולרים עבור מודל חזיתי (frontier). נתונים אלו נועדו להמחשה בלבד. בדקו את דף המחירים העדכני לפני קבלת החלטות. אם ההשוואה שלכם היא מול תוכנית חודשית קבועה ולא מול תשלום לפי טוקנים, החישוב של דמי המנוי עובד אחרת ונקודת האיזון משתנה בהתאם.

בהרצה רציפה של הכרטיס במלוא העומס, עלות מיליון טוקנים של פלט היא 0.35 דולרים, מחיר זול באופן מובהק. במחזור עבודה של 10%, אותו מיליון טוקנים עולה 3.47 דולרים. במחזור עבודה של 2%, העלות היא 17.36 דולרים, סכום שאינו באותו סדר גודל של 0.20 דולרים שגובה מודל פתוח מארח עבור פלט זהה.

מתחת למחזור עבודה של כ-10%, השכרת GPU הופכת לבחירה יקרה. אתם משלמים 3.47 דולרים למיליון טוקנים עבור פלט שנמכר ב-0.20 דולרים; מה שאתם קונים בהפרש הזה הוא פרטיות וחשבונית קבועה שאינה משתנה. אלו יכולים להיות שווים כסף רב. הם אינם מהווים יתרון במחיר, לכן אל תסווגו אותם ככאלה.

נפח נקודת האיזון עבור כל שכבת API

[
  {
    "label": "Hosted open 8B API",
    "breakeven_tokens_millions": 1825,
    "required_duty_pct": 174
  },
  {
    "label": "Small commercial model",
    "breakeven_tokens_millions": 73,
    "required_duty_pct": 6.9
  },
  {
    "label": "Frontier model",
    "breakeven_tokens_millions": 24.3,
    "required_duty_pct": 2.3
  }
]

עבור שכבת ה-frontier, נדרשים 24.3 מיליון טוקנים של פלט בחודש, המהווים רק 2.3% מהיכולת של הכרטיס. זהו רף נמוך. צוות קטן שמריץ סוכני תכנות במהלך יום העבודה עובר אותו בקלות.

עבור שכבת ה-small commercial נדרשים 73 מיליון טוקנים בחודש, או מחזור עבודה (duty cycle) של 6.9%. עבור שכבת ה-hosted open-weight, מחזור העבודה הנדרש הוא 174%. כל ערך מעל 100% אינו בר-השגה מעצם הגדרתו: הכרטיס יצטרך לפעול יותר שעות ממה שיש בחודש. כרטיס אחד בדרג ביניים בתעריף שעתי זה אינו יכול לנצח בהשוואה זו, לכן הדרכים היחידות לשנות את התוצאה הן כרטיס זול יותר, כרטיס מהיר יותר, או סיבה שאינה נוגעת למחיר.

מה שהנוסחה מסתירה

הנוסחה מתמחרת שעות GPU וטוקנים. עלויות ממשיות רבות נותרות מחוץ לה.

Cold starts. מודל 8B במשקולות 16-bit שוקל כ-16 GB, וטעינתו מהדיסק המקומי ל-VRAM אורכת עשרות שניות. אם תעצרו את השרת בין שימושים כדי לחסוך בעלות, תשלמו בזמן המתנה בבקשה הראשונה בכל פעם. אם תותירו אותו פועל כדי להימנע מהמתנה, מחזור העבודה שלכם יצטמצם, מה שיעלה את העלות לטוקן. הפשרה הזו היא הסיבה המרכזית לקיומו של serverless inference.

אחסון והורדה. המשקולות גדולות. מודל 8B ב-16-bit הוא כ-16 GB, מודל 30B שעבר קוונטיזציה ל-4-bit הוא כ-18 GB, ומודל 30B ב-16-bit כלל לא נכנס לכרטיס של 24 GB. התקרה מורגשת במהירות בקצה העליון, שבו הרצת מודל קוד פתוח של טריליון פרמטרים כמו Kimi K3 משמעותה שהמשקולות לבדן חורגות מכל כרטיס בודד שניתן לשכור לפי שעה. אתם משלמים על הדיסק הזה מדי חודש, ומשלמים בזמן בכל בנייה מחדש. הריצו du -sh ~/.cache/huggingface/hub לאחר שבוע של ניסויים. התיקייה גדלה מהר מהצפוי, כיוון שכל קוונטיזציה שניסיתם פעם אחת עדיין נמצאת שם.

הזמן שלכם. גרסאות דרייבר ו-CUDA, שגיאות out-of-memory באורך הקשר שעבד אתמול, עדכון מודל שמשנה את ה-chat template. שום דבר מזה לא מופיע בנתון של עלות לטוקן, וכולו נגבה מהערבים שלכם. אם לא הגדרתם שרת כזה בעבר, כדאי לקרוא מה באמת מקבלים ב-GPU VPS לפני שמתחייבים לחודש שכירות.

פער האיכות. זו העלות הסמויה הגדולה ביותר והקשה ביותר לתמחור. מודל קוד פתוח של 8B אינו מודל חזיתי (frontier model). אם הוא זקוק לשלושה ניסיונות במקום שבו מודל חזיתי זקוק לאחד, המחיר האמיתי שלו לתשובה שימושית הוא פי שלושה מהערך בטבלה, והוא עשוי להיכשל במשימה בכל מקרה. בצעו השוואה על ה-prompts שלכם לפני שאתם משווים מחירים. עבור עומסי עבודה של סוכנים (agents), התשובה המקובלת היא ניתוב לפי רמת קושי ושמירה על טוקנים מקומיים זולים לעבודה מסיבית, שזהו עיקר העיסוק ב-שליטה בהוצאות סוכנים על גבי VPS.

חיובים ששכחתם. מופע GPU שעתי שעצרתם ממשיך לעיתים קרובות לחייב על האחסון המצורף ועל כתובת ה-IP השמורה. קראו את החשבונית, לא את דף המחירים.

מתי אירוח עצמי משתלם מסיבות שאינן מחיר

ארבעה מקרים שבהם החישוב הכלכלי אינו הגורם המכריע.

• נתונים שאינם יכולים לצאת משליטתך. אם כללי ציות אוסרים על שליחת טקסט לצד שלישי, המחיר לכל token אינו השאלה הרלוונטית.
• נפח עבודה גבוה וקבוע לפי לוח זמנים. משימת סיווג באצווה (batch) שרצה שש שעות בכל לילה נמצאת ב־25% ניצולת מעצם הגדרתה, והיא לעולם לא תפתיע אותך בחשבונית.
• מגבלות קצב (Rate limits). לכרטיס המסך שלך יש תור אחד והוא שייך לך בלבד.
• מודל שאף API לא מציע. אם דרוש לך fine-tune ספציפי, אין שירות אחר להשוות מולו.

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

FAQ

באיזה נפח טוקנים חודשי משתלם יותר לשכור GPU VPS מאשר להשתמש ב־API?

חלקו את העלות החודשית של ה־GPU במחיר ה־API למיליון טוקנים של פלט. כרטיס שעלותו 365 דולר לחודש, בהשוואה ל־API של מודל מוביל במחיר של 15.00 דולר למיליון, מגיע לנקודת איזון ב־24.3 מיליון טוקני פלט בחודש. בהשוואה למודל מסחרי קטן במחיר של 5.00 דולר, נקודת האיזון היא 73 מיליון. בהשוואה למודל בקוד פתוח שמתארח אצל ספק במחיר של 0.20 דולר, כרטיס בדרג ביניים לא יוכל לייצר מספיק טוקנים בחודש כדי להגיע לאיזון כלל.

מדוע API של מודל בקוד פתוח עולה פחות מה־GPU הפרטי שלי?

מכיוון שהמחיר שלו נקבע קרוב לעלות של GPU מנוצל במלואו, בעוד הכרטיס שלכם אינו מנוצל במלואו. ספק המשרת אלפי בקשות במקביל שומר על הציוד שלו קרוב לניצולת מלאה, ולכן הוא יכול למכור טוקנים קרוב לעלות השולית של הפקתם. הכרטיס שלכם עומד ללא שימוש ברוב שעות היממה, ואתם משלמים על שעות ההמתנה הללו. בשיעור ניצולת של 10%, העלות שלכם היא 3.47 דולר למיליון טוקני פלט, לעומת 0.20 דולר אצל הספק.

האם עליי לספור טוקני קלט בנוסף לטוקני פלט?

ספרו אותם אם ה־prompts שלכם ארוכים. ההשוואה כאן משתמשת בטוקני פלט בלבד, שהם המרכיב העיקרי בעבודה עם צ'אטים וסוכנים. הוספת קלט משנה את שני הצדדים. בצד ה־API, מדובר בשורה נפרדת וזולה יותר בחשבונית. בכרטיס שלכם, ה־prefill צורך זמן GPU, כך שהעלות כבר כלולה בנתון הטוקנים לשנייה שמדדתם. בצעו את המדידה עם אורכי ה־prompt האמיתיים שלכם, וכך שני הצדדים יישארו ברי השוואה.

איך מודדים את מספר הטוקנים לשנייה שהנוסחה דורשת?

הריצו את המודל בדרך שבה תשתמשו בו, ולאחר מכן קראו את קצב הייצור המצטבר תחת עומס עבודה אמיתי. עם Ollama, הפקודה ollama run <model> --verbose מדפיסה eval rate בטוקנים לשנייה, אך זהו זרם בודד והוא מציג נתון נמוך מזה של שרת בשיטת batch. עם vLLM, השרת הפעיל מתעד בלוגים את Avg generation throughput בזמן שהבקשות בתהליך, וזהו הנתון שבו יש להשתמש. עקבו במקביל אחר nvidia-smi. אם ניצולת ה־GPU אינה קרובה ל-100% במהלך הייצור, סימן שלא הגעתם עדיין לתקרת הביצועים.

האם כדאי לשכור GPU VPS מתחת ל-10% ניצולת?

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