Nivel gratuito de IBM Quantum: todo lo que puedes usar en 2026

IBM Quantum tiene el nivel gratuito más accesible de la industria de la computación cuántica. Con un IBM ID gratuito, obtienes acceso a procesadores cuánticos reales de hasta 127 qubits: sin coste, sin tarjeta de crédito, sin necesidad de solicitud. Aquí tienes exactamente lo que eso significa en la práctica.

Qué incluye el nivel gratuito

El Open Plan de IBM Quantum te ofrece:

• Acceso ilimitado a todos los sistemas cuánticos disponibles públicamente
• 10 minutos de tiempo cuántico al mes (el tiempo que tus circuitos están ejecutándose activamente en la QPU)
• Acceso a los simuladores de IBM sin límite de tiempo (statevector, QASM, matrix product state)
• Qiskit Runtime: el entorno de ejecución moderno de IBM para circuitos
• Plataforma IBM Quantum Learning con tutoriales y cursos

El límite mensual de 10 minutos suena restrictivo, pero en la práctica la mayoría de los circuitos de investigación se ejecutan en milisegundos de tiempo real de QPU. Rara vez se alcanza el límite en el caso de desarrolladores individuales que experimentan con algoritmos cuánticos.

QPU gratuitas disponibles

A principios de 2026, el Open Plan de IBM incluye acceso a:

IBM retira y añade sistemas con regularidad. Usa el servicio Qiskit Runtime para ver la lista actual:

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}")

Configuración en 10 minutos

Paso 1: Crea tu cuenta gratuita

Ve a quantum.ibm.com y crea un IBM ID gratuito. No se requiere información de pago.

Paso 2: Instala el SDK

pip install qiskit qiskit-ibm-runtime

Paso 3: Guarda tus credenciales

Después de iniciar sesión en el panel de IBM Quantum, copia tu token de API desde la página de la cuenta (Account).

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
)

Tus credenciales se guardan en ~/.qiskit/qiskit-ibm.json: no tendrás que volver a hacerlo.

Paso 4: Envía tu primer trabajo

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())

Cómo entender los tiempos de espera

El tiempo de espera en cola es la frustración más común con el nivel gratuito. Esto es lo que ocurre:

• Estás compartiendo la QPU con todos los demás usuarios del Open Plan a nivel mundial
• Los trabajos se ponen en cola por sistema; least_busy() ayuda a encontrar la espera más corta
• Espera típica: de 5 minutos a 2 horas según la carga del sistema

Consejos para minimizar el tiempo de espera:

• Ejecuta durante las horas de menor actividad (mañana europea = noche americana)
• Usa service.least_busy() en lugar de apuntar a un sistema específico
• Para el desarrollo, usa el simulador Aer localmente; envía a hardware real solo para la validación final
• Agrupa varios circuitos en un único trabajo usando la entrada de lista de SamplerV2

Usar en su lugar los simuladores gratuitos en la nube

Para la mayor parte del trabajo de desarrollo, los simuladores alojados en la nube de IBM son más rápidos que hacer cola para el hardware real:

# 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")

Estos simuladores no tienen tiempo de espera en cola y se ejecutan al instante. Usa QPU reales cuando necesites características de ruido reales o quieras hacer benchmarks en hardware real.

Usar HLQuantum con IBM Quantum

Si estás usando varios SDK, HLQuantum ofrece una interfaz más limpia para el hardware de IBM:

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 se encarga automáticamente de la transpilación, el envío de trabajos y el análisis de resultados. Consulta la guía completa del SDK de Qiskit para conocer la configuración avanzada.