Skip to content
Talk to QCS
Home / Automation Cost Estimator

A working tool · Every figure is an estimate

What would AI automation cost you each month?

Choose the departments and workflows you would automate and set your monthly volumes. The estimator breaks each workflow into units of judgement and prices them three ways: on GPUs you rent or own, on Claude or OpenAI, and on DeepSeek, Kimi or hosted open-weight models.

Prices were looked up on 15 November 2026 and each one links to its source below. Token counts, throughput and staff time are stated assumptions that you can change. Nothing here is a quotation.

01 · Describe your business

Place your departments. Pick the work.

Enter your domain and industry for a starting point, or drag departments onto the canvas. Tick the workflows and set how many you handle in a month. To match your own process, edit a workflow's steps or build one from the units of judgement.

02 · Three routes, side by side

Your monthly estimate.

The running cost of each route: models or GPUs, a shared platform and the engineering time to keep it going. Your own staff's review time is added underneath each total.

Add a department above to see the estimate.

Shared platform is the ordinary server that runs everything around the models: the gateway that every model call passes through, the workflow engine that moves work from step to step (n8n, for example), and the logs that record each run. Every route needs it, so the same amount appears in all three. It does not include your ERP, which you already run, or backups, a test environment and disaster recovery. The default of $100 a month is our assumption for one small cloud server, not a quoted price, and you can change it below.

Engineering time is the hours a technical person spends keeping the automation working after it is live, costed at the engineer rate in the assumptions. It is not the work of building it, which is a one-off cost, and it is not your staff reviewing the output. It has two parts. Upkeep applies on every route: watching for failures, updating prompts and test cases, and re-testing when a provider changes or retires a model. Running your own GPUs adds a second part on the self-hosted route only: the serving software, drivers, security patches, capacity and being on call. The hours are our assumptions, and you can change them below.

The comparison assumes every route does the work equally well. That is not established: the same tier does not mean the same accuracy, and a smaller model may need more retries and more review. A test set built from your own documents settles it. This page compares three ways of running the automation; it does not show whether automating costs less than the way you do the work today, which depends on your current handling time. Figures are US dollars at list price (AED is pegged at 3.6725), before UAE VAT and before any volume or committed-use discount.

Cost by unit of judgement
03 · Whether self-hosting pays, and at what volume

The break-even volume.

API cost rises with every item. A GPU costs the same whether it is busy or idle. The chart scales your volumes up and down to show where the lines cross.

04 · Beyond the monthly bill

Why self-host when an API is cheaper?

At low volume an API nearly always costs less. Three reasons can still justify your own models, and none of them appears in the totals above.

01 / Data boundary

The data never leaves.

Prompts, documents and outputs stay on infrastructure you control. That matters where contracts, regulators or residency rules restrict where client and company data may be processed.

02 / Fine-tuning

The model learns your work.

A small open-weight model can be adapted on your own approved examples. For narrow, repetitive tasks that can let a smaller model do work that would otherwise need a larger one. Whether it does is settled by evaluation, not assumed.

03 / Independence

The terms are yours.

Open weights keep running if a vendor changes its prices, retires a model or changes its terms. This month's price lists show the risk: Moonshot closed its cheaper K2 models to new users on 31 October 2026.

The reasons run the other way too. The largest hosted models are more capable than any model that fits on one GPU, an API needs no on-call engineer, and a middle path exists: open-weight models from a hosted provider in a jurisdiction you accept. How we approach private AI →

05 · Assumptions

Change what does not fit you.

Every default below is our working assumption, not a measurement of your business. A pilot replaces them with real figures.

One-off costs

The monthly figures leave out the work of getting there. QCS charges $100 an hour for it. As a guide, automating one department, Sales for example, takes around 50 hours with AI assistance, which is about $5,000. The hours depend on the department, its workflows and your systems, and are agreed at scoping. The self-hosted route adds work that is scoped separately.

ItemApplies toEstimate
Workflow design, integration and the action gateEvery route, for each workflowWithin the 50 hours for each department
Test sets and evaluation, for each workflowEvery routeWithin the 50 hours for each department
Data-protection review and processing agreementEvery route; heavier when data leaves your boundaryWithin the 50 hours for each department
Serving stack, gateway and security hardeningSelf-hostedExtra; agreed at scoping
Fine-tuning a small model on your approved examplesSelf-hosted and hosted open-weight, where evaluation supports itExtra; agreed at scoping
Hardware purchaseOwned GPUs onlyFrom the GPUs your estimate needs

Not included on any route: management time, network egress, backups and disaster recovery beyond the shared platform, insurance, the cost of an error that reaches a customer or the ledger, migration away from a provider, and price changes after 15 November 2026. Each open-weight model's licence needs checking before use.

06 · What is being priced

Units of judgement, not one big model.

A workflow is a chain of small decisions. Each is done by a model, by ordinary code or by a person. Only model-backed units carry a model cost. Select a unit to see its size, tier and the model each route would use.

