Skip to main contentIBM Quantum Documentation
Important

IBM Quantum Platform is moving and this version will be sunset on July 1. To get started on the new platform, read the migration guide.

Latest updates

Last updated 9 June 2025

Keep up with the latest and greatest from Qiskit and IBM Quantum®!

For all product announcements, visit the Announcements page on IBM Quantum Platform Classic.

Jump to Qiskit SDK | Qiskit Runtime client | Qiskit Runtime service | Qiskit Transpiler service | Qiskit Serverless | Qiskit Functions | Qiskit Code Assistant | Documentation

Qiskit SDK v2.0

31 Mar 2025

Qiskit SDK v2.0 introduces significant performance improvements over its predecessor, and lays the groundwork for powerful new tools and capabilities that we plan to share in the coming months. Highlights include:

  • A brand new C API - This major release introduces a C-language API to interact with the SparseObservable class. This new functionality is just the first step toward building a robust C interface for the Qiskit SDK, and you can expect major expansions of the new C interface as we progress through the rest of the v2.x series. We believe this work will play an important role in supporting large-scale quantum experimentation and enabling the hunt for quantum advantage.
  • Removal of deprecated features - Many of the minor releases in the previous v1.x series included new deprecation warnings to make room for us to continue improving the SDK. In this major release, all of the deprecated classes, functions, and modules are now being removed.
  • Continued performance improvements - We have continued work on porting more of the Qiskit SDK functionality over to Rust, resulting in a 2x speedup for circuit construction benchmarking tasks and a roughly 20% speedup for transpilation benchmarking tasks.
  • Introducing boxes and stretches - Qiskit SDK v2.0 introduces helpful new features for structuring your circuits in preparation for future changes to dynamic circuits on IBM QPUs.

Wondering what has changed? Read the changelog and the v2.0 release notes.

To see the release notes for all versions, visit the Qiskit SDK release notes.

Qiskit Runtime client 0.40.0

28 May 2025

New features

  • The following changes were made to support the upcoming IBM Quantum platform migration:

    • A new channel type, ibm_quantum_platform, has been introduced for service initialization (QiskitRuntimeService()). It joins the existing ibm_quantum (now deprecated) and ibm_cloud channels. By default, ibm_quantum_platform is selected when no channel is specified. This new channel connects to the new IBM Quantum Platform API and is intended to replace ibm_cloud. In the meantime, the ibm_cloud channel will redirect to the new API, but its continued use is discouraged.

    • An instance value is no longer required for saving (QiskitRuntimeService.save_account()) or initializing (QiskitRuntimeService()) an account on the new platform (ibm_quantum_platform, and temporarily, ibm_cloud channels). If an instance is not passed in, all instances will be checked when a backend is retrieved, (service.backend("backend_name")). If an instance is passed into QiskitRuntimeService.save_account(), or passed in during initialization, it will be used as the default instance when retrieving backends. The instance passed in at initialization will take precedence over the one saved in the account.

    • Note that the IBM Cloud API Token (token) is required for saving (QiskitRuntimeService.save_account()) or initializing (QiskitRuntimeService()) an account on the new platform. It’s treated as the account identifier and will unlock the resources associated with the account the token was created in. A list of tokens per account can be found here. Only one account per API token can be used. If you want to use multiple accounts, you must create multiple API tokens.

    • The QiskitRuntimeService.backend() and QiskitRuntimeService.backends() methods have been updated to accept an instance passed in explicitly when retrieving backends: service.backend(name="...", instance="...").

    • New parameters, region and plans_preference, have been added to the QiskitRuntimeService initializer and QiskitRuntimeService.save_account() method. These can be used to prioritize certain instances on the new platform (ibm_quantum_platform, and temporarily, ibm_cloud channels) without explicitly providing the CRN. In more detail:

      • region: Sets a region preference. us-east or eu-de.
      • plans_preference: Is a list of account types, ordered by preference. An instance of the first type in the list will be prioritized.

      For example, if region is saved as us-east, only instances from us-east will be checked. If plans_preference is set, the instances will be prioritized in the order given, so ['Open', 'Premium'] would prioritize all Open Plan instances, then all Premium Plan instances, and then the rest. Note that the plan names in plans_preference must exactly match the API names (case insensitive).

    • The instance input parameter of QiskitRuntimeService has been extended to accept new input types for the ibm_quantum_platform and ibm_cloud channels. In addition to the IBM Cloud Resource Name (CRN), the instance name can now be passed in as the instance value.

    • The instances() method has been extended to show all available instances associated to an account for the ibm_quantum_platform and ibm_cloud channels, in addition to the already enabled ibm_quantum channel.

      The following code snippets show the new usage patterns enabled by the changes described above (2239):

      # save account
