qcr:2606.49260.1

Running Qiskit on Amazon Braket

Qiskit is one of the most widely used open-source quantum SDKs, and this notebook shows how to run Qiskit circuits on Amazon Braket's simulators and quantum hardware through the qiskit-braket-provider, letting users keep their familiar Qiskit workflow while accessing Braket's managed backends. The provider exposes Braket devices as standard Qiskit backends, so a circuit written with Qiskit's QuantumCircuit can be submitted to a Braket on-demand simulator or QPU with minimal changes, and results come back in Qiskit's native format. The notebook walks through the integration end to end: installing and configuring the qiskit-braket-provider, listing the available Braket backends, building a circuit with Qiskit, transpiling and submitting it to a chosen Braket device, and retrieving and interpreting the results. It highlights how this interoperability lets teams mix tools, for example developing in Qiskit while running on hardware available through Braket, and supports portability across the quantum software ecosystem. It is a practical introduction to cross-framework execution, connecting Qiskit and the Amazon Braket SDK so that Qiskit programs run on Braket's cloud-accessible devices.

Qubit

Circuit-based

Uploaded 4 months ago

Views

GitHub

588

Citing this entry? Use this QCR ID

Uploaded by

QCR Librarian

amazon-braket/amazon-braket-examples

588

264

In [ ]:

# --- Setup cell added by QCR (not part of the original tutorial) ---
# Source: amazon-braket/amazon-braket-examples @ 0c0818f315479aab9deebed7e7ed7533ac581923, Apache License 2.0.
# Installs the example's dependencies. If a later cell still reports a missing
# package, restart the runtime/kernel and run again from the top.
%pip install -q amazon-braket-sdk==1.117.3 qiskit==2.4.1 qiskit-braket-provider==0.14.4 qiskit-algorithms

How to run Qiskit on Amazon Braket

If you're like many people who learned quantum computing in the past several years, you might have learned how to program quantum circuits with Qiskit: the open-source quantum Software Development Kit (SDK) first released in 2017.

With the Qiskit-Braket provider, you can run your Qiskit code across any of the gate-based devices on the Amazon Braket quantum computing service. You can also use the Qiskit-Braket provider to enhance Braket applications and access features like easy compilation to native gates and device connectivities.

[!IMPORTANT] Further details and documentation for using the Qiskit-Braket provider can be found at the Qiskit-Braket Provider how-to and tutorials pages.

[!NOTE] if you're running this in your local development environment (i.e. not from the Braket console), you'll need to make sure you've got your AWS account configured properly first to access Braket devices. Check out this tutorial for a walkthrough.

In [1]:

# Use Braket SDK Cost Tracking to estimate the cost to run this example
from braket.tracking import Tracker

tracker = Tracker().start()

Access Braket devices from Qiskit

There are quite a few different backend devices on Amazon Braket, so we'll walk through them one by one and give an example of recommended use cases for each.

Quantum simulators

Let's start with the local simulator. This is a quantum full state vector simulator which runs locally -- that means wherever you're running this Jupyter notebook (e.g. your local development environment or a notebook instance on the Braket console).

Recommended use case: Noiseless circuits up to ~12 qubits

In [2]:

from qiskit_braket_provider import BraketLocalBackend

local_simulator = BraketLocalBackend()

Next, we have the local density matrix simulator. This simulator also runs on your local machine, but allows you to simulate the effects of noise on your quantum circuit. Because density matrices are twice the size of state vectors, the number of qubits you can effectively simulate is half the size as the local state vector simulator.

Recommended use case: Noisy circuits up to ~6 qubits

In [3]:

local_dm_simulator = BraketLocalBackend(name="braket_dm")

Now let's look at Braket's on-demand simulators: these run on AWS computing resources and have some expanded features in addition to those of the local simulator. We can list all the available Braket simulators with the following code:

In [4]:

from qiskit_braket_provider import BraketProvider

provider = BraketProvider()

provider.backends(statuses=["ONLINE"], types=["SIMULATOR"])

[BraketBackend[SV1], BraketBackend[TN1], BraketBackend[dm1]]

First up for on-demand simulators is SV1. This is a full state vector simulator which allows you to simulate larger circuits than the local simulator, along with the ability to batch tasks and run them in parallel, as well as use advanced techniques like adjoint gradient calculations for variational quantum algorithms.

Recommended use case: Noiseless variational algorithms on up to 34 qubits

In [5]:

sv1 = provider.get_backend("SV1")