ModelCode, no model costPerson

1 · MatchingMid model

Links an outside description to the right internal record. Code shortlists candidates with search and embeddings. The model picks one and gives the reason.

Examples: Supplier item descriptions to item codes, bank lines to invoices, duplicate customers.

Assumed size: 2,500 input and 200 output tokens per line item. An estimate, not a measurement.

Models: Claude (Anthropic): Claude Sonnet 5.5; OpenAI: gpt-6.1-sol; DeepSeek: deepseek-flash; Kimi (Moonshot AI): kimi-k3.1-pro; Open-weight models, hosted: Qwen3.8-27B on DeepInfra (list price); self-hosted: Qwen3.8-27B (FP8) on a 48 GB GPU.

2 · ExtractionSmall model

Turns a document into structured fields. A model with a fixed output schema. The ERP validates every field.

Examples: Invoices, emailed purchase orders, RFQs, contracts, CVs, delivery notes.

Assumed size: 4,000 input and 800 output tokens per document. An estimate, not a measurement.

Models: Claude (Anthropic): Claude Haiku 5.5; OpenAI: gpt-6-luna; DeepSeek: deepseek-flash; Kimi (Moonshot AI): kimi-k3.1-pro; Open-weight models, hosted: Qwen3.5-9B on DeepInfra; self-hosted: Gemma 4 E4B (8-bit), fine-tuned on a 24 GB GPU.

3 · Classification and routingSmall model

Decides what something is and where it goes. A small model. Usually the cheapest unit.

Examples: Inbound email and tickets, expense categories, the language and intent of an enquiry.

Assumed size: 1,200 input and 50 output tokens per message. An estimate, not a measurement.

Models: Claude (Anthropic): Claude Haiku 5.5; OpenAI: gpt-6-luna; DeepSeek: deepseek-flash; Kimi (Moonshot AI): kimi-k3.1-pro; Open-weight models, hosted: Qwen3.5-9B on DeepInfra; self-hosted: Gemma 4 E4B (8-bit), fine-tuned on a 24 GB GPU.

4 · Normalisation and enrichmentSmall model

Cleans and completes records to a standard. Code handles units and formats. A model handles free text.

Examples: Units of measure, item naming, addresses, missing attributes.

Assumed size: 1,000 input and 200 output tokens per record. An estimate, not a measurement.

Models: Claude (Anthropic): Claude Haiku 5.5; OpenAI: gpt-6-luna; DeepSeek: deepseek-flash; Kimi (Moonshot AI): kimi-k3.1-pro; Open-weight models, hosted: Qwen3.5-9B on DeepInfra; self-hosted: Gemma 4 E4B (8-bit), fine-tuned on a 24 GB GPU.

5 · ValidationSmall model

Spots what is wrong or unusual. Mostly code: thresholds and duplicate checks. A model sees only the records code cannot settle.

Examples: Duplicate invoices, price deviations from the order, odd expense claims.

Assumed size: 1,500 input and 150 output tokens per record flagged by code. An estimate, not a measurement.

Models: Claude (Anthropic): Claude Haiku 5.5; OpenAI: gpt-6-luna; DeepSeek: deepseek-flash; Kimi (Moonshot AI): kimi-k3.1-pro; Open-weight models, hosted: Qwen3.5-9B on DeepInfra; self-hosted: Gemma 4 E4B (8-bit), fine-tuned on a 24 GB GPU.

6 · Comparison and evaluationTop model

Weighs options against criteria. A top-tier model drafts the comparison. A person decides. Output includes the model's reasoning tokens, which are billed as output.

Examples: Supplier quote comparison, contract terms against a standard, candidate against a role.

Assumed size: 12,000 input and 3,000 output tokens per comparison. An estimate, not a measurement.

Models: Claude (Anthropic): Claude Opus 5.5; OpenAI: gpt-6-astra; DeepSeek: deepseek-v4-pro; Kimi (Moonshot AI): kimi-k3.1-pro; Open-weight models, hosted: gpt-oss-120b on Groq, Together or Fireworks; self-hosted: gpt-oss-120b on an 80 GB GPU.

7 · Policy decisioningCode, no model

Applies rules to approve, reject or escalate. Code and people. The rules are written or configured, so the same facts always give the same answer. A model may gather the facts, but it does not decide, so there is no model cost.

Examples: Lead qualification against criteria you set, credit limits, discount approvals, leave and expense claims.

8 · ForecastingCode, no model

Predicts a number or a date. Statistical code. Language models are poor at numeric forecasting.

Examples: Demand, cash flow, delivery dates.

9 · Planning and schedulingCode, no model

Works out a feasible sequence under constraints. Solver code and people.

Examples: Reordering, shift rosters, delivery routes.

10 · Knowledge retrievalMid model

Answers from company records and documents, with sources. Search code finds the passages. A model answers and cites them.

Examples: What did we quote this client last year? Policy and SOP questions.

