Full Reference →

Braket Cheat Sheet

Install: pip install amazon-braket-sdk

Background and History

Amazon Braket was announced at AWS re:Invent in December 2019 and entered general availability in August 2020. The service was AWS’s entry into the quantum computing market, taking a vendor-neutral cloud approach rather than building proprietary quantum hardware. The name “Braket” references bra-ket notation, the standard mathematical formalism used in quantum mechanics. The Braket Python SDK, which provides the Circuit class and device interfaces covered in this reference, was open-sourced on GitHub alongside the service launch.

Amazon Braket’s core value proposition is unified access to multiple quantum hardware providers through a single API. At launch, the service offered processors from three vendors: superconducting qubits from Rigetti, trapped ions from IonQ, and quantum annealers from D-Wave. Over time, AWS added support for additional providers, including Oxford Quantum Circuits (OQC), QuEra’s neutral atom processor Aquila, and IQM’s superconducting systems. The lineup rotates as devices are retired: D-Wave left the platform in 2022 and OQC access ended in mid-2024, while the current provider set includes IonQ, IQM, Rigetti, AQT, and QuEra. This multi-vendor model allows researchers and developers to benchmark algorithms across different hardware modalities without managing separate accounts and SDKs for each provider.

The SDK itself is a lightweight Python library that handles circuit construction, device management, and result retrieval. It was designed to be straightforward for developers already familiar with AWS infrastructure, using standard AWS patterns like S3 for result storage, IAM for access control, and CloudWatch for monitoring. The Hybrid Jobs feature, introduced in 2021, provides managed classical-quantum compute environments for iterative algorithms like VQE and QAOA, with co-located classical instances that reduce round-trip latency to quantum hardware.

As of 2026, Amazon Braket remains actively maintained and is one of the primary paths for enterprise teams to access quantum computing within existing AWS workflows. The Braket SDK has accumulated a moderate open-source community, though its adoption is concentrated among organizations already invested in the AWS ecosystem. AWS has also invested in the Amazon Quantum Solutions Lab, a consultancy program that uses Braket as its technical foundation.

Installation

pip install amazon-braket-sdk

For local simulation without AWS credentials:

pip install amazon-braket-default-simulator

Key Imports

from braket.circuits import Circuit, Gate, Qubit
from braket.devices import LocalSimulator
from braket.aws import AwsDevice

Devices

Braket separates local simulators (free, no AWS) from cloud devices (billed per task).

Local simulators

from braket.devices import LocalSimulator

device = LocalSimulator()                         # default statevector
device = LocalSimulator('braket_sv')              # statevector
device = LocalSimulator('braket_dm')              # density matrix
device = LocalSimulator('braket_ahs')             # analog Hamiltonian

AWS managed simulators

from braket.aws import AwsDevice

device = AwsDevice("arn:aws:braket:::device/quantum-simulator/amazon/sv1")   # SV1 statevector
device = AwsDevice("arn:aws:braket:::device/quantum-simulator/amazon/tn1")   # TN1 tensor network
device = AwsDevice("arn:aws:braket:::device/quantum-simulator/amazon/dm1")   # DM1 density matrix

Real hardware

# IQM (superconducting)
device = AwsDevice("arn:aws:braket:eu-north-1::device/qpu/iqm/Garnet")

# IonQ (trapped ion)
device = AwsDevice("arn:aws:braket:us-east-1::device/qpu/ionq/Forte-1")

# QuEra (neutral atom)
device = AwsDevice("arn:aws:braket:us-east-1::device/qpu/quera/Aquila")

Circuit Construction

Braket circuits use method chaining - each gate method returns the circuit.

from braket.circuits import Circuit

circuit = Circuit()
circuit.h(0)                 # Hadamard on qubit 0
circuit.cnot(0, 1)           # CNOT, control=0, target=1
circuit.measure([0, 1])      # explicit measurement (optional for simulators)

Chained style:

circuit = Circuit().h(0).cnot(0, 1)

Gates

circuit.h(qubit)             # Hadamard
circuit.x(qubit)             # Pauli-X
circuit.y(qubit)             # Pauli-Y
circuit.z(qubit)             # Pauli-Z
circuit.s(qubit)             # S gate
circuit.t(qubit)             # T gate
circuit.cnot(control, target) # CNOT
circuit.cz(q1, q2)           # Controlled-Z
circuit.swap(q1, q2)         # SWAP
circuit.ccnot(q1, q2, q3)    # Toffoli

# Rotation gates (angles in radians)
circuit.rx(qubit, angle)
circuit.ry(qubit, angle)
circuit.rz(qubit, angle)

# Arbitrary unitary
import numpy as np
circuit.unitary(matrix=np.eye(2), targets=[0])

Running Circuits

Local simulation

from braket.devices import LocalSimulator

device = LocalSimulator()
task = device.run(circuit, shots=1000)
result = task.result()

print(result.measurement_counts)   # {'00': 503, '11': 497}
print(result.measurements)         # raw 2D array
print(result.measurement_probabilities)

Cloud execution

from braket.aws import AwsDevice, AwsSession

device = AwsDevice("arn:aws:braket:::device/quantum-simulator/amazon/sv1")
task = device.run(circuit, s3_destination_folder=('my-bucket', 'results'), shots=100)

# Task runs asynchronously - poll for result
result = task.result()
print(result.measurement_counts)

Task status

task.state()       # 'RUNNING', 'COMPLETED', 'FAILED', etc.
task.cancel()      # cancel a queued task

Common Patterns

Bell state

from braket.circuits import Circuit
from braket.devices import LocalSimulator

circuit = Circuit().h(0).cnot(0, 1)
device = LocalSimulator()
result = device.run(circuit, shots=1000).result()
print(result.measurement_counts)

Statevector (no shots)

circuit = Circuit().h(0).cnot(0, 1)
circuit.state_vector()         # register a statevector result type
device = LocalSimulator()
result = device.run(circuit, shots=0).result()
print(result.values[0])        # statevector amplitudes

Running with shots=0 requires at least one result type (such as state_vector(), probability(), or expectation()) on the circuit.

Parameterised circuits

from braket.circuits import FreeParameter

angle = FreeParameter('angle')
circuit = Circuit().h(0).rx(0, angle)

result = device.run(circuit, shots=100, inputs={'angle': 1.57}).result()

Noise simulation

from braket.circuits import Circuit
from braket.circuits.noises import BitFlip, Depolarizing
from braket.devices import LocalSimulator

circuit = Circuit().h(0).bit_flip(0, 0.01).cnot(0, 1)
device = LocalSimulator('braket_dm')
result = device.run(circuit, shots=1000).result()

Result Object

result.measurement_counts          # dict: bitstring → count
result.measurements                # numpy array of shape (shots, n_qubits)
result.measurement_probabilities   # dict: bitstring → probability
result.values                      # raw result data (statevector, etc.)

Gotchas

  • Device ARNs are region-locked: the region string embedded in the ARN must match the AWS region your session is configured for, or AwsDevice() fails with a “device not found” error even though the ARN is correctly formatted.
  • Cloud tasks bill per task plus per shot, and that adds up quickly on iterative loops like VQE or QAOA. Develop and debug the ansatz on LocalSimulator first, then switch to SV1 or hardware only for the runs you actually need.
  • shots=0 only works if the circuit registers an explicit result type such as state_vector() or probability(); without one the call errors out instead of silently returning nothing.