Guide

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 0.30+1000×0.000425=0.7250.30 + 1000 \times 0.000425 = 0.725 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

ModelWho sells this wayWhat the bill followsWhat it means for a workload
Per task plus per shotAmazon Braket; Open Quantum, a resellerA 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 runIonQ on Azure QuantumOne- 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 formulaQuantinuum, on Azure Quantum and directlyHardware Quantum Credits: HQC=5+N1q+10N2q+5Nm5000C\text{HQC} = 5 + \frac{N_{1q} + 10 N_{2q} + 5 N_m}{5000} C, with N1qN_{1q} and N2qN_{2q} the one- and two-qubit gates, NmN_m the state preparations and measurements, and CC 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 timeIBM Quantum and IQM Resonance, per second; Rigetti on Azure, per 10-millisecond increment[5]; Pasqal on Azure, per QPU-hourOn 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 subscriptionsBraket Direct, IBM Flex and Premium, IonQ and Quantinuum plans on Azure Quantum, IQM Skip-the-queueHours or months you hold, whether you use them or not.Cheaper per unit only if you keep the device busy.
Free tiers and research creditsIBM Open Plan, IQM Starter, Braket's simulator free tier, AWS Cloud Credit for Research, Open Quantum sign-up creditsAn 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.

QPURouteBilling modelList priceMinimum or floor
IonQ ForteAmazon BraketPer task plus per shotUSD 0.30 per task + USD 0.08 per shot[1]2,500 shots per task with error mitigation[1]
AQT IBEX-Q1Amazon BraketPer task plus per shotUSD 0.30 per task + USD 0.0235 per shot[1]None listed
IQM EmeraldAmazon BraketPer task plus per shotUSD 0.30 per task + USD 0.0016 per shot[1]None listed
IQM GarnetAmazon BraketPer task plus per shotUSD 0.30 per task + USD 0.00145 per shot[1]None listed
Rigetti CepheusAmazon BraketPer task plus per shotUSD 0.30 per task + USD 0.000425 per shot[1]None listed
QuEra Aquila (analog)Amazon BraketPer task plus per shotUSD 0.30 per task + USD 0.01 per shot[1]None listed
IonQ Forte, Forte EnterpriseOpen Quantum, public tierPer task plus per shotUSD 0.18 per task + USD 0.048 per shot[12]None listed
IonQ Forte 1, Forte Enterprise 1Azure QuantumPer gate-shotUSD 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 1Azure QuantumPer gate-shotUSD 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 H2Azure Quantum, pay as you goHQC creditsPer HQC; price from Quantinuum sales[5]5 HQC per job[11], the formula's constant
Quantinuum H2 and HeliosQuantinuum directlyHQC creditsNot publishedHelios jobs are costed differently from H2 jobs and depend on the path taken at run time[11]
Rigetti Cepheus-1-108QAzure QuantumExecution timeUSD 0.02 per 10 ms of job execution time[5], that is 0.02/0.01=20.02 / 0.01 = 2 US dollars a secondNo charge per job, per shot or per gate[5]
Pasqal Fresnel (analog)Azure QuantumQPU timeEUR 3,000 per QPU-hour[5]None listed
IBM QPUsIBM Quantum, Pay-As-You-GoQPU timeFrom USD 96 per minute, billed per second[6], that is 96/60=1.6096 / 60 = 1.60 US dollars a second1 second[6]
IQM QPUsIQM Resonance, pay as you goQPU timeFrom USD 0.30 per second[9]None stated
IonQ QPUsIonQ directlyPer gate-shotNot 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.

OfferPriceWhat you get
Braket Direct reservationPer 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 PlanFrom USD 72 per minute, prepaid from 400 minutes a year[6]Needs a contract. The smallest commitment is 400×72=28,800400 \times 72 = 28{,}800 US dollars a year.
IBM Premium PlanFrom 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 5200×48=249,6005200 \times 48 = 249{,}600 US dollars a year.
IBM On-Prem PlanPrice requires a quote[6]A dedicated system on your site, serviced by IBM.
IonQ Aria-Forte plan, Azure QuantumUSD 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 QuantumUSD 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-queueContact 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, 2+0.00035×2 + 0.00035 \times circuits ×\times shots seconds[7], gives 2.352.35 seconds for one circuit at 1,000 shots, so ten minutes cover about 600/2.35≈255600 / 2.35 \approx 255 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 1616 single-qubit gates, 1414 two-qubit gates and 88 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

