How Much Does a Quantum Computer Cost? To Buy, and To Rent

There are two versions of this question and they have very different answers. Buying a quantum computer costs anywhere from five thousand dollars to thirty million, depending on what you mean by one.

Renting time on somebody else's costs a fraction of a cent. This article answers both, with figures you can check, and the per shot cost calculator prices any of them against your own budget.

Everything here is runnable on your own circuit. Try it in the console

How much does a quantum computer cost?

Published purchase prices span four orders of magnitude, because the phrase covers everything from a desktop teaching device to a cryogenically cooled installation that needs its own room.

• SpinQ Gemini Mini, around $5,000. Two qubits, nuclear magnetic resonance, room temperature. A teaching device
• SpinQ Gemini, around $43,000, and Triangulum, around $55,000. Desktop, still educational
• Rigetti Novera QPU, $900,000. Nine superconducting qubits. That buys the chip alone, with no working system around it
• Rigetti Novera as a complete system, around $2,850,000. The difference is the dilution refrigerator and the control electronics
• D-Wave Advantage2, around $20,000,000. An annealer, sold to Florida Atlantic University in 2026
• IQM at the Leibniz Supercomputing Centre, around 25 million euros. On-premise superconducting
• IBM Quantum System One, $10M to $30M. IBM installs on-premise but publishes no list price

The distance between the top and bottom of that list is not a discount. The five-thousand-dollar machines run two or three qubits by nuclear magnetic resonance at room temperature and exist to teach the concepts. They cannot run anything you could not simulate on a phone. The multi-million-dollar systems are the ones capable of research.

How much does it cost to build a quantum computer?

More than buying one, and the reason is the refrigeration rather than the chip.

A superconducting processor has to sit at roughly 10 to 15 millikelvin, colder than deep space. A commercial dilution refrigerator runs from about $150,000 for a tabletop research unit to over $2,000,000 for one sized to a multi-qubit processor.

IBM's large-scale unit reportedly cost over $800,000, with annual electricity above $100,000. That is before control electronics, microwave lines, shielding and the staff who can operate any of it.

The Rigetti figures make the point precisely. The nine-qubit chip is $900,000 and the working system is $2,850,000. Roughly two thirds of the price is everything that is not the quantum processor. Trapped-ion and neutral-atom machines skip the refrigerator and pay instead in lasers, vacuum systems and optical tables, landing in the same range.

Are quantum computers expensive?

Expensive to own, cheap to use, and that gap is the entire commercial argument for cloud access.

For most organisations the sensible first step is a few tens of thousands of dollars of cloud access before committing to a capital purchase measured in millions. On this platform the contrast is starker still. A certified simulation of a research-scale circuit costs a fraction of a cent. A run on real superconducting hardware costs about thirty cents.

• Teach quantum concepts. Buy: $5,000. Rent: free tier
• Run a 100-qubit structured circuit. Buy: not possible at any price today. Rent: under one cent
• Run a circuit on real superconducting hardware. Buy: $2.85M. Rent: about $0.32
• Run a circuit on real trapped-ion hardware. Buy: $10M and up. Rent: $0.77 to $8.30 depending on device and shots

Buying does purchase something real: exclusive access, no queue, and the ability to work on physically sensitive data. Those are why national labs and a few large corporations buy. They are not reasons that apply to running an algorithm.

What real hardware costs to rent

Superconducting QPU access through cloud aggregators runs a flat $0.30 per task plus $0.000425 to $0.0016 per shot, depending on the device. Trapped-ion devices price far higher per shot, up to $0.08.

Here is the full list, at provider list price with no markup. Eight machines from seven manufacturers, across four hardware modalities:

device                      modality          qubits  per task   per shot
Quandela Belenos            photonic              12  EUR 0.30 EUR 0.000001
Rigetti Cepheus-1-108Q      superconducting      108     $0.30    $0.000425
IQM Garnet                  superconducting       20     $0.30    $0.00145
IQM Emerald                 superconducting       54     $0.30    $0.0016
QuEra Aquila                neutral atom         256     $0.30    $0.01
AQT IBEX Q1                 trapped ion           12     $0.30    $0.0235
IonQ Forte Enterprise 1     trapped ion           36     $0.30    $0.08
Pasqal FRESNEL              neutral atom         100   machine time, EUR 500/hour

Two of them are not priced per shot. Quandela Belenos charges a flat EUR 0.30 a job however many samples you take, and Pasqal FRESNEL bills machine time at EUR 500 an hour, about EUR 0.56 a shot at one shot every four seconds. Both are quoted in euros because that is what the provider invoices; the dollar amount you are charged uses the exchange rate read that day, and the rate applied is recorded in the result.

