START NOW
ProvidersQudoraProvider
Providers

QudoraProvider

Runtime integration for direct access to QUDORA trapped-ion quantum systems via the QUDORA Cloud REST API.

API Reference: qbraid.runtime.qudora

Overview

The qbraid.runtime.QudoraProvider provides direct access to QUDORA trapped-ion quantum systems through the QUDORA Cloud REST API (https://api.qudora.com). You can write quantum circuits in Qiskit, Cirq, or any other qBraid-supported framework; the provider transpiles them to OpenQASM and submits the program string directly to the QUDORA Cloud, which compiles it server-side — all from within the qBraid Runtime framework.

This is a direct-REST, dependency-free integration: there is no vendor SDK to install. QUDORA’s Cloud API accepts OpenQASM 2 and OpenQASM 3 strings directly, and the language is auto-detected from each program’s header.

QUDORA devices are also available through the qBraid platform — accessed with QbraidProvider as a separate access point with its own device ids. The current QUDORA backends are simulators and are free to use — no qBraid credits are charged.

Getting started

Before you begin, make sure you have:

  1. A QUDORA Cloud account.
  2. A QUDORA API token (a Bearer token generated from the QUDORA cloud console).
  3. Python >= 3.10

Set up the qBraid-SDK

Install qBraid from PyPI using pip:

pip install qbraid

QUDORA support requires no extra dependencies — OpenQASM 2 / OpenQASM 3 transpilation and pyqasm validation are part of the qBraid core.

Note: The qBraid-SDK requires Python 3.10 or greater. You can check your Python version by running python --version from the command line.

Authentication

The QudoraProvider authenticates to the QUDORA Cloud with a Bearer API token. Provide it via an environment variable:

export QUDORA_API_TOKEN="your-api-token"

Then initialize the provider:

from qbraid.runtime.qudora import QudoraProvider

provider = QudoraProvider()

You can also pass the token directly instead of using the environment variable, and optionally override the API base URL:

# token passed directly
provider = QudoraProvider(token="your-api-token")

# token with a custom base URL (defaults to https://api.qudora.com)
provider = QudoraProvider(token="your-api-token", base_url="https://api.qudora.com")

The base URL can also be set with the QUDORA_BASE_URL environment variable. When neither the argument nor the variable is provided, it defaults to https://api.qudora.com.

List available devices

Use the QudoraProvider to list the devices to which you have access:

from qbraid.runtime.qudora import QudoraProvider

provider = QudoraProvider()

devices = provider.get_devices()
print(devices)

QUDORA devices are addressed by the backend’s username. Get a specific device by its id:

device = provider.get_device("<device-id>")

print(device.status())
# <DeviceStatus.ONLINE>

Use get_devices() to discover the exact device ids you have access to. QUDORA’s current backends are trapped-ion simulators — Qamelion (32 qubits) and the QVLS-Q1 Emulator (20 qubits). See QUDORA’s available backends for the up-to-date list and their specifications.

Submitting jobs

The QudoraProvider accepts circuits written in any qBraid-supported framework. device.run() transpiles the circuit to an OpenQASM string, validates it with pyqasm, and submits it to the QUDORA Cloud, which compiles it server-side.

Create a circuit

from qiskit import QuantumCircuit

# Bell state circuit
circuit = QuantumCircuit(2)
circuit.h(0)
circuit.cx(0, 1)
circuit.measure_all()

Run a job

Use device.run() to transpile and submit a circuit:

from qiskit import QuantumCircuit
from qbraid.runtime.qudora import QudoraProvider

provider = QudoraProvider()
device = provider.get_device("<device-id>")

circuit = QuantumCircuit(2)
circuit.h(0)
circuit.cx(0, 1)
circuit.measure_all()

job = device.run(circuit, shots=100)
print(f"Job ID: {job.id}")

Batch submission

Submit multiple circuits in a single call. All circuits are bundled into one QUDORA job, subject to the device’s max_programs_per_job limit:

from qiskit import QuantumCircuit
from qbraid.runtime.qudora import QudoraProvider

provider = QudoraProvider()
device = provider.get_device("<device-id>")

qc1 = QuantumCircuit(1)
qc1.h(0)
qc1.measure_all()

qc2 = QuantumCircuit(2)
qc2.h(0)
qc2.cx(0, 1)
qc2.measure_all()

job = device.run([qc1, qc2], shots=100)
print(f"Job ID: {job.id}")

All programs in a single batch job must use the same OpenQASM version. When submitting a list of circuits, the returned measurement counts will be a list of dictionaries, one per circuit.

Simulator noise settings

QUDORA’s simulators accept per-job noise parameters through the backend_settings argument (see QUDORA’s noise model details for what each parameter controls). The accepted keys — and their defaults — are exposed by each backend’s settings schema, which you can inspect with device.available_settings():

# Discover the accepted backend settings and their defaults for this device
print(device.available_settings())

Pass the settings you want to override to device.run():

job = device.run(
    circuit,
    shots=100,
    backend_settings={
        "measurement_error_probability": 0.01,
        "single_qubit_gate_noise_strength": 0.001,
        "two_qubit_gate_noise_strength": 0.01,
        "dephasing_T2_time": 1.0,
    },
)

Use device.available_settings() to see which noise parameters a given backend supports and their default values, rather than assuming a fixed set of keys.

Retrieving results

result = job.result()

# Measurement counts
print(result.data.get_counts())
# {'00': 51, '11': 49}

# Job metadata
print(f"Device: {result.device_id}")
print(f"Job ID: {result.job_id}")
print(f"Success: {result.success}")

Check job status

from qbraid.runtime.enums import JobStatus

status = job.status()
print(status)
# <JobStatus.COMPLETED>

Cancel a job

job.cancel()

Cancellation targets queued or ongoing jobs. Jobs already in a terminal state (COMPLETED, FAILED, CANCELLED) cannot be cancelled.

Configuration options

The device.run() method accepts the following keyword arguments:

ParameterTypeDefaultDescription
shotsint100Number of measurement shots per program.
namestr"qbraid"Optional human-readable job label.
backend_settingsdict{}Optional QUDORA backend settings, such as the simulator noise parameters.

Credentials are configured via environment variables:

VariableDescription
QUDORA_API_TOKENBearer API token for the QUDORA Cloud, generated from the QUDORA cloud console.
QUDORA_BASE_URLOptional base URL override (defaults to https://api.qudora.com).

Full example

A complete end-to-end workflow submitting a GHZ state to a QUDORA device:

from qiskit import QuantumCircuit
from qbraid.runtime.qudora import QudoraProvider

# 1. Initialize provider (reads QUDORA_API_TOKEN from the environment)
provider = QudoraProvider()

# 2. Get a device by its id (discover ids with provider.get_devices())
device = provider.get_device("<device-id>")
print(f"Device status: {device.status()}")

# 3. Define a GHZ state circuit
circuit = QuantumCircuit(3)
circuit.h(0)
circuit.cx(0, 1)
circuit.cx(1, 2)
circuit.measure_all()

# 4. Submit the job
job = device.run(circuit, shots=100)
print(f"Submitted job: {job.id}")

# 5. Retrieve results
result = job.result()
print(f"Counts: {result.data.get_counts()}")
# Expected output (approximate): {'000': ~50, '111': ~50}
© 2026 qBraid