RouteArithmeticCost
Rigetti Cepheus, Braket0.30+1000×0.0004250.30 + 1000 \times 0.0004250.7250.725
IQM Garnet, Braket0.30+1000×0.001450.30 + 1000 \times 0.001451.751.75
IBM, Pay-As-You-GoQPU time from IBM's quick estimate[7]: 2+0.00035×1000=2.352 + 0.00035 \times 1000 = 2.35 s, at 1.601.60 a second3.763.76
AQT IBEX-Q1, Braket0.30+1000×0.02350.30 + 1000 \times 0.023523.8023.80
IonQ Forte, Open Quantum0.18+1000×0.0480.18 + 1000 \times 0.04848.1848.18
IonQ Forte, Braket, no error mitigation0.30+1000×0.080.30 + 1000 \times 0.0880.3080.30
IonQ Forte, Braket, with error mitigationThe 2,500-shot minimum applies: 0.30+2500×0.080.30 + 2500 \times 0.08200.30200.30
IonQ Forte 1, Azure QuantumGate-shots: 1000×(16×0.0001645+14×0.001121)=18.331000 \times (16 \times 0.0001645 + 14 \times 0.001121) = 18.33, below the floor, so the floor is billed168.195168.195 with error mitigation on, 25.789925.7899 off
Quantinuum H25+1000×16+10×14+5×165000=52.25 + 1000 \times \frac{16 + 10 \times 14 + 5 \times 16}{5000} = 52.2 HQC, counting 8 state preparations and 8 measurements and the gates as writtenNot computable: no published price per HQC
Rigetti Cepheus, Azure Quantum22 a second of execution time; no time per shot is publishedMeasure one job first
IQM ResonanceFrom 0.300.30 a QPU second; no time per shot is publishedMeasure 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 PP parameters needs two shifted circuits per parameter, and one more circuit gives the value itself. Take P=16P = 16 parameters, 100 optimiser iterations and 1,000 shots per circuit:

(2P+1)×100=33×100=3300 circuits,3300×1000=3.3×106 shots.(2P + 1) \times 100 = 33 \times 100 = 3300 \text{ circuits}, \qquad 3300 \times 1000 = 3.3 \times 10^{6} \text{ shots}.

What 100 iterations of a 16-parameter loop cost

RouteArithmeticCost, USD
Rigetti Cepheus, Braket, one task per circuit3300×0.30+3.3×106×0.0004253300 \times 0.30 + 3.3 \times 10^{6} \times 0.0004252392.502392.50
Rigetti Cepheus, Braket, one program set per iteration100×0.30+3.3×106×0.000425100 \times 0.30 + 3.3 \times 10^{6} \times 0.0004251432.501432.50
IQM Garnet, Braket, one program set per iteration100×0.30+3.3×106×0.00145100 \times 0.30 + 3.3 \times 10^{6} \times 0.0014548154815
IBM, Pay-As-You-Go, one job per iteration100×(2+0.00035×33000)=1355100 \times (2 + 0.00035 \times 33000) = 1355 s, at 1.601.60 a second21682168
IonQ Forte, Braket, no error mitigation3300×0.30+3.3×106×0.083300 \times 0.30 + 3.3 \times 10^{6} \times 0.08264,990264{,}990

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 200200 circuits, 200×0.30+2×105×0.000425=145200 \times 0.30 + 2 \times 10^{5} \times 0.000425 = 145 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, 88 trainable circuit weights, parameter-shift gradients and 30 epochs:

200×30×(2×8+1)=102,000 circuits,1.02×108 shots at 1,000 each.200 \times 30 \times (2 \times 8 + 1) = 102{,}000 \text{ circuits}, \qquad 1.02 \times 10^{8} \text{ shots at 1,000 each}.