Assumed size: 6,000 input and 500 output tokens per question. An estimate, not a measurement.

Models: Claude (Anthropic): Claude Sonnet 5.5; OpenAI: gpt-6.1-sol; DeepSeek: deepseek-flash; Kimi (Moonshot AI): kimi-k3.1-pro; Open-weight models, hosted: Qwen3.8-27B on DeepInfra (list price); self-hosted: Qwen3.8-27B (FP8) on a 48 GB GPU.

11 · DraftingMid model

Produces a first version for review. A model drafts. A person reviews before anything is sent.

Examples: Quotations, customer replies, requirement documents, reports.

Assumed size: 5,000 input and 1,500 output tokens per document drafted. An estimate, not a measurement.

Models: Claude (Anthropic): Claude Sonnet 5.5; OpenAI: gpt-6.1-sol; DeepSeek: deepseek-flash; Kimi (Moonshot AI): kimi-k3.1-pro; Open-weight models, hosted: Qwen3.8-27B on DeepInfra (list price); self-hosted: Qwen3.8-27B (FP8) on a 48 GB GPU.

12 · Summarising and monitoringMid model

Condenses activity and flags what needs attention. Code detects. A model writes the digest.

Examples: Meeting notes to actions, daily exception digest, overdue items.

Assumed size: 10,000 input and 600 output tokens per digest or meeting. An estimate, not a measurement.

Models: Claude (Anthropic): Claude Sonnet 5.5; OpenAI: gpt-6.1-sol; DeepSeek: deepseek-flash; Kimi (Moonshot AI): kimi-k3.1-pro; Open-weight models, hosted: Qwen3.8-27B on DeepInfra (list price); self-hosted: Qwen3.8-27B (FP8) on a 48 GB GPU.

13 · Conversational intakeMid model

Gathers missing information from people. About six turns. The history is sent again on each turn, so input grows, and most of it can be read from the prompt cache.

Examples: Chasing a supplier for a missing spec, collecting customer requirements.

Assumed size: 15,000 input and 1,200 output tokens per conversation. An estimate, not a measurement.

Models: Claude (Anthropic): Claude Sonnet 5.5; OpenAI: gpt-6.1-sol; DeepSeek: deepseek-flash; Kimi (Moonshot AI): kimi-k3.1-pro; Open-weight models, hosted: Qwen3.8-27B on DeepInfra (list price); self-hosted: Qwen3.8-27B (FP8) on a 48 GB GPU.

14 · Visual understandingMid model

Reads images and drawings. A vision model. Current Claude and OpenAI models bill a full-page image at about 2,600 to 4,800 tokens, depending on resolution. Resizing photos before sending lowers this.

Examples: Item photo to catalogue item, damage on receipt, receipts.

Assumed size: 4,000 input and 200 output tokens per image. An estimate, not a measurement.

Models: Claude (Anthropic): Claude Sonnet 5.5; OpenAI: gpt-6.1-sol; DeepSeek: deepseek-flash; Kimi (Moonshot AI): kimi-k3.1-pro; Open-weight models, hosted: Qwen3.8-27B on DeepInfra (list price); self-hosted: Qwen3.8-27B (FP8) on a 48 GB GPU.

Sources for the size: Anthropic: vision (image tokens) · OpenAI: images and vision (image tokens)

15 · TranslationSmall model

Works across languages and vocabularies. Input and output are about the same size.

Examples: Multilingual descriptions, supplier jargon against internal terms.

Assumed size: 1,500 input and 1,500 output tokens per message. An estimate, not a measurement.

Models: Claude (Anthropic): Claude Haiku 5.5; OpenAI: gpt-6-luna; DeepSeek: deepseek-flash; Kimi (Moonshot AI): kimi-k3.1-pro; Open-weight models, hosted: Qwen3.5-9B on DeepInfra; self-hosted: Gemma 4 E4B (8-bit), fine-tuned on a 24 GB GPU.

16 · Follow-throughCode, no model

Carries a multi-step task across systems to completion. Workflow code such as n8n, calling the other units. Orchestration, not a model.

Examples: Reminders, retries, hand-offs, escalation when stuck.

Supporting steps

Document reading (OCR)Small model

Turns a scanned page into text, tables and layout. On an API a small vision model reads the page image: an A4 scan at 150 dpi is about 2,600 to 2,800 input tokens, and more at higher resolution. Self-hosted, a specialist OCR model does. Output of about 1,500 tokens a page matches the PaddleOCR-VL paper.

Examples: Scanned invoices, delivery notes, forms.

Assumed size: 3,000 input and 1,500 output tokens per scanned page. An estimate, not a measurement.

Models: Claude (Anthropic): Claude Haiku 5.5; OpenAI: gpt-6-luna; DeepSeek: deepseek-flash; Kimi (Moonshot AI): kimi-k3.1-pro; Open-weight models, hosted: Qwen3.5-9B on DeepInfra; self-hosted: PaddleOCR-VL on a 24 GB GPU.

