IBM Quantum Free Tier: Everything You Can Access in 2026

IBM Quantum has the most accessible free tier in the quantum computing industry. With a free IBM ID, you get access to real quantum processors with up to 127 qubits — no cost, no credit card, no application required. Here's exactly what that means in practice.

What the Free Tier Includes

The IBM Quantum Open Plan gives you:

• Unlimited access to all publicly available quantum systems
• 10 minutes of quantum time per month (time your circuits are actively running on QPU)
• Access to IBM simulators with no time limit (statevector, QASM, matrix product state)
• Qiskit Runtime — the modern IBM execution environment for circuits
• IBM Quantum Learning platform with tutorials and courses

The 10-minute monthly limit sounds restrictive, but in practice most research circuits run in milliseconds of actual QPU time. The limit is rarely hit by individual developers experimenting with quantum algorithms.

Available Free QPUs

As of early 2026, IBM's Open Plan includes access to:

IBM regularly retires and adds systems. Use the Qiskit Runtime service to see the current list:

from qiskit_ibm_runtime import QiskitRuntimeService

service = QiskitRuntimeService(channel="ibm_quantum")
backends = service.backends(
    operational=True,
    simulator=False,
    min_num_qubits=1
)
for b in backends:
    print(f"{b.name}: {b.num_qubits} qubits, status: {b.status().status_msg}")

Setting Up in 10 Minutes

Step 1: Create Your Free Account

Go to quantum.ibm.com and create a free IBM ID. No payment information is required.

Step 2: Install the SDK

pip install qiskit qiskit-ibm-runtime

Step 3: Save Your Credentials

After logging in to the IBM Quantum dashboard, copy your API token from the Account page.

from qiskit_ibm_runtime import QiskitRuntimeService

# Run this once to save your token locally
QiskitRuntimeService.save_account(
    channel="ibm_quantum",
    token="YOUR_API_TOKEN_HERE",
    overwrite=True
)

Your credentials are saved to ~/.qiskit/qiskit-ibm.json — you won't need to do this again.

Step 4: Submit Your First Job

from qiskit import QuantumCircuit
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
from qiskit_ibm_runtime import QiskitRuntimeService, SamplerV2 as Sampler

# Build a Bell state
qc = QuantumCircuit(2, 2)
qc.h(0)
qc.cx(0, 1)
qc.measure([0, 1], [0, 1])

# Connect and pick the least-busy free QPU
service = QiskitRuntimeService(channel="ibm_quantum")
backend = service.least_busy(
    operational=True,
    simulator=False,
    min_num_qubits=2
)
print(f"Submitting to: {backend.name}")

# Transpile for the target device
pm = generate_preset_pass_manager(backend=backend, optimization_level=1)
isa_qc = pm.run(qc)

# Submit
sampler = Sampler(mode=backend)
job = sampler.run([isa_qc], shots=1024)

print(f"Job ID: {job.job_id()}")
print(f"Status: {job.status()}")
result = job.result()
print(result[0].data.c.get_counts())

Understanding Queue Times

Queue time is the most common frustration with the free tier. Here's what's happening:

• You're sharing the QPU with all other Open Plan users globally
• Jobs are queued per system — least_busy() helps find the shortest wait
• Typical wait: 5 minutes to 2 hours depending on system load

Tips to minimize queue time:

• Run during off-peak hours (European morning = American night)
• Use service.least_busy() rather than targeting a specific system
• For development, use the Aer simulator locally — submit to real hardware only for final validation
• Batch multiple circuits into a single job using SamplerV2's list input

Using Free Cloud Simulators Instead

For most development work, IBM's cloud-hosted simulators are faster than queuing for real hardware:

# IBM cloud QASM simulator (up to 32 qubits, no queue)
backend = service.backend("ibmq_qasm_simulator")

# Or use the Statevector simulator (exact simulation)
backend = service.backend("simulator_statevector")

These simulators have no queue time and run instantly. Use real QPUs when you need actual noise characteristics or want to benchmark on real hardware.

Using HLQuantum with IBM Quantum

If you're using multiple SDKs, HLQuantum provides a cleaner interface to IBM hardware:

import hlquantum as hlq

qc = hlq.Circuit(2)
qc.h(0).cx(0, 1).measure_all()

# Run on IBM's free QPU
result = hlq.run(
    qc,
    backend="qiskit",
    device="ibm_sherbrooke",  # or use "auto" for least busy
    shots=1024,
    error_mitigation="zne"
)
print(result)

HLQuantum handles transpilation, job submission, and result parsing automatically. See the full Qiskit SDK guide for advanced configuration.