This needs JavaScript. Every possible answer is shown below.
Self-host — this is the real reason
Data that legally cannot leave is the one case where the arithmetic doesn't decide it. No API pricing beats a compliance requirement. Check whether a private cloud deployment satisfies your obligation first, since it's far less operational work than running GPUs.
Watch out: Read the licence before you build. Several prominent "open" models carry user thresholds or use restrictions that rule out exactly the commercial case you had in mind.
Self-host, small and quantized
Offline is a genuine constraint an API cannot satisfy. A quantized small model runs on modest hardware, and for a narrow task it will often beat a large general one anyway.
Watch out: Quantization loss isn't evenly spread — conversation holds up better than code or arithmetic, and an unchanged perplexity score hides exactly the failures you'll notice.
Abstract the provider instead
Lock-in is a real risk and self-hosting is an expensive way to address it. Put your own interface in front of the API so switching is a config change. You get most of the independence for a fraction of the work, and you keep the better model.
Watch out: No abstraction removes the strategic exposure entirely. But operating GPUs to avoid a migration you may never run is buying insurance more expensive than the risk.
Use the API
At this volume, self-hosting costs more — not in GPU rental, in your time. Infrastructure, scaling, updates, uptime and evaluation are a team's work. The break-even arrives at volumes most products never reach.
Watch out: Re-check when volume grows an order of magnitude. And abstract the provider now, while it's easy.
Right-size before you rebuild
Most teams run the flagship because it's the default, on tasks the cheap tier handles. Switching tiers is a config change and often cuts the bill by most of it. Do that before buying hardware.
Watch out: Test on your actual task, not a benchmark. The gap between tiers is task-specific and the published numbers won't tell you where yours sits.
Now the arithmetic might favour self-hosting
High sustained volume on a right-sized model is where the crossover genuinely lives. Inference is where the money goes at scale, and at some point owning the hardware wins.
Watch out: Count the whole cost: GPUs, scaling, updates, uptime, and evaluation — which was the provider's job and is now yours. That last one is the most underestimated line in the budget.