Sources for the size: Anthropic: PDF support (tokens per page) · Anthropic: vision (image tokens) · OpenAI: images and vision (image tokens) · PaddleOCR-VL paper, table 13 (pages per second)

Speech to textPer audio minute

Transcribes calls and voice notes. Priced per audio minute on an API, and by GPU time when self-hosted.

Examples: Sales calls, WhatsApp voice notes.

Priced as: Claude (Anthropic): OpenAI gpt-transcribe, $0.0045 a minute; OpenAI: gpt-transcribe, $0.0045 a minute; DeepSeek: Whisper large-v3-turbo on Groq, $0.00067 a minute; Kimi (Moonshot AI): Whisper large-v3-turbo on Groq, $0.00067 a minute; Open-weight models, hosted: Whisper large-v3-turbo on Groq, $0.00067 a minute. Self-hosted: Whisper large-v3-turbo on a 24 GB GPU.

Input and output guardSmall model

Screens what comes in and what goes out. A small model, separate from the models that do the work. The size covers screening the input and the output of one item.

Examples: Prompt injection hidden in a document, unsafe output.

Assumed size: 2,000 input and 20 output tokens per item screened. An estimate, not a measurement.

Models: Claude (Anthropic): Claude Haiku 5.5; OpenAI: gpt-6-luna; DeepSeek: deepseek-flash; Kimi (Moonshot AI): kimi-k3.1-pro; Open-weight models, hosted: Qwen3.5-9B on DeepInfra; self-hosted: Qwen3Guard (smallest size) on a 24 GB GPU.

Agent with toolsTop model

Plans several steps and calls approved tools. The costliest unit: each tool call sends the whole history again, so most input can be read from the prompt cache. Sized for a short run of about eight model calls with reasoning kept low; a long conversation with many tool calls can use four times as much. The action gate in code still checks every write.

Examples: The website enquiry agent that logs a lead or opens a requirements session.

Assumed size: 50,000 input and 5,000 output tokens per run. An estimate, not a measurement.

Models: Claude (Anthropic): Claude Opus 5.5; OpenAI: gpt-6-astra; DeepSeek: deepseek-v4-pro; Kimi (Moonshot AI): kimi-k3.1-pro; Open-weight models, hosted: gpt-oss-120b on Groq, Together or Fireworks; self-hosted: gpt-oss-120b on an 80 GB GPU.

A person decidesPerson

Reviews the proposal and approves, amends or rejects. Staff time, shown separately. Assumed the same on every route; a weaker model may need more.

Examples: Posting an invoice, sending a quotation.

07 · Prices and sources

Looked up on 15 November 2026.

List prices in US dollars, before tax and volume discounts. Providers change prices often, so check the source before relying on a figure.

Model prices per million tokens