The next on-demand simulator is DM1. This is a density matrix simulator which, like SV1, allows you to simulate a larger number of qubits, as well as take advantage of batch execution.

Recommended use case: Noisy variational algorithms on up to 17 qubits

In [6]:

dm1 = provider.get_backend("dm1")

Lastly for on-demand simulators, we have TN1. This is a tensor-network simulator, which represents each gate in a circuit as a tensor. TN1 can simulate a larger number of qubits for circuits with local gates or other special structure, but will typically be slower than SV1 or DM1 for circuits with long-range or all-to-all gate structure.

Recommended use case: Noiseless quantum circuits with local connectivity and up to 50 qubits

Note: Each AWS resource, (like a file or CPU or QPU) lives in a specific region and may only be accessible from that region. For example, TN1 is only available in the eu-west-2, us-east-1, and us-west-2 regions.

To change your AWS region if you're running in a managed notebook, you'll need to use the GUI in the top right hand corner of the AWS console to select your new region, then relaunch or create your notebook from the Braket console.

To change your AWS region if you're running in your local development environment, you run the following code snippet:

import os
os.environ["AWS_REGION"] = "your-desired-region"

In [7]:

# If you've switched to one of the regions where TN1 is accessible, feel free to uncomment the following code
# tn1 = provider.get_backend("TN1")

Quantum Processing Units (QPUs)

Amazon Braket also provides access to a number of third-party quantum hardware devices. The following code shows how to view the supported QPUs which are currently online:

In [9]:

provider.backends()

[BraketBackend[Cepheus-1-108Q],
 BraketBackend[Emerald],
 BraketBackend[Forte Enterprise 1],
 BraketBackend[Garnet],
 BraketBackend[IBEX Q1]]

For a closer look at each quantum computer, you can peruse the Providers Overview on the Braket homepage, or the Devices tab on the left side of the Braket console. Currently only gate-based QPUs (IonQ, Rigetti) are supported with the Qiskit-Braket provider.

Running circuits on Braket devices

Now that we've walked through each of the quantum devices available through the Qiskit-Braket provider, let's take them for a spin! For this example, we'll create a 3-GHZ state on the Rigetti device, but feel free to choose a different QPU from the commented out devices below.

In [9]:

qpu_backend = provider.get_backend("Cepheus-1-108Q")
# qpu_backend = provider.get_backend("Garnet")
# qpu_backend = provider.get_backend("Forte enterprise 1")

print(qpu_backend)
print(type(qpu_backend))

BraketBackend[Cepheus-1-108Q]
<class 'qiskit_braket_provider.providers.braket_backend.BraketAwsBackend'>

In [10]:

from qiskit import QuantumCircuit

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

     ┌───┐          
q_0: ┤ H ├──■────■──
     └───┘┌─┴─┐  │  
q_1: ─────┤ X ├──┼──
          └───┘┌─┴─┐
q_2: ──────────┤ X ├
               └───┘

In [11]:

# run circuit
qpu_task = qpu_backend.run(circuit, shots=100, optimization_level = 2)

Each quantum task you run is assigned a unique ARN (Amazon Resource Name), which you can save and use to retrieve the data for your quantum task after its run, even if you close your notebook.

In [12]:

task_id = qpu_task.task_id()
task_id

'arn:aws:braket:us-west-1:641737106670:quantum-task/98b2d6c2-f82c-44cb-8577-18a36c382911'

Now, Braket has a separate feature called "Hybrid Jobs", which is beyond the scope of this notebook, but which you can read about in the developer guide.

In [13]:

# Retrieve quantum task data
retrieved_task = qpu_backend.retrieve_job(task_id=task_id)

Then you can check the status of the task to see if it's finished:

In [14]:

retrieved_task.status()

<JobStatus.QUEUED: 'job is queued'>

Note: different devices may have different availability windows, so while your task may not run right away, rest assured it will be added to the queue to be run when the device is back online.

When your task is finished, you can retrieve the data:

In [15]:

data = retrieved_task.result()

In [16]:

from qiskit.visualization import plot_histogram

plot_histogram(data.get_counts())

Running algorithms on Braket devices

You can also use the Qiskit-Braket provider to run built-in Qiskit algorithms on Braket backends. For example, we can run the VQE algorithm to find the ground state of hydrogen. We'll use the local simulator since the problem can be expressed in a basis that only requires a few qubits and will run quickly.

The qiskit-braket-provider provides a built in BraketEstimator, which can be initialized with Braket based backends, and supports generic PUB inputs. Additionally, this works well with existing Qiskit applications expecting estimators.