service = QiskitRuntimeService.save_account(
  # No channel needs to be specified, ibm_quantum_platform is the default
  token=token,
  region="eu-de", # Optional
  plans_preference=['Open',...], #Optional
  set_as_default=True  #Optional
  )
 
# initialize account
service = QiskitRuntimeService() # defaults to ibm_quantum_platform account
service.backend(name="...") # picks instance based on saved preferences
service.backend(name="...", instance="...") # can also explicity pass in an instance to use
 
# initialize account with instance
service = QiskitRuntimeService(instance = "...") # sets instance as default instance
service.backend(name="...") # only checks default instance, fails if the backend not in the instance
service.backend(name="...", instance="...") # can still explicity pass in a different instance
 
# OR
 
# save account with instance
service = QiskitRuntimeService.save_account(
  # No channel needs to be specified, ibm_quantum_platform is the default
  token=token,
  instance="..." # This will be the default instance
  region="us-east", # Optional
  plans_preference=['Open',...], #Optional
  set_as_default=True  #Optional
  )
 
# initialize account
service = QiskitRuntimeService() # defaults to ibm_quantum_platform account
service.backend(name="...") # only checks saved default instance from save_account
service.backend(name="...", instance="...") # can also explicity pass in an instance which takes precedence
 
# initializing account with instance works the same way
service = QiskitRuntimeService(instance = "...") # sets instance as default instance, overrides instance from save_account
service.backend(name="...") # only checks default instance, fails if the backend not in the instance
service.backend(name="...", instance="...") # can still explicity pass in a different instance

  • The private option under EnvironmentOptions is now supported on the ibm_cloud and ibm_quantum_platform channels (new IBM Quantum Platform). When this option is set to True, the job will be returned without parameters, and results can only be retrieved once.

    There is also a new private() property that returns whether or not a job is private. (2263)

Bug fixes

  • The call to defaults() in target() was removed because backend defaults are no longer used in the target generation. (2261)

To see the release notes for all versions, visit the Qiskit Runtime client release notes.

Qiskit Runtime service

This summary of the latest changes to the Qiskit Runtime service applies to anyone using Qiskit Runtime, regardless of how you communicate with the service (by using qiskit-ibm-runtime or otherwise), or which version of the client SDK you use.

5 June 2025

  • Now available: Early access to the new version of dynamic circuits on select QPUs. This new version will allow you to run dynamic circuits at utility scale and comes with improvements in speed, quality, and usability. Premium Plan and Flex Plan users interested in participating in this early access can contact us.

3 February 2025

  • Pulse-level control on all IBM Quantum processors has been removed. Additionally, the pulse module is scheduled for removal in Qiskit SDK v2.0. Instead, you can use fractional gates that are now built into the Instruction Set Architecture (ISA). For full details and help migrating your code, refer to Migrate from Qiskit Pulse to fractional gates.

2 February 2025

  • Starting 2 June 2025 and continuing through the year, IBM Quantum will begin a gradual rollout of new features to dynamic circuits that will enable them at the utility scale. Improvements include the following:

    • A 75x speedup in execution by using the Gen3 engine stack
    • Parallel execution of branches, which reduces circuit duration and improves result quality
    • Improvement in mid-circuit measurement
    • Better integration with dynamical decoupling
    • More visibility of circuit timing information

  • To accelerate the rollout, the following capabilities are now deprecated and will be no longer supported on or around 2 June 2025:

    • The while, for, and switch control flow constructs
    • The ability to use control flow instructions inside the body of a branch (as in, nested control flow)
    • Conditional measurements
Previous updates

7 January 2025

  • The rollout of the Gen3 engine stack begins today. This engine stack gives a 75x speedup in execution. The rollout will be done on one QPU at a time, where a percentage of the jobs on the QPU will use the Gen3 path. You can also force the Gen3 path using the gen3-turbo experimental option. Note that this engine stack is not compatible with fractional gates, pulse gates, or dynamic circuits.

15 October 2024

  • Support for backend.run has ended. See the appropriate migration guide if you have not yet migrated to using primitives.

1 October 2024

  • Parameterized delay gates have been deprecated.

15 August 2024

  • Probabilistic error amplification (PEA) error mitigation method is now available for Estimator V2. See the ZneOptions API reference for more details.
  • A new helper program noise-learner is now available. It allows characterizing the noise processes affecting the gates in one or more circuits of interest, based on the Pauli-Lindblad noise model. The output noise model can then be passed to Estimator via the layer_noise_model option.
  • V1 primitives are no longer supported.