The classical tiers, for the same circuit, are the other half of the comparison: CPU at $0.69 an hour with a $0.0001 floor per circuit, GPU at $3.00 an hour to 30 qubits and $8.00 an hour above that, and TPU at $1.85 a chip-hour.

Dedicated hourly access on frontier machines runs into the thousands of dollars per hour. Queue time adds a further, less visible cost in iteration speed. The per-device list prices for all of them, with shot floors and ceilings, are in what it costs to rent a quantum computer.

Workload                              Approx. QPU cost (superconducting)
Single 10,000-shot experiment                              ~$4.50
Research sweep, 200 parameter settings                       ~$900
Team subscription, simulation cloud, monthly            $600-$2,500+

Every figure above is in the per shot cost calculator, where you can price a run against your own shot count and device before committing to it.

Click to enlarge

Close

What we actually paid, with receipts

Published prices are one thing; a bill is another. These are runs on our own service, each with a public certificate that states the engine, the shot count and the accuracy of the result. The certificates need no account to open.

Run                                          Engine        Cost      Certificate
192-qubit expectation value                  pauli.cpu     $0.0001   5b8b2c4309d44d41
1001-qubit error-correcting code             clifford      $0.0001   86125198363b4d02
40-qubit tensor network, certified bound     mps.quimb.cpu $0.0001   613aa866278e4c81
Bell state on IonQ Forte-1 hardware          qpu.ionq      ~$0.30    df1d4c698a954051

The pattern is the point. Anything a classical engine can reach costs a hundredth of a cent, because the work takes seconds. The moment real hardware is involved the price jumps by more than two orders of magnitude, and that gap is the whole economics of the field: hardware time is scarce and simulation is not.

A 1001-qubit error-correction circuit for a hundredth of a cent sounds implausible until you notice it is a Clifford circuit, which the Gottesman-Knill theorem says is classically tractable no matter how many qubits it has. Paying hardware prices for that would be a straightforward waste.

One molecule, every tier, with the bill

The receipts above are different problems on different engines. This is a single problem sent to all four tiers. The H2 molecule at its equilibrium bond length is two qubits, so it fits everywhere. CPU and GPU compute it exactly, a Google Cloud TPU solves it from the Hamiltonian using neural network quantum states, and three quantum processors run it on real hardware.

Run on our engines

The H2 molecule at its equilibrium bond length, whose exact electronic ground state is -1.857275 Ha. Two qubits, so it fits every device we offer. Submitted to each kind of compute we offer, on 16 September 2026. Every figure below is a real job on the service, priced as any customer would be priced.

Device	Engine	Kind	Qubits	Result	Cost
	exact.cpu	CPU	2	ZZ = -1.0000, the ideal value certificate	$0.0001
	exact.gpu	GPU	2	ZZ = -1.0000, the ideal value certificate	$0.0001
	qpu.iqm.garnet	QPU	2	ZZ = -0.9326, superconducting, 4,096 shots certificate	$6.239
	qpu.rigetti	QPU	2	ZZ = -0.5420, superconducting, 4,096 shots * certificate	$2.041
	qpu.rigetti	QPU	2	ZZ = -0.5107, the same circuit re-run * certificate	$2.041
	qpu.aqt.ibex	QPU	2	ZZ = -0.9200, trapped ion, 100 shots certificate	$2.650
	neural.cpu	CPU	2	-1.116981 Ha total, 0.0203 Ha above exact certificate	$0.0001
	neural.tpu	TPU	2	-1.116981 Ha total, 0.0203 Ha above exact certificate	$0.074

* The two Rigetti rows are one circuit run twice, an internal reproduction of the published benchmark notebook. A depolarizing noise model puts both versions at about -0.99, so the shortfall is not the circuit shape, but the identical program has not yet run on both devices. The steps are in the docs.

A note on the hardware certificates: they state Hellinger fidelity against the exact distribution. For an optimisation circuit that distribution is spread across many outcomes rather than concentrated on one, so the figure is low by construction and is not a measure of whether the device found a good answer. The result column above is.

The same problem is yours to run: every instance here is seeded, so it rebuilds exactly. Open the console and a cost estimate is free before anything executes.

The spread is this article in one table. The three classical rows cost a hundredth of a cent each and the Google TPU row seven cents, against $6.24 on IQM Garnet, $2.04 on Rigetti Cepheus-1 and $2.65 on AQT IBEX Q1. The first two ran at 4,096 shots and the AQT row at 100, so only those first two are a like-for-like comparison on cost. The full write-up is on the chemistry benchmark.