On Rigetti through Braket, in full program sets of 100 circuits, that is 1020×0.30+1.02×108×0.000425=43,6561020 \times 0.30 + 1.02 \times 10^{8} \times 0.000425 = 43{,}656 US dollars. On IBM, the shots alone take 0.00035×1.02×108=35,7000.00035 \times 1.02 \times 10^{8} = 35{,}700 QPU seconds, 35,700×1.60=57,12035{,}700 \times 1.60 = 57{,}120 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 nn training samples is symmetric with ones on its diagonal, so it needs n(n−1)/2n(n-1)/2 circuits. For n=100n = 100 that is 49504950 circuits, 4.95×1064.95 \times 10^{6} shots at 1,000 each. With the 8-qubit map above, each circuit has 3232 single-qubit and 2828 two-qubit gates.

What a 100-sample kernel matrix costs

RouteArithmeticCost, USD
Rigetti Cepheus, Braket, 50 program sets50×0.30+4.95×106×0.00042550 \times 0.30 + 4.95 \times 10^{6} \times 0.0004252118.752118.75
IQM Garnet, Braket, 50 program sets50×0.30+4.95×106×0.0014550 \times 0.30 + 4.95 \times 10^{6} \times 0.001457192.507192.50
IBM, Pay-As-You-Go, one job2+0.00035×4.95×106=1734.52 + 0.00035 \times 4.95 \times 10^{6} = 1734.5 s, at 1.601.60 a second; a job this large may be split into sub-jobs, each with its own overheadAt least 2775.202775.20
IonQ Forte 1, Azure Quantum, error mitigation onGate-shots per circuit: 1000×(32×0.0001645+28×0.001121)=36.651000 \times (32 \times 0.0001645 + 28 \times 0.001121) = 36.65, below the floor, so 4950×168.1954950 \times 168.195832,565.25832{,}565.25
IonQ Forte 1, Azure Quantum, error mitigation offAbove the floor: 4950×36.6524950 \times 36.652181,427.40181{,}427.40

The circuit count grows with the square of the training set: 1,000 samples need 1000×999/2=499,5001000 \times 999 / 2 = 499{,}500 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 pp estimated from SS shots has a standard error of p(1−p)/S≤1/(2S)\sqrt{p(1-p)/S} \le 1/(2\sqrt{S}), about 0.0160.016 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 ±1\pm 1, estimated from SS shots, has a standard error of at most 1/S1/\sqrt{S}. A precision of ε\varepsilon therefore needs about S≈1/ε2S \approx 1/\varepsilon^2 shots: ε=0.01\varepsilon = 0.01 needs 10410^4 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.

  1. 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.

  2. 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].

  3. 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.

  4. 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.

  5. 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.

  6. Set a spending limit

    Braket lets you set a maximum spend per QPU and rejects a task that would exceed it before creating it[3]. IBM lets you set a cost limit on a Pay-As-You-Go instance, but a job may run past it, because run time is reported only periodically[8].

  7. 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]", then provider=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

  1. Amazon Web Services. Amazon Braket pricing. Amazon Web Services, pricing page (checked 4 November 2026), 2026.
  2. 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.
  3. Amazon Web Services. Amazon Braket introduces spending limits feature for quantum processing units. AWS What's New, 2025.
  4. Amazon Web Services. Research quantum algorithms and test quantum computers. Amazon Braket, research page, 2026.
  5. Microsoft. Pricing plans for Azure Quantum providers. Microsoft Learn, Azure Quantum documentation (checked 4 November 2026), 2026.
  6. IBM. IBM Quantum access plans. IBM Quantum, plans page (checked 4 November 2026), 2026.
  7. IBM. Workload usage. IBM Quantum Platform documentation, 2026.
  8. IBM. Manage cost on the Pay-As-You-Go Plan. IBM Quantum Platform documentation, 2026.
  9. IQM Quantum Computers. IQM Resonance. IQM, product and pricing page (checked 4 November 2026), 2026.
  10. IonQ. Job cost and usage. IonQ documentation, 2026.
  11. Quantinuum. Quantinuum Systems' workflow. Quantinuum documentation, hardware user guide, 2026.
  12. Open Quantum. Pricing. Open Quantum, pricing page (checked 4 November 2026), 2026.
  13. D-Wave Quantum. Leap quantum cloud service. D-Wave, product page, 2026.
  14. K. Temme, S. Bravyi, J. M. Gambetta. Error mitigation for short-depth quantum circuits. Physical Review Letters 119, 180509, 2017. arXiv:1612.02058.
  15. 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.
  16. 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