3 July 2024

  • The following endpoints are deprecated and will be removed on or after 3 October 2024: GET /stream/jobs and GET /stream/jobs/{id}. This removal has the following impacts:

    • After the endpoints are removed, job.stream_results() and job.interim_results() will be removed from the qiskit-ibm-runtime client.
    • Additional methods, such as job.result() currently use the deprecated endpoints. Upgrade to qiskit_ibm_runtime 0.25 or later before the endpoints are removed to avoid disruption.

18 June 2024

  • The optimization_level option is deprecated for Estimator V2 and will be removed no sooner than 30 September 2024.

3 June 2024

  • Probabilistic error amplification (PEA) error mitigation method is now available as an experimental option for Estimator V2. See the EstimatorOptions API reference for more details.

28 March 2024

  • Qiskit Runtime primitives now support OpenQASM 3 as the input format for circuits and standard JSON output format. See Qiskit Runtime REST API for examples.

Qiskit Transpiler Service client v0.11.0

25 March 2025

To see the release notes for all versions, visit the Qiskit Transpiler Service client release notes.

Previous updates

  • Qiskit Transpiler Service client v0.3.0

    • The Qiskit Transpiler Service leverages IBM Cloud® resources to provide users with the latest transpilation capabilities from the Qiskit SDK. It offers a Python library that helps users seamlessly integrate the service into their current Qiskit patterns and workflows. Perhaps most importantly, the service invites users to experiment with new and improved AI-powered transpiler passes — cutting-edge tools that might be faster and produce better results than traditional transpilation methods. Read the blog for more information.

Qiskit Serverless

16 May 2025

  • Developers can set detailed statuses and track what's happening across a workflow.

    Serverless workloads have several stages across a workflow. By default, the following statuses are viewable with job.status():

    • QUEUED: The workload is queued for classical resources.
    • INITIALIZING: The workload is set up.
    • RUNNING: The workload is currently running on classical resources.
    • DONE: The workload has successfully completed.

    Now, you can also set custom statuses that further describe the specific workflow stage, as in the following example.

    Expand for code example
    from qiskit_serverless import update_status, Job
 
## If your function has a mapping stage, particularly application functions, you can set the status to "RUNNING: MAPPING" as follows:
update_status(Job.MAPPING)
 
## While handling transpilation, error suppression, and so forth, you can set the status to "RUNNING: OPTIMIZING_FOR_HARDWARE":
update_status(Job.OPTIMIZING_HARDWARE)
 
## After you submit jobs to Qiskit Runtime, the underlying quantum job will be queued. You can set status to "RUNNING: WAITING_FOR_QPU":
update_status(Job.WAITING_QPU)
 
## When the Qiskit Runtime job starts running on the QPU, set the following status "RUNNING: EXECUTING_QPU":
update_status(Job.EXECUTING_QPU)
 
## After the QPU is completed and post-processing has begun, set the status "RUNNING: POST_PROCESSING":
update_status(Job.POST_PROCESSING)

Qiskit Functions

5 June 2025

  • We're excited to roll out two new functions for finance and optimization:

    • QUICK-PDE by ColibriTD allows users to solve certain differential equations for material deformation and computational fluid dynamics problems. For example, one team of researchers has already begun using the QUICK-PDE function to study the dynamics of novel reactive fluids developed to transfer heat more efficiently in a type of nuclear reactor known as Small Modular Reactors.

    • Quantum Portfolio Optimizer by Global Data Quantum enables quantitative finance researchers to back-test portfolio optimization strategies. Running on over 100 qubits, this function calculates a portfolio’s Sharpe ratio versus return across a specified time period. Early users are exploring the optimizer’s ability to evaluate historical performance of an investment strategy and to enable comparisons of different portfolios under similar conditions.

Check out the Qiskit Functions Catalog to request a free trial today.

4 June 2025

  • New updates

    • Documentation for Singularity Machine Learning - Classification has been updated. View the Changelog.
Previous updates