What the same science costs classically

The comparison is instructive. Circuits under roughly 32 qubits simulate exactly on ordinary CPU hardware for fractions of a cent per circuit.

Structured circuits in the 50 to 128-qubit range, including QAOA instances, ansatze, and quench dynamics, run on tensor-network engines in seconds; a 100-qubit, depth-304 QAOA instance completes in 5.9 seconds on a laptop CPU, which prices at under a cent on cloud infrastructure. Clifford circuits at any scale are effectively free to simulate.

GPU acceleration for workloads that benefit from it rents on demand by the hour: on this service, $3 per GPU-hour up to 30 qubits and $8 for the 31 to 32-qubit tier, which needs a larger card. With per-second billing a 20-minute sweep on the standard tier costs about a dollar. Across a typical algorithms group, the audited quantum computing budget is overwhelmingly classical simulation, not hardware access.

Error correction is the sharpest version of the comparison. A surface code is built almost entirely from Clifford gates, which classical methods handle exactly, so a distance-15 memory experiment over a million shots costs about three cents to simulate and decode. Demonstrating error correction on a device needs the device, but testing a code, a decoder and a noise model does not, which is why research on codes runs years ahead of the hardware that will eventually run them. The output is a logical error rate with a confidence interval, and what one logical qubit costs in physical ones is measured across seven error rates here.

The cost of hybrid algorithms

Every price above is the price of one circuit. The workloads people actually want to run are not one circuit. VQE, QAOA and every other variational method wrap an optimizer around the circuit and evaluate it repeatedly, so the quoted per-task figure is a unit cost that has to be multiplied by the number of evaluations the optimizer needs.

That number follows from the optimizer, not from the chemistry or the portfolio. Our own solver runs SPSA, which perturbs every parameter simultaneously and therefore costs two circuit evaluations per iteration regardless of how many parameters the ansatz has, plus one final evaluation at the best point found.

A 150-iteration run is 301 circuit submissions. That figure is not an estimate; it is asserted by a test in our backend suite, because the property is the reason SPSA was chosen.

Substituting the parameter-shift rule, which is the textbook gradient method, changes the arithmetic entirely. Parameter shift costs two evaluations per parameter per iteration. A real_amplitudes ansatz on 8 qubits at depth 3 carries 32 parameters, so the same 150 iterations become 9,601 submissions, a factor of 32 more. EfficientSU2 at the same width and depth carries 64 parameters and doubles that again.

Priced at the Rigetti pass-through rate of $0.30 per task plus $0.000425 per shot, at 2,048 shots per evaluation:

Optimizer        Circuit submissions   On QPU hardware   On simulation
SPSA, 150 iter                    301           $352.29           $0.30
Parameter shift, 150 iter       9,601        $11,237.01           $9.60

Two conclusions follow. The first is that the choice of optimizer, which is usually made on convergence grounds and rarely revisited, moves the hardware bill by a factor of 32 on an eight-qubit problem and by more on larger ones.

The second is that the ratio between the two right-hand columns is roughly 1,170 to 1, and it is constant. It is simply the per-task price ratio, applied 301 times instead of once.

Wall-clock time compounds this. Each submission enters the device queue separately, and published queue times on shared hardware range from minutes to hours.

At a median of one minute per task, a 301-evaluation SPSA run occupies about five hours of elapsed time before any result exists, and a parameter-shift run of the same problem occupies over a week. Iteration speed, not the invoice, is usually what ends up constraining the work.

The practical consequence is that the ansatz, the optimizer and the iteration budget should be settled by simulation, where the same 301 evaluations cost thirty cents and return in minutes, and hardware should be reserved for the single configuration that survives that process. Running the search itself on a QPU pays hardware prices 300 times over for evaluations that were only ever going to be discarded.

When hardware spending is justified

Real QPU spend is warranted in three cases:

• Validating algorithm behavior under genuine hardware noise, where the physical error process itself is the object of study
• Circuits beyond roughly 45 to 50 qubits with entanglement structure that no classical method compresses, a condition that should be verified rather than assumed
• Error-correction experiments that require physical qubits by definition

For work outside these three cases, simulation returns a noise-free, error-bounded answer for a fraction of the cost. The pricing model on this platform follows from that logic: simulation from $0.0001 per circuit with a free pre-run cost estimate, GPU billed by the second, and Rigetti hardware passed through at cost, $0.30 per task plus $0.000425 per shot, with no markup.

The single question worth asking before any hardware run in 2026 is whether a simulator could answer it. Asking it first is inexpensive; not asking it is where most quantum computing budgets are spent unnecessarily.