ProviderTierModelInputCached inputOutputSource
Claude (Anthropic)SmallClaude Haiku 5.5$0.10$0.01$0.50Anthropic: Claude API pricing
Claude (Anthropic)MidClaude Sonnet 5.5$2.00$0.1$10.00Anthropic: Claude API pricing
Claude (Anthropic)TopClaude Opus 5.5$4.00$0.2$20.00Anthropic: Claude API pricing
Claude (Anthropic)EmbeddingsOpenAI text-embedding-3-small$0.02OpenAI: API pricing
Claude (Anthropic)Speech to textOpenAI gpt-transcribe$0.0045 per audio minuteOpenAI: API pricing
OpenAISmallgpt-6-luna$0.10$0.01$0.50OpenAI: API pricing
OpenAIMidgpt-6.1-sol$2.00$0.1$10.00OpenAI: API pricing
OpenAITopgpt-6-astra$10.00$1.0$50.00OpenAI: API pricing
OpenAIEmbeddingstext-embedding-3-small$0.02OpenAI: API pricing
OpenAISpeech to textgpt-transcribe$0.0045 per audio minuteOpenAI: API pricing
DeepSeekSmalldeepseek-flash$0.30$0.006$1.20DeepSeek: models and pricing
DeepSeekMiddeepseek-flash$0.30$0.006$1.20DeepSeek: models and pricing
DeepSeekTopdeepseek-v4-pro$1.32$0.044$3.96DeepSeek: models and pricing
DeepSeekEmbeddingsBGE-M3 on DeepInfra$0.01DeepInfra: pricing
DeepSeekSpeech to textWhisper large-v3-turbo on Groq$0.00067 per audio minuteGroq: models and pricing
Kimi (Moonshot AI)Smallkimi-k3.1-pro$2.00$0.2$10.00Moonshot AI: Kimi API pricing (international)
Kimi (Moonshot AI)Midkimi-k3.1-pro$2.00$0.2$10.00Moonshot AI: Kimi API pricing (international)
Kimi (Moonshot AI)Topkimi-k3.1-pro$2.00$0.2$10.00Moonshot AI: Kimi API pricing (international)
Kimi (Moonshot AI)EmbeddingsBGE-M3 on DeepInfra$0.01DeepInfra: pricing
Kimi (Moonshot AI)Speech to textWhisper large-v3-turbo on Groq$0.00067 per audio minuteGroq: models and pricing
Open-weight models, hostedSmallQwen3.5-9B on DeepInfra$0.10$0.1$0.15DeepInfra: pricing
Open-weight models, hostedMidQwen3.8-27B on DeepInfra (list price)$0.20$0.05$2.50DeepInfra: pricing
Open-weight models, hostedTopgpt-oss-120b on Groq, Together or Fireworks$0.15$0.15$0.60Groq: models and pricing · Together AI: pricing · Fireworks AI: serverless pricing
Open-weight models, hostedEmbeddingsBGE-M3 on DeepInfra$0.01DeepInfra: pricing
Open-weight models, hostedSpeech to textWhisper large-v3-turbo on Groq$0.00067 per audio minuteGroq: models and pricing
  • Claude (Anthropic). Text token counts are raised by 30% for Claude, because Anthropic states its current tokenizer produces about 30% more tokens for the same text. Anthropic sells no embedding or speech-to-text model, so those two use OpenAI's prices. Haiku 5.5 costs five times more on prompts over 100,000 tokens; no unit here reaches that. Claude Fable 5.2 ($8 in, $40 out) sits above Opus and is not used. Batch API, 50% off.
  • OpenAI. Tiers follow OpenAI's own positioning: Astra as the flagship, Sol to balance intelligence and cost, Luna for high-volume work. Prices are for prompts up to 272,000 tokens. Batch API, 50% off.
  • DeepSeek. The table shows peak-hour prices; off-peak is half. Peak hours are 01:00 to 04:00 and 06:00 to 10:00 UTC on weekdays, about four hours of a ten-hour UAE working day, so 40% of live work is priced at peak. DeepSeek lists two models, so small and mid both use deepseek-flash. Embeddings and speech use hosted open-weight models. Off-peak hours are half price; work that can wait is moved off-peak.
  • Kimi (Moonshot AI). Moonshot's cheaper K2 models closed to new users on 31 Oct 2026, so every tier uses kimi-k3.1-pro. Prices exclude tax. We did not confirm that it accepts images, which document reading and visual understanding need. Batch, 40% off.
  • Open-weight models, hosted. The same open-weight models as the self-hosted route, run by an inference provider and billed per token. Gemma 4 E4B was not on offer from the providers checked, so the small tier uses Qwen3.5-9B; we did not confirm that it accepts images, which document reading needs. The same provider lists Gemma 4 31B at $0.20 in and $0.40 out, which would cut the mid-tier output price by five sixths. No batch discount assumed.

GPU rental, on demand, per GPU hour

ClassProviderGPUPer hourAlways on, per monthSource
24 GB GPURunPod Secure CloudRTX 4090$0.89$650RunPod: GPU pricing
24 GB GPURunPod Secure CloudL4$0.69$504RunPod: GPU pricing
24 GB GPURunPod Secure CloudRTX A5000$0.27$197RunPod: GPU pricing
24 GB GPUVast.ai (median)RTX 4090$0.50$368Vast.ai: live marketplace offers (median of verified single-GPU offers)
24 GB GPULambdaA10$1.29$942Lambda: cloud pricing (rates effective 16 Nov 2026)
24 GB GPUAWS, US Eastg6.xlarge (L4)$0.80$588AWS EC2 on-demand price list
24 GB GPUAWS, UAEg6.xlarge (L4)$0.99$721AWS EC2 on-demand price list
24 GB GPUAzure, East USNV36ads A10 v5$3.20$2,336Azure retail prices API
48 GB GPURunPod Secure CloudL40S$1.09$796RunPod: GPU pricing
48 GB GPURunPod Secure CloudRTX A6000$0.69$504RunPod: GPU pricing
48 GB GPUHyperstackRTX A6000$0.50$365Hyperstack: GPU pricing
48 GB GPUVast.ai (median)L40S$0.82$600Vast.ai: live marketplace offers (median of verified single-GPU offers)
48 GB GPULambdaRTX A6000$1.09$796Lambda: cloud pricing (rates effective 16 Nov 2026)
48 GB GPUCrusoeL40S$1.50$1,095Crusoe: cloud pricing
48 GB GPUVerdaL40S$2.02$1,473Verda (formerly DataCrunch): pricing
48 GB GPUAWS, US Eastg6e.xlarge (L40S)$1.86$1,359AWS EC2 on-demand price list
48 GB GPUAWS, UAEg6e.xlarge (L40S)$2.28$1,667AWS EC2 on-demand price list
80 GB GPURunPod Secure CloudA100 80 GB PCIe$2.09$1,526RunPod: GPU pricing
80 GB GPURunPod Secure CloudH100 PCIe$2.89$2,110RunPod: GPU pricing
80 GB GPUHyperstackA100 80 GB$1.35$986Hyperstack: GPU pricing
80 GB GPUHyperstackH100$2.50$1,825Hyperstack: GPU pricing
80 GB GPULambdaH100 PCIe$3.79$2,767Lambda: cloud pricing (rates effective 16 Nov 2026)
80 GB GPUVast.ai (median)RTX PRO 6000 96 GB$1.74$1,269Vast.ai: live marketplace offers (median of verified single-GPU offers)
80 GB GPUCrusoeH100 (rises to 4.50 on 1 Dec 2026)$3.90$2,847Crusoe: cloud pricing
80 GB GPUVerdaH100 SXM$5.24$3,826Verda (formerly DataCrunch): pricing
80 GB GPUCoreWeaveH100$6.16$4,493CoreWeave: pricing (8-GPU nodes, shown per GPU)
80 GB GPUCore42 (UAE)H100, 'from' price$2.50$1,825Core42 AI Cloud (UAE): 'from' prices
80 GB GPUAWS, US Eastp5.4xlarge (H100)$6.88$5,022AWS EC2 on-demand price list
80 GB GPUAzure, East USNC40ads H100 v5$6.98$5,095Azure retail prices API
80 GB GPUAzure, UAE NorthNC40ads H100 v5$9.98$7,285Azure retail prices API