16 May 2025

  • Over the coming weeks, every function will give detailed information to help you run, debug, and analyze your workflows. This includes:

    • When jobs fail, you can use job.error_message() to find specific error codes and messages to help you debug your workflows
    • job.status() will give more information on what's happening while a Function is RUNNING, including:
      • RUNNING: MAPPING
      • RUNNING: OPTIMIZING_FOR_HARDWARE
      • RUNNING: WAITING_FOR_QPU
      • RUNNING: EXECUTING_QPU
      • RUNNING: POST_PROCESSING
    • Finally, after a Qiskit Function is complete, you can inspect how much time is spent across each stage with job.result()['metadata']['resource_usage'], as in the following example.
    Expand for code example
    {
      ...,
  "metadata": {
    "resource_usage": {
      {
        "RUNNING: MAPPING": {
          "CPU_TIME": seconds,
          "GPU_TIME": seconds,
          "QPU_TIME": seconds,
        }, 
        "RUNNING: OPTIMIZING_FOR_HARDWARE": {
          "CPU_TIME": seconds,
          "GPU_TIME": seconds,
          "QPU_TIME": seconds,
        }, 
        "RUNNING: WAITING_FOR_QPU": {
          "CPU_TIME": seconds,
          "GPU_TIME": seconds,
          "QPU_TIME": seconds,
        }, 
        "RUNNING: EXECUTING_QPU": {
          "CPU_TIME": seconds,
          "GPU_TIME": seconds,
          "QPU_TIME": seconds,
        }, 
        "RUNNING: POST_PROCESSING": {
          "CPU_TIME": seconds,
          "GPU_TIME": seconds,
          "QPU_TIME": seconds,
        }, 
      }, 
    }
  }
}

    We're hoping these changes make it easier to use Qiskit Functions, and you can get started with free trials in the catalog today.

10 March 2025

To get started, explore the Qiskit Functions documentation.

16 September 2024

  • Introducing the Qiskit Functions preview, for IBM Quantum Premium Plan users. To get started, pip install qiskit-ibm-catalog and explore the Qiskit Functions documentation. With the Qiskit Functions Catalog client, you can submit workloads to abstracted services designed to accelerate your research. Sign in with your existing IBM Quantum Platform credentials.

    The Qiskit Functions Catalog preview provides access to Premium Plan users to explore the available functions, including those written by IBM and those written by other members of our ecosystem. The catalog contains two kinds of functions: circuit functions and application functions.

    • Circuit functions provide a simplified interface for running circuits. They receive user-provided abstract circuits and observables as input, then manage synthesis, optimization, and execution of the representative ISA circuit. Circuit functions bring together the latest capabilities in transpilation, error suppression, and error mitigation to make utility-grade performance accessible out of the box. This allows computational scientists to focus on mapping their problems to circuits, rather than building the pattern for each problem from scratch.

    • Application functions cover higher-level tasks, like exploring algorithms and domain-specific use cases. Enterprise developers and data scientists may not have the background quantum information science knowledge for working with circuits, and instead hope to bring their domain knowledge to advance quantum computing algorithms and applications. With application functions, users can enter their classical inputs and receive solutions so they can more easily experiment with plugging quantum into their domain-specific workflows.

  • With the launch of the Qiskit Functions Catalog, Premium Plan developers can explore the IBM Circuit function. The IBM Circuit function includes the latest AI-powered extensions to Qiskit for circuit synthesis, optimization, and scheduling, as well as advanced error mitigation methods to return the most accurate estimations possible with today's hardware.

    Users can purchase licenses for the following functions contributed by our partners at Q-CTRL, QEDMA, Algorithmiq, and Qunasys.

  • Circuit functions

    • Q-CTRL is releasing a circuit function that applies AI-driven quantum control techniques, with which users can scale successfully to larger problems.
    • Algorithmiq is releasing a circuit function that applies TEM (tensor-network error mitigation), an error mitigation method for obtaining estimators with fewer shots than the PEC (probabilistic error cancellation) method.
    • QEDMA is releasing a circuit function that uses proprietary protocols for efficient and accurate characterization of the noisy QPU operations, and applies error suppression and error mitigation based on the characterization data.

  • Application functions

    • QunaSys is releasing a chemistry application function comprising three algorithms meant to solve the ground state energy estimation (GSEE) problem.
    • Q-CTRL is releasing an optimization solver with which users can pass a graph or an objective, and receive solution costs.

Qiskit Code Assistant

5 June 2025

For more details on Qiskit Code Assistant, see the documentation.

Documentation

IBM Quantum documentation recently added a number of user-facing improvements, including content updates and new features. Many of these changes are a result of specific user requests! Check out the highlights below.

18 December 2024

A huge thank you goes out to everyone in the open-source community who contributed and gave feedback! Please open an issue if you find a bug, have a suggestion, or want to share your experience.

Was this page helpful?
Report a bug or request content on GitHub.