Using your own IonQ API key? See IonQ (self-managed).

Devices on qBraid

IonQ’s trapped-ion systems are on qBraid through three submission paths. Each path has its own device IDs, billing, and runtime options.

Device IDDevicePath
ionq:ionq:sim:simulatorIonQ simulator, 29 qubitsDirect
ionq:ionq:qpu:forte-1Forte-1, 36 qubitsDirect
aws:ionq:qpu:forte-1Forte-1, 36 qubitsAmazon Braket
aws:ionq:qpu:forte-enterprise-1Forte Enterprise-1Amazon Braket
openquantum:ionq:qpu:forte-1Forte-1, 36 qubitsOpen Quantum
openquantum:ionq:qpu:forte-enterpriseForte EnterpriseOpen Quantum

Check each device’s status and price in the device catalog before you submit. Not every path is online at once.

Quick start

Start on the simulator, which runs the same programs as the QPUs:

from qbraid.runtime import QbraidProvider

provider = QbraidProvider()
device = provider.get_device("ionq:ionq:sim:simulator")

bell = """
OPENQASM 3.0;
include "stdgates.inc";
qubit[2] q;
bit[2] c;
h q[0];
cx q[0], q[1];
c = measure q;
"""

job = device.run(bell, shots=100)
print(job.result().data.get_counts())

To run on a QPU, change the device ID. Programs can be written in any framework qBraid supports; qBraid converts them to OpenQASM before they reach IonQ.

Direct

ionq: devices go from qBraid straight to IonQ, billed in qBraid credits. They accept these runtime_options:

OptionEffect
noise_modelOn the simulator, the hardware noise model to simulate. See below.
seedWith noise_model, makes a noisy run repeatable.
error_mitigationOn QPUs, IonQ’s error mitigation settings, such as debiasing. See below.
noiseIonQ’s own form of noise_model and seed, kept for older code. See the note below.

A job with any other option fails before it reaches IonQ, at no cost, with a message naming the options it accepts.

Run the simulator with a hardware noise profile:

job = device.run(
    bell,
    shots=1000,
    runtime_options={"noise_model": "forte-1", "seed": 42},
)

The same seed with the same noise_model returns the same counts. Without a noise_model the simulator is ideal, and seed has no effect.

The simulator’s noise models are listed on the device, and a model not on the list is refused before the job is submitted:

print(device.profile.noise_models)
# NoiseModelSet(['ideal', 'aria-1', 'aria-2', 'forte-1', 'forte-enterprise-1'])

forte-1 and forte-enterprise-1 model IonQ’s current QPUs; IonQ keeps aria-1 and aria-2 for its retired Aria systems. See IonQ’s guide to simulation with noise models.

Older code may pass IonQ’s own form, runtime_options={"noise": {"model": "aria-1", "seed": 42}}. It still works, and a model or seed set there takes precedence over noise_model and seed. New code should use noise_model and seed, which are what other qBraid devices use.

Debiasing is set with error_mitigation, which is sent to IonQ as the job’s settings.error_mitigation. It runs on QPUs only and needs at least 500 shots. IonQ turns it on by default for jobs of 500 shots or more written in standard gates, and off for native-gate jobs. Turn it off for a job of 500 shots or more that doesn’t need it:

device = provider.get_device("ionq:ionq:qpu:forte-1")

job = device.run(
    bell,
    shots=1000,
    runtime_options={"error_mitigation": {"debiasing": False}},
)

See IonQ’s guide to debiasing for how it works and how it affects cost.

Through Amazon Braket

aws:ionq: devices go through Amazon Braket, billed in qBraid credits. They take Braket runtime options rather than the direct options above. Debiasing, for example, is set with device_parameters:

device = provider.get_device("aws:ionq:qpu:forte-1")

job = device.run(
    bell,
    shots=2500,  # Braket requires at least 2500 shots for debiasing
    runtime_options={"device_parameters": {"errorMitigation": "Debias"}},
)

Amazon Braket covers what every Braket device has in common, including how counts are ordered.

Through Open Quantum

openquantum:ionq: devices go through Open Quantum and spend credits from an Open Quantum account linked to qBraid, not qBraid credits. Link the account first, then submit as usual:

device = provider.get_device("openquantum:ionq:qpu:forte-1")
job = device.run(bell, shots=100)

See Open Quantum for linking an account and what these devices accept.