If your dev stack already lives on a VPS provider, the “who runs the model” question has quietly gained a third answer. You used to pick between renting a GPU and running inference yourself, or calling a hosted API like OpenAI. Vultr now sells Serverless Inference on the same account as your droplets - managed LLM inference billed per token, with compute auto-provisioned and scaled as requests arrive, no GPU infrastructure to manage.[1][2]
This page compares the three paths for a team that already operates VPS infrastructure: Vultr Serverless Inference (pay-per-token, no infra), a rented GPU instance you manage yourself (Vultr Cloud GPU or DigitalOcean GPU Droplet), and the OpenAI API (ready-made, but vendor-locked). Every number below is read from the providers’ own pricing pages on the day this was written - there are no invented benchmarks here.
What Vultr Serverless Inference actually is
Vultr describes it as inference “on demand with compute resources automatically provisioned and scaled as requests arrive, without managing GPU infrastructure."[2] Concretely: you get an API key, an OpenAI-compatible base URL, and a catalog of models. You swap out your inference URL, point it at Vultr’s endpoint, and pay for tokens used rather than for an idle GPU.[3]
The billing model is the whole point. There is no hourly GPU charge sitting on your invoice whether you use it or not - you pay per million input and output tokens for chat models, and per megapixel for image models.[1]
The price table, straight from Vultr’s pricing page
Vultr publishes the following chat/prompt model rates (per 1M input / 1M output tokens) on its pricing page as of the day this was written:[1]
| Model | Input /M | Output /M |
|---|---|---|
| deepseek-ai/DeepSeek-V4-Flash | $0.30 | $1.00 |
| moonshotai/Kimi-K2.6 | $0.30 | $1.20 |
| MiniMaxAI/MiniMax-M2.7 | $0.30 | $1.20 |
| XiaomiMiMo/MiMo-V2.5-Pro | $0.55 | $1.65 |
| nvidia/DeepSeek-V3.2-NVFP4 | $0.55 | $1.65 |
| nvidia/Nemotron-3-Nano-Omni-30B-A3B-Reasoning-BF16 | $0.13 | $0.38 |
| nvidia/Nemotron-Cascade-2-30B-A3B | $0.15 | $0.60 |
| nvidia/Nemotron-3.5-Content-Safety | $0.10 | $0.30 |
| nvidia/Llama-3.1-Nemotron-Safety-Guard-8B-v3 | $0.01 | $0.01 |
| zai-org/GLM-5.1-FP8 | $0.85 | $3.10 |
Image generation models are billed per megapixel instead of per token: flux.1-dev and stable-diffusion-3.5-large-turbo at $0.02/MP, flux.1-schnell and stable-diffusion-3.5-medium at $0.01/MP.[1]
One thing worth flagging: the pricing page and Vultr’s docs overview don’t always name the same catalog. The docs overview currently lists models like “DeepSeek V4.1 Flash, GLM 5.2, MiniMax M3” while the pricing page lists DeepSeek-V4-Flash, GLM-5.1-FP8 and MiniMax-M2.7.[1][2] The pricing page is the authoritative source for prices - but the model list changes, so check the current catalog in the Vultr Console before you build against a specific model name.[2]
Path two: rent a GPU and run it yourself
The self-hosted route means renting GPU compute and running a serving stack (vLLM, TGI, or similar) yourself. You get full control and no per-token markup, but you own the whole lifecycle: provisioning, model loading, autoscaling, updates, and the risk of an idle GPU you’re still paying for.
Vultr’s Cloud GPU is billed on-demand, hourly:[4]
| GPU | Price /GPU/hr |
|---|---|
| NVIDIA L40S (48 GB) | $1.671 |
| NVIDIA HGX H100 | $2.300 |
| AMD MI300X | $1.850 |
| AMD MI325X | $2.000 |
| AMD MI355X | $2.590 |
| NVIDIA GH200 | $1.990 |
| NVIDIA HGX B200 | $3.500 |
The L40S is the natural entry point for self-hosting a 30–70B-class model: a single-GPU L40S instance comes with 48 GB of GPU RAM, 16 vCPUs and 180 GB of system RAM.[4]
DigitalOcean’s GPU Droplets give you a comparable on-demand menu, billed per second with a 5-minute minimum - and note that a powered-off GPU Droplet is still billed, because the disk, CPU, RAM and IP stay reserved until you destroy the instance:[5]
| GPU | On-demand /GPU/hr |
|---|---|
| NVIDIA RTX 4000 Ada (20 GB) | $0.76 |
| NVIDIA RTX 6000 Ada (48 GB) | $1.57 |
| NVIDIA L40S (48 GB) | $1.57 |
| AMD MI300X (192 GB) | $2.59 |
| AMD MI325X (256 GB) | $3.80 |
| NVIDIA HGX H100 (80 GB) | $4.41 |
| NVIDIA HGX H200 (141 GB) | $4.47 |
The cheaper DigitalOcean cards (RTX 4000 Ada at $0.76/hr, RTX 6000 Ada / L40S at $1.57/hr) are the realistic self-hosted entry points for a small dev team.[5]
Path three: the OpenAI API
The OpenAI API is the “just works” option: no infrastructure at all, a mature SDK, and models that are consistently near the frontier. The trade-off is vendor lock-in and, on the flagship models, a price premium per token.
OpenAI’s published standard rates (per 1M tokens) as of the day this was written:[6]
| Model | Input /M | Cached input /M | Output /M |
|---|---|---|---|
| gpt-6-astra | $10.00 | $1.00 | $50.00 |
| gpt-5.6-sol | $4.00 | $0.40 | $20.00 |
| gpt-5.6-terra | $2.00 | $0.20 | $12.00 |
| gpt-5.6-luna | $0.20 | $0.02 | $1.20 |
The gap to the Vultr catalog is stark on output tokens: OpenAI’s flagship, gpt-6-astra, runs $50.00 per million output tokens, and even the mid-tier gpt-5.6-terra is $12.00 per million, while Vultr’s DeepSeek-V4-Flash is $1.00 per million - a 50× spread on the output side alone.[1][6] That is not a benchmark; it is a read straight off both pricing pages.
The cost model: when does each one win?
We are not going to invent throughput numbers - we haven’t benchmarked these on our own accounts, and per the site’s sourcing standard, no measurement means no number. But the shape of the cost curve follows directly from the published prices, and that’s enough to reason about it.
Serverless Inference wins when your traffic is bursty, low, or unpredictable. You pay per token, so an app that gets a handful of requests an hour costs cents. There is no GPU sitting idle on the invoice. The flip side is that per-token pricing is a markup over raw GPU cost - Vultr has to cover provisioning and scaling - so at sustained high volume the per-token rate will eventually exceed what you’d pay to keep a GPU warm.
Self-hosted GPU wins when utilization is high and steady. If a model is running constantly, the economics invert: a Vultr L40S at $1.671/hr is roughly $1,200/month if it runs around the clock, but that buys an unlimited token budget. The break-even point against per-token pricing depends entirely on how many tokens you actually generate - which is exactly why you shouldn’t guess it. The real cost of this path is operational: you need the skill to run and babysit a serving stack, and you pay for the GPU even in the hours it’s idle.[4]
OpenAI API wins when you value zero-ops and frontier quality above unit cost. You pay a premium per token, but you never think about GPUs, scaling, or model serving. For a dev team whose time is the scarce resource, that premium is often the cheapest option in practice - even though it’s the most expensive in raw dollars per token.[6]
The practical heuristic, in plain terms: low or spiky volume → Serverless Inference; high sustained volume and you have the ops skill → self-hosted GPU; you want zero maintenance and don’t mind the price → OpenAI API. The exact crossover point is a function of your token volume and your hourly cost of engineering time, and it’s worth computing once you have real usage data.
Non-price factors that matter as much as price
- Latency. Serverless inference pays for scaling, which can mean cold-start latency on the first request of a burst. A warm self-hosted GPU has no cold start. For interactive chat this usually doesn’t matter; for tight request budgets it might.[2]
- Data locality and compliance. Self-hosting on Vultr or DigitalOcean keeps your data on infrastructure you control. With a managed API you’re sending prompts to a third party’s endpoint - a real consideration if you handle customer data.[3][5]
- Model choice and control. Self-hosting lets you run any open-weight model, fine-tune it, and pin a version. Serverless and hosted APIs constrain you to their catalog - and as shown above, that catalog can shift under you.[1][2]
- Vendor lock-in. OpenAI’s API is the deepest lock-in: SDKs, tooling, and models all assume it. Vultr’s Serverless Inference is OpenAI-compatible at the API level, so switching is a URL-and-key change rather than a rewrite.[3]
- Operational burden. Self-hosting is the only path where you own uptime. If a model serving process crashes at 3 a.m., that’s on you. Serverless and hosted APIs put that on the provider.
Which should your dev stack pick?
There is no universal winner - it depends on your volume and your team. But for a team that already runs VPS infrastructure, a sensible default is:
- Start with Vultr Serverless Inference for the first version of an AI feature. It’s on the account you already have, it’s OpenAI-compatible so you can switch later without a rewrite, and the per-token cost of a low-traffic app is trivial.[1][3]
- Move to a self-hosted GPU only once a model is earning its keep at sustained volume, and you have someone who can run a serving stack. The L40S on Vultr or the RTX 4000 Ada / L40S on DigitalOcean are the realistic entry points.[4][5]
- Keep OpenAI in the picture when you specifically need frontier model quality or zero maintenance, and accept that you’re paying a per-token premium and taking on lock-in.[6]
The honest answer to “which is cheapest” is: it depends on your token volume, and you can’t know that until you measure it. What you can know today, from the pricing pages, is which path is cheapest at the extremes - and that’s enough to make the first move.
Before you commit capacity anywhere, our VPS deployment guide covers right-sizing a box, and the hosting reviews round up where the providers differ. If you’re weighing managed inference against a plain VPS for the rest of the stack, our VPS vs shared hosting comparison is a good starting point.
Prices move and differ by datacenter and currency - the figures above are the official rates on the day this was written, and should be re-checked on each provider’s own pricing page before you budget.
Sources
- Vultr - Pricing page, “Serverless Inference” section (chat/prompt model per-token rates, image model per-megapixel rates). https://www.vultr.com/pricing/ - checked 2026-10-04
- Vultr Docs - “Serverless Inference: On-Demand AI Model Inference” (on-demand provisioning/scaling, no GPU infra management, model catalog, RAG chat use cases). https://docs.vultr.com/product-overviews/serverless-inference - checked 2026-10-04
- Vultr Docs - Serverless Inference FAQ (OpenAI-compatible base URL swap, usage/cost monitoring in Console, API key). https://docs.vultr.com/products/compute/serverless-inference/faq - checked 2026-10-04
- Vultr - Pricing page, “Cloud GPU” section (on-demand hourly GPU rates; L40S 48 GB config). https://www.vultr.com/pricing/ - checked 2026-10-04
- DigitalOcean - GPU Droplets pricing (on-demand per-GPU-hour rates; per-second billing with 5-minute minimum; powered-off instances still billed). https://www.digitalocean.com/pricing/gpu-droplets - checked 2026-10-04
- OpenAI - API pricing (GPT-6 Astra / GPT-5.6 Sol / GPT-5.6 Terra / GPT-5.6 Luna standard per-token rates). https://platform.openai.com/docs/pricing - checked 2026-10-04