In [17]:

from qiskit.quantum_info import SparsePauliOp

# Define the Hamiltonian operator for H2 in terms of Pauli spin operators
H2_op = SparsePauliOp.from_list(
    [
        ("II", -1.052373245772859),
        ("IZ", 0.39793742484318045),
        ("ZI", -0.39793742484318045),
        ("ZZ", -0.01128010425623538),
        ("XX", 0.18093119978423156),
    ],
)

In [18]:

# Import some utilities
from qiskit.circuit.library import n_local
from qiskit_algorithms import VQE
from qiskit_algorithms.optimizers import SLSQP
from qiskit_braket_provider import BraketEstimator

# Define a `BackendEstimatorV2` with a Braket backend
qi = BraketEstimator(backend=local_simulator)

# Specify VQE configuration
ansatz = n_local(2, rotation_blocks="ry", entanglement_blocks="cz")
slsqp = SLSQP(maxiter=1)
vqe = VQE(estimator=qi, ansatz=ansatz, optimizer=slsqp)

# Find the ground state
result = vqe.compute_minimum_eigenvalue(H2_op)
print(result)

{   'aux_operators_evaluated': None,
    'cost_function_evals': 9,
    'eigenvalue': np.float64(-1.0227272710447532),
    'optimal_circuit': <qiskit.circuit.quantumcircuit.QuantumCircuit object at 0x127907da0>,
    'optimal_parameters': {   ParameterVectorElement(θ[1]): np.float64(0.3481839901685849),
                              ParameterVectorElement(θ[3]): np.float64(-2.3137368060174164),
                              ParameterVectorElement(θ[5]): np.float64(-4.083041670115152),
                              ParameterVectorElement(θ[7]): np.float64(-0.3827282855372018),
                              ParameterVectorElement(θ[2]): np.float64(-3.3935252085536916),
                              ParameterVectorElement(θ[6]): np.float64(-4.1405070428668145),
                              ParameterVectorElement(θ[4]): np.float64(-0.9929145136859857),
                              ParameterVectorElement(θ[0]): np.float64(-4.970454583099686)},
    'optimal_point': array([-4.97045458,  0.34818399, -3.39352521, -2.31373681, -0.99291451,
       -4.08304167, -4.14050704, -0.38272829]),
    'optimal_value': np.float64(-1.0227272710447532),
    'optimizer_evals': None,
    'optimizer_result': <qiskit_algorithms.optimizers.optimizer.OptimizerResult object at 0x1279044d0>,
    'optimizer_time': 1.3014230728149414}

Summary

In this notebook we saw the basics of using the Qiskit-Braket Provider for accessing Amazon Braket devices using Qiskit and expanding available tools for Braket users. If you run into a bug or want a new feature supported, consider submitting a GitHub issue and opening a feature branch to join in on the development effort yourself!

In [21]:

print("Quantum Task Summary")
print(tracker.quantum_tasks_statistics())
print(
    "Note: Charges shown are estimates based on your Amazon Braket simulator and quantum processing unit (QPU) task usage."
    "Estimated charges shown may differ from your actual charges. Estimated charges do not factor in any discounts or credits,"
    " and you may experience additional charges based on your use of other services such as Amazon Elastic Compute Cloud (Amazon EC2)."
)
print(
    f"Estimated cost to run this example: {tracker.qpu_tasks_cost() + tracker.simulator_tasks_cost():.2f} USD",
)

Quantum Task Summary
{'arn:aws:braket:us-west-1::device/qpu/rigetti/Cepheus-1-108Q': {'shots': 100, 'tasks': {'COMPLETED': 1}}}
Note: Charges shown are estimates based on your Amazon Braket simulator and quantum processing unit (QPU) task usage.Estimated charges shown may differ from your actual charges. Estimated charges do not factor in any discounts or credits, and you may experience additional charges based on your use of other services such as Amazon Elastic Compute Cloud (Amazon EC2).
Estimated cost to run this example: 0.39 USD

Join the Discussion

Comments (0)

No comments yet. Be the first to share your thoughts!

Indexed by QCR Librarian

This entry was created automatically from publicly available records. QCR links to public sources and only stores repository content where the license permits redistribution.

Claim this entry →

Versions

v1 Latest

Jun 16, 2026

qcr:2606.49260.1

Cite all versions? Use the base QCR ID to always reference the latest version of this entry.

Tools used

Amazon Braket SDK

Keywords

qiskit

interoperability

braket

provider

cross-framework