Pricing pages are easy to argue with. Everyone's cost table has an asterisk, everyone's benchmark picks a flattering workload. So this post does something simpler: it takes a real, unedited week of production traffic that ran on the MicroDC.ai network — every job, every token, straight from the billing ledger — and asks one question. What would the exact same tokens have cost on AWS?
This is a comparison AWS makes unusually easy right now, because Bedrock hosts two of the three models in this workload natively — same weights, same names. No "comparable model" hand-waving needed for 90% of the bill.
The workload.
Seven days of production traffic, exactly as it ran. A mix of chat/completion calls on gpt-oss:20b, heavier reasoning on qwen3:32b, and image-understanding jobs on qwen2.5vl:7b:
| Model | Jobs | Tokens (in / out) |
|---|---|---|
gpt-oss:20b | 9,390 | 5.29M / 0.78M |
qwen3:32b | 4,446 | 2.74M / 1.54M |
qwen2.5vl:7b (vision) | 3,921 | 1.56M (text out) |
| Total | 17,757 | ~11.9M tokens |
MicroDC.ai billed this week at $0.21. That's the number on the ledger, not a projection — at the per-token rates in effect that week. (Marketplace rates fluctuate with capacity and demand; more on that in the caveats.)
The same tokens on Bedrock.
AWS Bedrock's published serverless rates, applied to the identical token counts:
| Model on Bedrock | Rate (per 1M in / out) | Cost | MicroDC.ai billed |
|---|---|---|---|
gpt-oss-20b (native) | $0.07 / $0.30 | $0.60 | $0.145 |
Qwen3-32B (native) | $0.15 / $0.62 | $1.37 | $0.009 |
| Nova Lite (vision stand-in) | $0.06 / $0.24 | ~$0.37 | $0.061 |
| Total | ≈ $2.35 | $0.21 |
Same tokens, same open models, roughly 11× the price. And the gap isn't driven by one cherry-picked row: the 20B model alone is 4× cheaper here, and the 32B — the model you'd actually reach for when quality matters — is where the difference gets silly.
What about just renting the GPUs?
The standard rebuttal is "serverless is the expensive way to buy AWS — self-host on EC2." Fair. We logged the actual busy compute behind this week's workload: 69.3 GPU-hours of real processing time across the three models.
On a g6e.xlarge (an NVIDIA L40S, the sensible on-demand choice for models this size, at ~$1.86/hr) that's ~$129 — and that figure counts only the hours the GPU was actually working. A real self-hosted deployment also pays for every idle hour between jobs, for the second instance you keep for availability, and for the engineer who babysits the whole thing. Empirically, dedicated-GPU deployments run at 15–40% utilization, which multiplies that headline number by 2–6× before anyone's salary enters the math.
That idle time is the entire story, and it's the thing a distributed network deletes. The GPUs running these jobs weren't reserved and waiting — they were existing hardware with spare cycles, matched to queued jobs the moment they had capacity. You pay for work performed, not for readiness.
The honest asterisks.
Real comparisons deserve real caveats, so here are ours:
- The vision row is an approximation.
qwen2.5vl:7bisn't on Bedrock, so we priced its output tokens at Amazon Nova Lite's rate — the closest small multimodal model. Image input tokens weren't tracked in this dataset, and Bedrock bills those too, so the true Bedrock figure for that row is somewhat higher than $0.37. The error favors AWS. - Reasoning tokens. gpt-oss models emit reasoning tokens that Bedrock bills as output. Our count uses the tokens as processed; heavy reasoning settings would widen the gap further.
- Latency is different. Bedrock is a real-time API; MicroDC.ai is an async queue (typically 30s–5min end-to-end). This workload — document processing and dataset enrichment — doesn't care. A user-facing chatbot would. Know which one you are.
- Prices move — on both sides. Bedrock rates are as published July 2026. Our per-token prices aren't fixed either: they fluctuate with network capacity and per-model demand, so the exact multiplier will drift over time. Current rates are always on the pricing page — that's the number to compare, not this snapshot.
Run this math on your bill.
The multiplier that matters is yours, not ours. The recipe is short: pull one week of your token counts per model from your provider's billing export, multiply by the per-million rates in the table above, and compare it to the same tokens at our rates. If a meaningful slice of your workload is batch-shaped — overnight processing, enrichment, extraction, anything where no human is staring at a spinner — the gap you compute will look a lot like the one above.
And if you'd rather test it than compute it: the same OpenAI-shaped code you're running today works against our compatible endpoint with a one-line base-URL change.