A month is 730 hours. Each rented GPU also carries $20 a month for disk: 200 gb of disk per gpu at runpod's $0.10 per gb a month, applied to every price list. Committed and reserved prices are lower and are not shown. The Vast.ai figures are medians of live marketplace offers from independent hosts. The AWS and Azure rows name the instance type; the GPU inside is from the providers' instance documentation.

Owned hardware and sizing

ClassRunsCard priceRated powerThroughput we assume, and why
24 GB GPUsmall models, OCR, speech, embeddings and the guard$3,250 to $6,183
RTX 4090 24 GB on the resale market to RTX 5090 32 GB. gpupoet: resale price tracker
450 W
NVIDIA product pages: rated power
350 output and 5,000 input tokens a second. 8B models on a dedicated A10 24 GB reached 349 output tokens a second at 16 concurrent requests, and a classifier workload about 10,000 input tokens a second (TrueFoundry); we use 350 and half that input rate. When three or more of these models share the card, all rates are halved. Sharing five models needs the small model at 8-bit and leaves no room for long prompts, so it suits a pilot. OCR: PaddleOCR-VL ran 1.35 pages a second on an A100 under vLLM; we assume 0.5 on a 24 GB card. Speech: published real-time factors run from 46x (faster-whisper, 8 GB card) to 145x (A100); we assume 40x. Embeddings: BGE-M3 at about 97,000 tokens a second on an RTX A5000 (RunPod).
TrueFoundry: vLLM benchmark, 8B models on an A10 24 GB · PaddleOCR-VL paper, table 13 (pages per second) · faster-whisper README benchmarks · Open ASR Leaderboard paper (real-time factors) · RunPod: embedding throughput benchmark (BGE-M3) · Google: Gemma 4 memory requirements
48 GB GPUthe mid-tier model$7,072 to $8,965
RTX 6000 Ada to L40S, 48 GB. Reseller listings (CDW, Amazon, Saitech), read from search results
350 W
NVIDIA product pages: rated power
500 output and 4,000 input tokens a second. We found no published benchmark for a quantised 27B model on one 48 GB card. Nearest: Gemma 3 27B unquantised gave about 1,000 output tokens a second on two A100 40 GB cards with 100-token prompts (Database Mart), and 4.17 requests a second with 1,500-token prompts on one 80 GB-class card (Google Cloud), from which we derive about 830 output tokens a second. We assume 500 output and 4,000 input tokens a second on one L40S, which puts that 1,500-token case at about 1.3 requests a second, a third of the Google figure. With the model loaded, roughly 17 GB is left for requests in flight, which limits it to about six to ten concurrent 6,000-token prompts.
Database Mart: vLLM benchmark on two A100 40 GB (Gemma 3 27B) · Google Cloud: vLLM performance tuning (Gemma 3 27B sizing case) · Google: Gemma 4 memory requirements
80 GB GPUthe top-tier model$12,550 to $27,295
A100 80 GB, refurbished, to H100 80 GB at list price. Network Outlet: A100 80 GB, refurbished · Supermicro store: H100 80 GB PCIe (listed, out of stock)
350 W
NVIDIA product pages: rated power
1,500 output and 9,000 input tokens a second. gpt-oss-120b fits one 80 GB GPU (OpenAI model card). It gave about 1,500 output tokens a second at 50 concurrent requests on an RTX Pro 6000 96 GB with 100-token prompts (Database Mart), which we use as measured. With 8,000-token prompts an H100 handled about 5,900 to 9,000 input and output tokens a second, depending on the speed each user gets (InferenceX); our input rate is set so the formula stays below that.
OpenAI gpt-oss-120b model card (fits one 80 GB GPU) · Database Mart: vLLM benchmarks on RTX Pro 6000 and A100 · InferenceX: gpt-oss-120b on H100

