Self-hosting uncensored models vs an NSFW AI API — the real math

"Why pay per call when a rented 4090 is $300 a month?" is the most reasonable objection to an NSFW AI API — and sometimes it's right. Here is the actual math, including the parts that don't fit in a tweet.

The sticker math

A rented consumer GPU (4090-class) runs roughly $0.35–0.50/hour — call it $250–370/month always-on. An A100-class card for larger models runs $1.10–1.80/hour — $800–1,300/month. A quantized 13B roleplay model on the 4090 serves a real product's chat traffic; a 70B wants the A100 or a multi-GPU rig.

Against flat credits (a completion is 1–3 credits ≈ 1–3¢, full table), the naive break-even on chat is:

Monthly completions	API cost (RP mini)	Self-host (4090)
100,000	~$830	~$300 + ops
30,000	~$250	~$300 + ops
10,000	~$83	~$300 + ops

Somewhere around 30–40k completions a month, the GPU line crosses under the API line. Case closed for self-hosting at scale? Only if the next four sections don't apply to you.

What the sticker math hides

Utilization is the whole game. The GPU bills 24/7; your users arrive in evening peaks. Real products see 15–35% utilization, which doubles or triples your effective per-call cost. The API's flat price is someone else's batching — you pay for output, not idle silicon. Failed generations even refund themselves.

Ops is a salary, not a footnote. Model updates, CUDA driver roulette, OOM crashes at your Saturday peak, quantization regressions after every fine-tune update. Budget real engineering-hours a month for a production inference stack — at contractor rates, that's your API bill right there before serving a single token.

Tuning is the invisible cost. Raw uncensored checkpoints repeat, drift and break the fourth wall under roleplay pressure — the failure modes are specific and fixing them (sampling profiles, anti-repetition, register control) is exactly the work you were hoping to skip.

Chat was the easy modality. The moment your product wants images, video, voice or transcription, self-hosting multiplies: separate models, separate VRAM, separate pipelines — plus NSFW-safe storage for outputs. One API key covering all six is the argument that usually ends the debate for small teams.

When self-hosting genuinely wins

Playing it straight, self-hosting is the right call when all four hold:

1. Steady, high, predictable volume (≥50k completions/month without evening cliffs);
2. One modality, one model you've already validated;
3. An engineer who wants to own inference (data-locality or compliance requirements count double);
4. Tolerance for a weekend of downtime while something recompiles.

That's a real profile — some of the best products in the space run this way. It just isn't most products, and it's almost never products at the start, when iteration speed is worth more than margin.

The hybrid that actually works

The pattern we see succeed: prototype and launch on the API (a key, 50 free credits, five-minute quickstart), instrument your real traffic, and revisit the math at your genuine volume — flat public prices make the API side of the spreadsheet a five-minute job. If chat volume alone crosses the line, move that workload to your own GPU and keep images, video and voice on the API. Statelessness makes the swap boring: it's one base URL per workload.

Infrastructure decisions deserve receipts, not vibes — run both columns on your own numbers.