How much does quantum computing cost? QPU prices, billing models and worked examples
Quantum computers are sold by the shot, by the gate-shot, by the second of QPU time, in credits or by subscription, and the same chip costs different amounts depending on the cloud you reach it through. At list prices on 4 November 2026, one run of a small circuit for a thousand shots costs from under a dollar on the cheapest per-shot route to around two hundred dollars where a per-run minimum applies. What makes a project expensive is the number of circuits: a training loop or a kernel matrix runs thousands of them, so count them, and simulate first.
Updated
The short answer
- Cheapest published per-shot route
- Rigetti Cepheus on Amazon Braket, at USD 0.30 per task plus USD 0.000425 per shot[1], so one task of 1,000 shots costs US dollars.
- IBM Quantum
- Pay-As-You-Go starts at USD 96 per minute[6] of QPU time, billed per second. The free Open Plan gives up to 10 minutes of runtime per month[6].
- Per-run minimums
- IonQ Forte on Azure Quantum bills at least USD 168.195 per program execution[5] with error mitigation on, which is the default. On Braket, error mitigation on IonQ needs at least 2,500 shots per task[1].
- Not published
- The US dollar price of a Quantinuum HQC (pay as you go goes through Quantinuum's sales[5]) and IonQ's direct rates, which depend on the access agreement[10].
- What decides the bill
- The number of circuits times the number of shots, then the route. A training loop or a kernel matrix is thousands of circuits, so it costs thousands of dollars or more on hardware and nothing on a laptop simulator.
- Prices checked
- 4 November 2026, on each vendor's own pricing page. Every figure below names its source.
How quantum computing is billed
There is no single price for a quantum computer. The same chip is sold on different terms by different marketplaces, and vendors use the same words for different things: a Braket task is a submission that can hold many circuits, an Azure gate-shot is gates times shots, and a Quantinuum HQC is a credit computed from a formula. Six billing models are in use, and each one turns a workload into a bill in its own way.
The billing models
| Model | Who sells this way | What the bill follows | What it means for a workload |
|---|---|---|---|
| Per task plus per shot | Amazon Braket; Open Quantum, a reseller | A fee per submitted task and a price per shot. On Braket the per-shot price does not change with the number or type of gates[1]. | Depth is free and circuits are not: each task pays the fee again. A Braket program set packs up to 100 circuits[2] into one task, which pays one fee. |
| Per gate-shot, with a minimum per run | IonQ on Azure Quantum | One- and two-qubit gates times shots, two-qubit gates priced higher, and a floor per program execution[5]. | A small circuit always costs the floor. Above it, wider and deeper circuits cost more per shot. |
| Credits from a published formula | Quantinuum, on Azure Quantum and directly | Hardware Quantum Credits: , with and the one- and two-qubit gates, the state preparations and measurements, and the shots[11]. | You can compute the credits a job uses before you run it. The dollar price of a credit is not published, so your contract sets it. |
| QPU time | IBM Quantum and IQM Resonance, per second; Rigetti on Azure, per 10-millisecond increment[5]; Pasqal on Azure, per QPU-hour | On IBM, the time the QPU is locked for your job[7]. | Shots and a fixed overhead per job drive it. Circuit depth matters less than the pause between shots, as the section on drivers below shows. |
| Reserved time and subscriptions | Braket Direct, IBM Flex and Premium, IonQ and Quantinuum plans on Azure Quantum, IQM Skip-the-queue | Hours or months you hold, whether you use them or not. | Cheaper per unit only if you keep the device busy. |
| Free tiers and research credits | IBM Open Plan, IQM Starter, Braket's simulator free tier, AWS Cloud Credit for Research, Open Quantum sign-up credits | An allowance, not a rate. | Enough to learn and to run a few small circuits. Not enough for a training run. |
Quantum computing prices by vendor and route, as of 4 November 2026
On-demand list prices for gate-based and analog QPUs that publish them, with the minimum each route charges. A price is quoted as the vendor's page shows it; where a vendor does not publish one, the row says so.
| QPU | Route | Billing model | List price | Minimum or floor |
|---|---|---|---|---|
| IonQ Forte | Amazon Braket | Per task plus per shot | USD 0.30 per task + USD 0.08 per shot[1] | 2,500 shots per task with error mitigation[1] |
| AQT IBEX-Q1 | Amazon Braket | Per task plus per shot | USD 0.30 per task + USD 0.0235 per shot[1] | None listed |
| IQM Emerald | Amazon Braket | Per task plus per shot | USD 0.30 per task + USD 0.0016 per shot[1] | None listed |
| IQM Garnet | Amazon Braket | Per task plus per shot | USD 0.30 per task + USD 0.00145 per shot[1] | None listed |
| Rigetti Cepheus | Amazon Braket | Per task plus per shot | USD 0.30 per task + USD 0.000425 per shot[1] | None listed |
| QuEra Aquila (analog) | Amazon Braket | Per task plus per shot | USD 0.30 per task + USD 0.01 per shot[1] | None listed |
| IonQ Forte, Forte Enterprise | Open Quantum, public tier | Per task plus per shot | USD 0.18 per task + USD 0.048 per shot[12] | None listed |
| IonQ Forte 1, Forte Enterprise 1 | Azure Quantum | Per gate-shot | USD 0.0001645 per one-qubit gate-shot, USD 0.001121 per two-qubit gate-shot[5] | USD 168.195 per program execution with error mitigation on (the default), USD 25.7899 with it off[5] |
| IonQ Aria 1 | Azure Quantum | Per gate-shot | USD 0.000220 per one-qubit gate-shot, USD 0.000975 per two-qubit gate-shot[5] | USD 97.50 per program execution with error mitigation on, USD 12.4166 with it off[5] |
| Quantinuum System Model H2 | Azure Quantum, pay as you go | HQC credits | Per HQC; price from Quantinuum sales[5] | 5 HQC per job[11], the formula's constant |
| Quantinuum H2 and Helios | Quantinuum directly | HQC credits | Not published | Helios jobs are costed differently from H2 jobs and depend on the path taken at run time[11] |
| Rigetti Cepheus-1-108Q | Azure Quantum | Execution time | USD 0.02 per 10 ms of job execution time[5], that is US dollars a second | No charge per job, per shot or per gate[5] |
| Pasqal Fresnel (analog) | Azure Quantum | QPU time | EUR 3,000 per QPU-hour[5] | None listed |
| IBM QPUs | IBM Quantum, Pay-As-You-Go | QPU time | From USD 96 per minute, billed per second[6], that is US dollars a second | 1 second[6] |
| IQM QPUs | IQM Resonance, pay as you go | QPU time | From USD 0.30 per second[9] | None stated |
| IonQ QPUs | IonQ directly | Per gate-shot | Not published: rates depend on the access agreement[10] | A minimum per circuit applies to small jobs[10] |
Braket's per-task fee is the same on every QPU it offers[1]. Azure Quantum adds its own infrastructure costs to each provider's price, and its page says provider prices can lag and should be checked in the workspace[5]. Quantum annealers are left out: D-Wave's Leap page offers a free trial and lists no prices[13].
Reserved access and subscriptions
For steady use, vendors sell time in blocks. These are worth it only when the device would otherwise sit idle in your queue.
| Offer | Price | What you get |
|---|---|---|
| Braket Direct reservation | Per hour: IonQ Forte USD 7,000, AQT IBEX-Q1 USD 4,800, Rigetti Cepheus USD 4,100, IQM Emerald USD 4,000, IQM Garnet USD 3,000, QuEra Aquila USD 2,500[1] | The QPU to yourself, booked in 1-hour increments[1] and billed for the time booked. |
| IBM Flex Plan | From USD 72 per minute, prepaid from 400 minutes a year[6] | Needs a contract. The smallest commitment is US dollars a year. |
| IBM Premium Plan | From USD 48 per minute, annual from 5,200 minutes a year[6] | Half the Pay-As-You-Go rate per minute, for a commitment of at least US dollars a year. |
| IBM On-Prem Plan | Price requires a quote[6] | A dedicated system on your site, serviced by IBM. |
| IonQ Aria-Forte plan, Azure Quantum | USD 25,000 a month[5] | Gate-shot rates as above; use beyond the subscription's value is billed as pay as you go[5]. |
| Quantinuum Standard and Premium, Azure Quantum | USD 125,000 a month with 10k HQCs, or USD 175,000 a month with 17k HQCs[5] | Priority access to System Model H2 and its emulator, with further credits at a lower priority. |
| IQM Skip-the-queue | Contact IQM[9] | Exclusive reserved timeslots, billed in QPU seconds. |
Free tiers and research credits
IBM Open Plan. Free, with up to 10 minutes of runtime per month[6]. IBM's own quick estimate of a job's QPU time, circuits shots seconds[7], gives seconds for one circuit at 1,000 shots, so ten minutes cover about such jobs.
IQM Resonance Starter. Free, up to 30 credits per month, based on availability[9]. The page does not say what a credit buys.
Simulators. Amazon Braket's free tier is one hour of on-demand simulation time per month for the first twelve months[1], for simulators only; past it, the SV1 simulator costs USD 0.075 per minute[1]. IonQ's simulator and Rigetti's QVM are free on Azure Quantum[5]. A simulator on your own machine, such as eigenkit's, costs nothing per shot.
Research credits. Faculty, research staff and graduate students at accredited institutions can apply for AWS Cloud Credit for Research to use Braket[4]. Open Quantum gives sign-up credits that run on its public tier and expire 90 days after claiming[12].
Worked example 1: one run of a small circuit
Take the quantum kernel feature map on the Benchmarks grid at 8 qubits and depth 2: in each layer a rotation on every qubit, then a chain of CNOTs. That is single-qubit gates, two-qubit gates and measurements, run once for 1,000 shots. Each line below takes the list price from the table above and shows the arithmetic; amounts are in US dollars.
What 1,000 shots of an 8-qubit circuit cost
| Route | Arithmetic | Cost |
|---|---|---|
| Rigetti Cepheus, Braket | ||
| IQM Garnet, Braket | ||
| IBM, Pay-As-You-Go | QPU time from IBM's quick estimate[7]: s, at a second | |
| AQT IBEX-Q1, Braket | ||
| IonQ Forte, Open Quantum | ||
| IonQ Forte, Braket, no error mitigation | ||
| IonQ Forte, Braket, with error mitigation | The 2,500-shot minimum applies: | |
| IonQ Forte 1, Azure Quantum | Gate-shots: , below the floor, so the floor is billed | with error mitigation on, off |
| Quantinuum H2 | HQC, counting 8 state preparations and 8 measurements and the gates as written | Not computable: no published price per HQC |
| Rigetti Cepheus, Azure Quantum | a second of execution time; no time per shot is published | Measure one job first |
| IQM Resonance | From a QPU second; no time per shot is published | Measure one job first |
Two lessons. The route moves the price as much as the hardware: IonQ Forte costs different amounts on Braket, Open Quantum and Azure, and Rigetti's Cepheus family is sold per shot on Braket and per unit of execution time on Azure. And at this size the fixed parts dominate: Braket's task fee is over a third of the Rigetti bill, IBM's per-job overhead is most of the IBM one, and Azure's floor with mitigation on is about nine times what the IonQ gates and shots would cost. IBM's quick estimate assumes no advanced error mitigation and the default delay between shots.
Why prices differ between QPUs
Per shot, the trapped-ion machines from IonQ and AQT cost tens to hundreds of times more than the superconducting ones from IQM and Rigetti. A shot is not the same unit of work everywhere: the qubit types differ in gate speed, gate fidelity and which qubits can interact directly, so a circuit that needs many SWAPs on one device runs natively on another, and a low-fidelity shot may need more shots or more mitigation to give the same answer. The superconducting vs trapped-ion vs neutral-atom qubits comparison sets out those differences. Compare the cost of a usable answer, not the price of a shot.
Worked example 2: a variational training loop
A variational algorithm (VQE, QAOA or a quantum neural network) runs the circuit again for every gradient step. With the parameter-shift rule, the gradient of parameters needs two shifted circuits per parameter, and one more circuit gives the value itself. Take parameters, 100 optimiser iterations and 1,000 shots per circuit:
What 100 iterations of a 16-parameter loop cost
| Route | Arithmetic | Cost, USD |
|---|---|---|
| Rigetti Cepheus, Braket, one task per circuit | ||
| Rigetti Cepheus, Braket, one program set per iteration | ||
| IQM Garnet, Braket, one program set per iteration | ||
| IBM, Pay-As-You-Go, one job per iteration | s, at a second | |
| IonQ Forte, Braket, no error mitigation |
Packing each iteration's 33 circuits into one Braket program set saves the task fee on all but one of them. On IonQ the shots, not the fees, are the bill.
When the loop is a hybrid model's training epochs
A gradient-free optimiser such as SPSA needs two evaluations per step whatever the number of parameters. A hundred steps are then circuits, US dollars on Rigetti through Braket with one task per circuit, though SPSA usually needs more steps than gradient descent to converge.
A hybrid quantum neural network is worse, because every training sample is a circuit. With 200 training samples, trainable circuit weights, parameter-shift gradients and 30 epochs:
On Rigetti through Braket, in full program sets of 100 circuits, that is US dollars. On IBM, the shots alone take QPU seconds, US dollars before the overhead of each job. And small gradients make it worse: when gradients shrink, as they do on barren plateaus, each one needs more shots to resolve. This is why the usual practice is to train on a simulator and run only the trained model on hardware.
Worked example 3: a quantum kernel matrix
A quantum kernel needs one circuit per pair of samples: the feature map of one sample followed by the inverse map of the other, with the kernel value read as the probability of measuring all zeros. The Gram matrix of training samples is symmetric with ones on its diagonal, so it needs circuits. For that is circuits, shots at 1,000 each. With the 8-qubit map above, each circuit has single-qubit and two-qubit gates.
What a 100-sample kernel matrix costs
| Route | Arithmetic | Cost, USD |
|---|---|---|
| Rigetti Cepheus, Braket, 50 program sets | ||
| IQM Garnet, Braket, 50 program sets | ||
| IBM, Pay-As-You-Go, one job | s, at a second; a job this large may be split into sub-jobs, each with its own overhead | At least |
| IonQ Forte 1, Azure Quantum, error mitigation on | Gate-shots per circuit: , below the floor, so | |
| IonQ Forte 1, Azure Quantum, error mitigation off | Above the floor: |
The circuit count grows with the square of the training set: 1,000 samples need circuits, about a hundred times the bill above. Prediction adds one circuit per pair of test and training samples.
How many shots a kernel entry needs
A kernel value estimated from shots has a standard error of , about at 1,000 shots. That is enough only while the entries differ by more than that. On many qubits, with expressive maps, entanglement or noise, kernel values crowd towards a fixed value, and telling them apart then needs a number of shots that grows exponentially with the qubit count[16]. The QSVM vs classical SVM comparison shows this on real data, next to classical kernels that cost nothing per entry.
What drives cost beyond the list price
Shots for a target precision. An expectation value of an observable with outcomes , estimated from shots, has a standard error of at most . A precision of therefore needs about shots: needs shots, and each further digit of precision multiplies the shots, and so a per-shot bill, by a hundred.
Error mitigation. Zero-noise extrapolation runs each circuit at several amplified noise levels and extrapolates to zero noise, and probabilistic error cancellation resamples randomised circuits from a quasi-probability distribution[14]. The first multiplies the number of circuits and makes some of them deeper; the second multiplies the shots by a factor that grows exponentially with the circuit's size and error rate[15]. Built-in mitigation shows up in the price list as a minimum: IonQ's on Braket needs 2,500 shots per task[1], and on Azure it raises the floor per run. The lasting fix is quantum error correction, which trades the shot overhead for many physical qubits per logical one.
Minimums and per-run fees. Braket's task fee, Azure's floor per program execution and IBM's overhead of approximately 2 s per sub-job[7] are paid per submission, not per shot. For small circuits they are most of the bill, so pack circuits into fewer submissions.
Queue time and sessions. A wait in the queue costs nothing on per-shot and QPU-time routes. Holding the machine does: IBM bills a session for the elapsed time while it remains active, whether or not jobs are running[7], and a Braket Direct hour is billed whether you use it or not. On IBM, a job that fails or is cancelled because of a user error is still billed for the time used so far, including the overhead of preparing the QPU[7].
Transpiled depth. On Braket the per-shot price ignores depth[1]. On IonQ through Azure and on Quantinuum, every gate after compilation is billed, and a two-qubit gate between qubits that are not connected becomes a chain of SWAPs, each three CNOTs. On IBM's time-based billing, a typical circuit of roughly 50 to 100 microseconds[7] is short next to the default 250-microsecond[7] pause between shots, so depth adds little time. Everywhere, depth adds noise, and noise costs shots and mitigation.
How to keep quantum computing cost down
In order of how much they save. The first two cost nothing.
Simulate first
Develop, debug and train on a simulator, where a shot costs nothing and exact expectation values need no shots at all. Exact simulation on one machine reaches a few dozen qubits. Check, too, whether the problem needs a quantum computer at all: the guide to when quantum machine learning makes sense sets out the test, and a classical baseline that already meets the need saves the whole hardware bill.
Count circuits and shots before you submit
Multiply circuits per call by calls per epoch by epochs, and shots by the precision you need. Run that count against the table above. IonQ offers dry-run jobs that return a predicted cost and are not charged[10].
Check which devices can run the circuit at all
A device whose errors swamp your circuit returns noise at full price. EigenOrbit Benchmarks shows, for a workload like yours, which QPUs can run it within their error budget and what one run costs where the vendor publishes prices.
Pack circuits into fewer submissions
On Braket, a program set pays one task fee for up to 100 circuits[2]; on IBM, one job with many circuits pays the per-job overhead once. Below a per-run floor, adding shots or circuits to a run is free.
Choose the route, not only the chip
The same IonQ Forte costs different amounts on Braket, Open Quantum and Azure, and the same Rigetti family is billed per shot on one cloud and per unit of time on the other. Price your workload on each route that reaches the device.
Run on hardware last, through one account
Validate the trained model on a QPU with the test set you already have. EigenOrbit Router reaches real QPUs and cloud simulators with one API key and one prepaid balance, so you can run the same circuit on the route that suits it without an account at each vendor. eigenkit's docs list Router with one job per sample and no native batching, so on a route with a per-task fee, count one fee per circuit.
Run it on a real QPU with EigenOrbit RouterIn eigenkit:
pip install "eigenkit[router]", thenprovider=RouterConfig(device=...)(docs).
Run it on a real QPU with EigenOrbit RouterThe circuits you counted above, on the QPU and route you chose, with one account and a prepaid balance.In eigenkit: pip install "eigenkit[router]", then provider=RouterConfig(device=...) (docs).
Questions
How much does it cost to use a quantum computer?
One run of a small circuit for a thousand shots costs from under a dollar on the cheapest per-shot route, Rigetti Cepheus on Amazon Braket, to around two hundred dollars where a per-run minimum applies, such as IonQ Forte with error mitigation. IBM sells QPU time by the second on Pay-As-You-Go. A real project runs many circuits: a variational training loop or a quantum kernel matrix is thousands of circuits and costs thousands of dollars or more, which is why most work is done on simulators first.
How much does IBM Quantum cost?
IBM's Open Plan is free with up to 10 minutes of runtime per month. Pay-As-You-Go starts at 96 US dollars per minute of QPU time, billed per second. The Flex Plan starts at 72 dollars per minute with prepaid time from 400 minutes a year, and the Premium Plan at 48 dollars per minute from 5,200 minutes a year; both need a contract. IBM bills the time the QPU is locked for your job, and a session for its whole active time.
How much does AWS Braket cost per shot?
Braket charges 0.30 US dollars per task on every QPU plus a per-shot price that depends on the device: 0.000425 dollars on Rigetti Cepheus, 0.00145 on IQM Garnet, 0.0016 on IQM Emerald, 0.01 on QuEra Aquila, 0.0235 on AQT IBEX-Q1 and 0.08 on IonQ Forte. Error mitigation on IonQ needs at least 2,500 shots per task. A program set puts up to 100 circuits in one task and pays one task fee. Braket Direct reservations cost 2,500 to 7,000 dollars an hour depending on the device.
What is a Quantinuum HQC and how much does it cost?
A Hardware Quantum Credit is the unit Quantinuum bills in. The credits a job uses follow a published formula: a constant of 5 per job plus the shots times a weighted count of single-qubit gates, two-qubit gates and state preparations and measurements, divided by 5000. The US dollar price of a credit is not published: pay as you go goes through Quantinuum's sales, and on Azure Quantum the subscriptions cost 125,000 dollars a month for 10k HQCs or 175,000 dollars a month for 17k HQCs.
Can I use a quantum computer for free?
Yes, in small amounts. IBM's Open Plan gives up to 10 minutes of runtime per month on its QPUs, and IQM Resonance's Starter plan gives up to 30 credits per month, based on availability. Simulators are free on your own machine and on several clouds, Amazon Braket gives an hour of simulator time a month for the first year, and researchers at accredited institutions can apply for AWS Cloud Credit for Research.
Why does the same QPU cost different amounts on different clouds?
Because the price belongs to the route, not to the chip. IonQ Forte costs 0.08 US dollars per shot plus a task fee on Amazon Braket, 0.048 dollars per shot on Open Quantum's public tier, and on Azure Quantum it is billed per gate-shot with a floor per run. Rigetti's Cepheus family is billed per shot on Braket and per unit of execution time on Azure. Price your workload on each route before you choose.
Sources
- Amazon Web Services. Amazon Braket pricing. Amazon Web Services, pricing page (checked 4 November 2026), 2026.
- C. Wang, M. Beach, G. Ramu, L. Capelluto, P. Komar, R. Shaffer, V. V. Chaudhari, Z. Mohammad. Amazon Braket introduces program sets, enabling customers to run quantum programs up to 24x faster. AWS Quantum Technologies Blog, 2025.
- Amazon Web Services. Amazon Braket introduces spending limits feature for quantum processing units. AWS What's New, 2025.
- Amazon Web Services. Research quantum algorithms and test quantum computers. Amazon Braket, research page, 2026.
- Microsoft. Pricing plans for Azure Quantum providers. Microsoft Learn, Azure Quantum documentation (checked 4 November 2026), 2026.
- IBM. IBM Quantum access plans. IBM Quantum, plans page (checked 4 November 2026), 2026.
- IBM. Workload usage. IBM Quantum Platform documentation, 2026.
- IBM. Manage cost on the Pay-As-You-Go Plan. IBM Quantum Platform documentation, 2026.
- IQM Quantum Computers. IQM Resonance. IQM, product and pricing page (checked 4 November 2026), 2026.
- IonQ. Job cost and usage. IonQ documentation, 2026.
- Quantinuum. Quantinuum Systems' workflow. Quantinuum documentation, hardware user guide, 2026.
- Open Quantum. Pricing. Open Quantum, pricing page (checked 4 November 2026), 2026.
- D-Wave Quantum. Leap quantum cloud service. D-Wave, product page, 2026.
- K. Temme, S. Bravyi, J. M. Gambetta. Error mitigation for short-depth quantum circuits. Physical Review Letters 119, 180509, 2017. arXiv:1612.02058.
- Z. Cai, R. Babbush, S. C. Benjamin, S. Endo, W. J. Huggins, Y. Li, J. R. McClean, T. E. O'Brien. Quantum error mitigation. Reviews of Modern Physics 95, 045005, 2023. arXiv:2210.00921.
- S. Thanasilp, S. Wang, M. Cerezo, Z. Holmes. Exponential concentration in quantum kernel methods. Nature Communications 15, 5200, 2024. arXiv:2208.11060.
Run it yourself with eigenkit
eigenkit is EigenOrbit's open-source Python library: write a circuit once, run it on any simulator or QPU, and test it against a classical baseline on your own data before you invest in it or rule it out.
$ pip install eigenkit