Card prices are wide ranges because the market is unsettled: several come from resale trackers and reseller listings, not manufacturer price lists, and an owned-hardware figure needs a supplier quotation. Each GPU is assumed to need one host machine per GPU, from a desktop base to a rackmount base (BIZON starting prices), $3,788 to $9,415 (BIZON: workstation and rackmount base prices). Power is gpu rated power plus half again for the rest of the machine and cooling. Throughput figures are taken from, or derated from, the nearest published benchmarks, which were run on other hardware and workloads; input rates are our own derivation. GPUs are sized to run at 65% of these rates in the busiest hour. A consumer card such as an RTX 4090 may not be licensed or built for a server room, and a desktop host cannot cool a data-centre card.

Speed of each card against its class

The throughput figures above are for one reference card in each class. Rental lists and hardware prices name other cards, so each is counted at a multiple of the reference card's speed, and a slower card needs more hours or more cards for the same work.

ClassCardSpeed we assumeWhy
24 GB GPUA10 (reference)1×The card the throughput figures were measured on.
24 GB GPUL40.55×On the same llama.cpp test an L4 instance generated 53.5 tokens a second against 94.2 on an A10G instance (7B model), and 25.2 against 47.8 (14B): 0.53 to 0.57. Single requests, not a loaded server.
Spare Cores: llama.cpp speed on cloud servers (AWS g5.xlarge with an A10G, g6.xlarge with an L4)
24 GB GPURTX 40901.4×No publisher we found tested both cards. Two llama.cpp tests of 4-bit 7B and 8B models give 127.7 tokens a second on an RTX 4090 and 94.2 on an A10G, about 1.4. Chaining Runpod's vLLM figures through the L4 gives about 2. We use the lower figure.
XiongjieDai: GPU benchmarks on LLM inference (llama.cpp, May 2024) · Spare Cores: llama.cpp speed on cloud servers (AWS g5.xlarge with an A10G, g6.xlarge with an L4) · Runpod: 21 GPUs under vLLM, Qwen2.5-7B at one request a second (measured 15 Sep 2026)
24 GB GPURTX 50901.9×Published tests put an RTX 5090 at 1.35 to 1.66 times an RTX 4090: 101 against 61 tokens a second per user at light load (Runpod), and 1.35 under concurrent load (Trooper.ai). We use 1.4 times the RTX 4090 figure, rounded down.
Runpod: 21 GPUs under vLLM, Qwen2.5-7B at one request a second (measured 15 Sep 2026) · Trooper.ai: RTX 5090 against RTX 4090
48 GB GPUL40S (reference)1×The card the throughput figures are assumed for.
48 GB GPURTX A60000.9×44 against 48 tokens a second per user under vLLM at light load (Runpod), and 102 against 114 on llama.cpp (XiongjieDai): 0.90 to 0.92. Neither is a loaded-server test.
Runpod: 21 GPUs under vLLM, Qwen2.5-7B at one request a second (measured 15 Sep 2026) · XiongjieDai: GPU benchmarks on LLM inference (llama.cpp, May 2024)
48 GB GPURTX 6000 Ada1.15×58 against 48 tokens a second per user under vLLM at light load (Runpod), and 131 against 114 on llama.cpp (XiongjieDai): 1.15 to 1.21. We use the lower figure.
Runpod: 21 GPUs under vLLM, Qwen2.5-7B at one request a second (measured 15 Sep 2026) · XiongjieDai: GPU benchmarks on LLM inference (llama.cpp, May 2024)
80 GB GPUH100 (reference)1×The card the input rate was checked against. PCIe and SXM versions are counted the same, though Runpod measured the SXM version about half as fast again.
80 GB GPUA100 80 GB0.8×Under vLLM at batch 32 an A100 ran at 0.70 to 0.85 of an H100 on 7B and 8B models (Koyeb), and at 0.86 per user at light load (Runpod, PCIe cards). A model that nearly fills the card's memory, as the top-tier model does, may do worse.
Koyeb: GPU benchmarks (vLLM, batch 32) · Runpod: 21 GPUs under vLLM, Qwen2.5-7B at one request a second (measured 15 Sep 2026)
80 GB GPURTX PRO 60001×Our output rate was measured on this card. Published comparisons with an H100 disagree, from 0.82 (Runpod, light load) to above 1 (Database Mart), so we count it the same.
Runpod: 21 GPUs under vLLM, Qwen2.5-7B at one request a second (measured 15 Sep 2026) · Database Mart: vLLM benchmarks on RTX Pro 6000 and A100

These multiples are estimates from published tests of smaller models, mostly single requests or light load, not from tests of the models priced here on a loaded server. A pilot on the chosen card replaces them.

