⚡LLM integration cost is two numbers, not one
Every LLM integration has a build cost — the engineering to make a feature reliable — and a run cost, the inference bill that arrives every month forever after. Quotes that blend the two into one number hide the one that recurs.
The build cost tiers below assume the work is done properly: prompt and context engineering, structured outputs, error and fallback paths, an evaluation set, and cost ceilings enforced server-side. Calling the API is the trivial part; everything around it is the engagement.
See our LLM integration services
| Scope | Build cost | Timeline | What is included |
|---|---|---|---|
| Single well-scoped feature | $8,000 – $25,000 | 3–6 weeks | One workflow (drafting, extraction, classification), eval set, basic cost controls |
| Production feature | $25,000 – $60,000 | 6–10 weeks | Guardrails, fallback models, caching, tracing, per-user spend ceilings, scored evaluation |
| Multi-feature LLM platform | $60,000 – $150,000+ | 3–6 months | Shared model layer, routing between models, org-wide observability, fine-tuning pipeline |
| Run cost | Route-dependent — see below | Ongoing | API tokens, or fine-tuned inference premium, or GPU infrastructure |
🔀The three routes: API, fine-tuning, self-hosting
The run-cost decision is really three different products. A hosted API rents capability per token with zero operations. A fine-tuned hosted model trains a provider's model on your examples and charges a premium on inference. Self-hosting runs open-weight models on GPUs you rent or own, converting a per-token variable cost into a mostly fixed infrastructure cost.
| Dimension | Hosted API | Fine-tuned hosted model | Self-hosted open weights |
|---|---|---|---|
| Upfront engineering | Lowest | Dataset curation is the real cost | Highest — serving, scaling, monitoring |
| Cost structure | Per token, pure variable | Per token with a premium on inference | Mostly fixed GPU cost + ops time |
| Data privacy | Enterprise terms: no training, defined retention | Same, plus your data shapes the weights | Data never leaves your infrastructure |
| Quality ceiling | Frontier models available on day one | Best for format, tone and narrow tasks | Strong open models, behind the frontier on the hardest tasks |
| Ops burden | None | Low | Real — budget 0.25 to 1 platform-engineer FTE |
| Best for | Most teams, most of the time | High-volume narrow tasks with stable format | Data-residency requirements or sustained high volume |
💵Route 1: hosted API economics
Published list pricing for the Claude family, per million tokens, as of July 2026 — the family we deploy most; the arithmetic is identical against any provider's rate card, and you should check the current pricing page before budgeting because these rates move.
The full cost-per-task model with retry and caching arithmetic
Worked example — classification
Two hundred million input tokens a month through the small model is roughly $200 of input plus output at five times that rate. Classification workloads are cheap enough that engineering time dwarfs the invoice.
Worked example — generation
A drafting feature producing 30 million output tokens a month on the mid-tier model costs about $450 of output plus its input. Output tokens are the expensive direction — features that write long text cost roughly 5× what features that only read cost.
The multiplier nobody budgets
Retry loops. A feature that succeeds first-try 70% of the time does not cost 1.43× the happy path — failures happen late, after most of the tokens are spent. Model cost per successful outcome, not per call.
| Model | Input / 1M tokens | Output / 1M tokens | Role in a typical integration |
|---|---|---|---|
| Claude Haiku 4.5 | $1.00 | $5.00 | Classification, routing, extraction |
| Claude Sonnet 5 | $3.00 | $15.00 | The workhorse — most production turns |
| Claude Opus 5 | $5.00 | $25.00 | Hard reasoning, drafting, review |
🎛️Route 2: fine-tuning economics
Fine-tuning changes how a model behaves, not what it knows. If your problem is missing information, that is a retrieval problem and fine-tuning will not fix it. If your problem is shape — the model has the knowledge but produces the wrong format, tone or structure on a narrow, repeated task — fine-tuning is often the cheapest permanent fix.
Published fine-tuning rates for mainstream hosted models run from a few dollars to around $25 per million training tokens depending on the model, plus a per-token premium on inference for the tuned model — check the provider's current page, as these change. The number that actually dominates, though, is dataset curation: several hundred to a few thousand high-quality input-output examples, each reviewed by someone who knows what correct looks like. That review time routinely costs more than the training run itself.
The break-even case: if a base model needs a 2,000-token system prompt with few-shot examples to hit your format bar, and a fine-tuned small model hits it with a 100-token prompt, the fine-tuned model wins on every call. At millions of calls a month, the training cost pays back quickly. At a few thousand calls, prompt engineering is cheaper and more flexible.
🖥️Route 3: self-hosting economics
Self-hosting converts a per-token invoice into GPU infrastructure. On-demand H100-class GPUs run roughly $2 to $8 per GPU-hour depending on provider and commitment level; a quantised 7–8B open model serves comfortably from a single mid-range card, while a 70B-class model at full precision needs roughly two H100s. Serving stacks like vLLM handle continuous batching, which is what makes the economics work at all.
The break-even question is utilisation. A GPU serving tokens around the clock at high occupancy frequently undercuts API pricing on the same workload. The same GPU idling between bursts costs more than the API would have — you pay for the hour, not the token. Self-hosting wins on sustained, predictable volume and on hard data-residency requirements; it loses on bursty traffic and small workloads, and it always carries an operations cost in platform-engineering time for scaling, monitoring and model upgrades.
The pattern we recommend: start on a hosted API behind an abstraction layer, measure your real token shape for a quarter, then self-host only the workload slices where the utilisation math clearly wins — if any do.