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 rather than ranges lifted from press releases.

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. This is the chip, not a working system.
• 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 roughly $0.30 per task plus $0.0004 to $0.001 per shot. Trapped-ion devices price higher per shot; 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.

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+

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.001    5b8b2c4309d44d41
1001-qubit error-correcting code             clifford      $0.001    86125198363b4d02
40-qubit tensor network, certified bound     mps.quimb     $0.001    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 tenth 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 tenth 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.

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 job. 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 at roughly $3 to $4 per GPU-hour on demand; with per-second billing, a 20-minute sweep costs about a dollar. Across a typical algorithms group, the audited quantum computing budget is overwhelmingly classical simulation, not hardware access.

The cost nobody quotes: 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 a number the vendor page never states.

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.001 per job 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.