All sources, with the date each was read
  1. Anthropic: Claude API pricing. Read 2026-11-15.
  2. OpenAI: API pricing. Read 2026-11-15.
  3. DeepSeek: models and pricing. Read 2026-11-15.
  4. Moonshot AI: Kimi API pricing (international). Read 2026-11-15.
  5. DeepInfra: pricing. Read 2026-11-15.
  6. Groq: models and pricing. Read 2026-11-15.
  7. Together AI: pricing. Read 2026-11-15.
  8. Fireworks AI: serverless pricing. Read 2026-11-15.
  9. RunPod: GPU pricing. Read 2026-11-15.
  10. Lambda: cloud pricing (rates effective 16 Nov 2026). Read 2026-11-15.
  11. Vast.ai: live marketplace offers (median of verified single-GPU offers). Read 2026-11-15.
  12. Hyperstack: GPU pricing. Read 2026-11-15.
  13. Verda (formerly DataCrunch): pricing. Read 2026-11-15.
  14. Crusoe: cloud pricing. Read 2026-11-15.
  15. CoreWeave: pricing (8-GPU nodes, shown per GPU). Read 2026-11-15.
  16. AWS EC2 on-demand price list. Read 2026-11-15.
  17. Azure retail prices API. Read 2026-11-15.
  18. Core42 AI Cloud (UAE): 'from' prices. Read 2026-11-15.
  19. gpupoet: resale price tracker. Read 2026-11-15. Secondary source.
  20. Reseller listings (CDW, Amazon, Saitech), read from search results. Read 2026-11-15. Secondary source.
  21. Network Outlet: A100 80 GB, refurbished. Read 2026-11-15.
  22. Supermicro store: H100 80 GB PCIe (listed, out of stock). Read 2026-11-15.
  23. BIZON: workstation and rackmount base prices. Read 2026-11-15.
  24. NVIDIA product pages: rated power. Read 2026-11-15.
  25. DEWA slab tariff (read from search results) and fuel surcharge. Read 2026-11-15. Secondary source.
  26. TrueFoundry: vLLM benchmark, 8B models on an A10 24 GB. Read 2026-11-15. Published benchmark, not our own test.
  27. Database Mart: vLLM benchmarks on RTX Pro 6000 and A100. Read 2026-11-15. Published benchmark, not our own test.
  28. Database Mart: vLLM benchmark on two A100 40 GB (Gemma 3 27B). Read 2026-11-15. Published benchmark, not our own test.
  29. Anthropic: prompt caching (write and read multipliers). Read 2026-11-15.
  30. OpenAI: images and vision (image tokens). Read 2026-11-15.
  31. Google Cloud: vLLM performance tuning (Gemma 3 27B sizing case). Read 2026-11-15. Published benchmark, not our own test.
  32. InferenceX: gpt-oss-120b on H100. Read 2026-11-15. Published benchmark, not our own test.
  33. PaddleOCR-VL paper, table 13 (pages per second). Read 2026-11-15. Published benchmark, not our own test.
  34. Open ASR Leaderboard paper (real-time factors). Read 2026-11-15. Published benchmark, not our own test.
  35. faster-whisper README benchmarks. Read 2026-11-15. Published benchmark, not our own test.
  36. RunPod: embedding throughput benchmark (BGE-M3). Read 2026-11-15. Published benchmark, not our own test.
  37. OpenAI gpt-oss-120b model card (fits one 80 GB GPU). Read 2026-11-15.
  38. Google: Gemma 4 memory requirements. Read 2026-11-15.
  39. Anthropic: PDF support (tokens per page). Read 2026-11-15.
  40. Anthropic: vision (image tokens). Read 2026-11-15.
  41. Cast AI: 2026 State of Kubernetes Optimization (average GPU utilisation 5%). Read 2026-11-15. Secondary source.
  42. Spare Cores: llama.cpp speed on cloud servers (AWS g5.xlarge with an A10G, g6.xlarge with an L4). Read 2026-11-16. Published benchmark, not our own test.
  43. Runpod: 21 GPUs under vLLM, Qwen2.5-7B at one request a second (measured 15 Sep 2026). Read 2026-11-16. Published benchmark, not our own test.
  44. XiongjieDai: GPU benchmarks on LLM inference (llama.cpp, May 2024). Read 2026-11-16. Published benchmark, not our own test.
  45. Koyeb: GPU benchmarks (vLLM, batch 32). Read 2026-11-16. Published benchmark, not our own test.
  46. Trooper.ai: RTX 5090 against RTX 4090. Read 2026-11-16. Published benchmark, not our own test.
  47. JobXDubai: MLOps salaries in the UAE, 2026. Read 2026-11-15. Secondary source.
08 · Send it to us

Have QCS check your estimate.

We receive the workflows, volumes and totals shown above, and reply with what a scoped pilot would measure. QCS builds and runs these systems, private AI included, so read this as a supplier's estimate and test it.

What we will receive
Add a department to build your estimate.

We also receive a link that reopens this estimate exactly as you built it. Nothing is sent until you press the button.

An estimate is a starting point. A pilot measures it.