--- title: Monitor or cancel a job description: How to monitor or cancel a job submitted to IBM Quantum Platform source: https://eu-de.quantum.cloud.ibm.com/docs/en/guides/monitor-job --- # Monitor or cancel a job This guide explains how to monitor job status, view usage information, and cancel jobs. You can access this information both through IBM Quantum® Platform and programmatically using Qiskit. ### Package versions The code on this page was developed using the following requirements. We recommend using these versions or newer. ``` qiskit-ibm-runtime~=0.46.1 ``` ## Monitor a job Use these methods to check the status of your submitted jobs, retrieve results, and view details related to the job and its execution. ### Monitor a job with Qiskit The job instance provides several methods for monitoring: | Method | Description | | ---------------------------- | --------------------------------------------------- | | `job.status()` | Check the current job status | | `job.job_id()` | Get the unique job identifier | | `job.result()` | Retrieve job results (blocking call until complete) | | `job.wait_for_final_state()` | Block until the job reaches a terminal state | ```python from qiskit_ibm_runtime import QiskitRuntimeService service = QiskitRuntimeService() # Retrieve a job by ID job = service.job("") # Get job ID (useful for saving for later retrieval) print(f"Job ID: {job.job_id()}") # Check current status print(f"Status: {job.status()}") # Wait for job to complete (blocking call) job.wait_for_final_state() print("Job completed") # Get results results = job.result() print(results) ``` ### Monitor a job on IBM Quantum Platform Navigate to the [Workloads page](/workloads) and check the Status column. Your job status appears as one of the following: - **Pending**: Job is waiting to run on a QPU - **In progress**: Job is currently executing - **Completed**: Job finished successfully - **Failed**: Job encountered an error - **Canceled**: User canceled the job Click on the job name or row to open the detailed view, where you can see information such as the results and any error messages. ### Why a job stays "In progress" You might notice that a job (using either job mode or batch mode) you expect to take only a few seconds stays in the **In progress** status (called `RUNNING` in Qiskit) for much longer. This is normal, and it does not mean the job is consuming that entire time as usage. It happens because of how jobs are scheduled onto a QPU: - Every job requires classical pre-processing before it can run on the QPU. A job moves to **In progress** (`RUNNING`) as soon as this classical processing begins — not when it starts executing on the QPU. - Most of this classical processing runs in parallel, so multiple jobs can be **In progress** at the same time. - However, only one job at a time can run on the QPU. When several jobs finish their classical processing and are ready to execute, they must wait their turn for the QPU. This is known as *QPU contention*. When contention is high, a job can remain **In progress** noticeably longer than the few seconds of QPU time it actually needs. - Contention can also occur when a system-maintenance task, such as calibration, is running on the QPU. Your job stays **In progress** until the maintenance task completes and the QPU becomes available. Because of this, the elapsed wall-clock time a job spends **In progress** is not the same as its usage. Both the [estimated usage](/docs/guides/estimate-job-run-time) and the [maximum execution time](/docs/guides/max-execution-time) are based only on the time the QPU is locked to execute your job, and therefore exclude the multi-threaded classical processing described above. A long **In progress** time does not increase your reported usage or cost. #### Session mode is different The preceding behavior applies to [job mode](/docs/guides/execution-modes#job-mode) and [batch mode](/docs/guides/execution-modes#batch-mode). In [session mode](/docs/guides/execution-modes#session-mode), during the session's active window, the user has exclusive access to the backend and no other jobs can run, including calibration jobs. Therefore, any QPU contention happens only among your own session jobs. In addition, because QPU capacity is reserved for the duration of the session, session usage is measured as the elapsed time while the session remains active, regardless of whether jobs are actively running. See [Workload usage](/docs/guides/estimate-job-run-time#usage) for more information. ## View remaining usage Track how much of your plan's usage quota remains. ### Check usage with Qiskit Use the `service.usage()` method to get usage information for your current active instance. ```python from qiskit_ibm_runtime import QiskitRuntimeService service = QiskitRuntimeService() # Get usage information for the current active instance usage = service.usage() print(usage) ``` ### View usage on IBM Quantum Platform Navigate to the [Instances page](/instances) and select the tab associated with the plan you want to check. The total time used and total time remaining on your plan is displayed. ## View job metrics Get an overview of your job submissions, including batch and session workload metrics. ### Get job metrics with Qiskit Use the [`service.jobs()`](/docs/api/qiskit-ibm-runtime/qiskit-runtime-service#jobs) method with filters to retrieve information about your submitted jobs, such as how many have been submitted, what their statuses are, and when they were created. The following example retrieves all jobs submitted in the last seven days and calculates the total usage from those jobs. ```python from datetime import datetime, timedelta from qiskit_ibm_runtime import QiskitRuntimeService service = QiskitRuntimeService() # Retrieve all jobs in the last 7 days seven_days_ago = datetime.now() - timedelta(days=7) jobs = service.jobs(limit=None, created_after=seven_days_ago) # To retrieve all jobs in a Session or Batch, use the session_id filter # jobs = service.jobs(session_id="") total_usage = 0 for job in jobs: total_usage += job.usage() print(f"{len(jobs)} jobs were submitted in the last 7 days.") print(f"Total usage was {total_usage} seconds") ``` ### View job metrics on IBM Quantum Platform Navigate to the [Analytics page](/analytics) to see and download data, such as the following: - Total usage - Usage filtered by instance, quantum computer, and user - Count of job, batch, and session workloads **Note**: You can only access the Analytics page for accounts that you own or manage. ## Retrieve job results at a later time You can save job IDs and retrieve results later, even after closing your session. ### Retrieve results with Qiskit If you saved the job ID when you submitted the job, use `service.job()` to retrieve it later. If you don't have the job ID, or if you want to retrieve multiple jobs at once (including jobs from retired QPUs), use `service.jobs()` instead, with optional filters. See the [`QiskitRuntimeService.jobs`](/docs/api/qiskit-ibm-runtime/qiskit-runtime-service#jobs) API documentation for available filters. This example demonstrates retrieving recent results run on a specific backend. ```python from qiskit_ibm_runtime import QiskitRuntimeService service = QiskitRuntimeService() # Uncomment the next line to retrieve a specific job by ID # job = service.job("") # Optionally retrieve multiple jobs with filters # Use `limit` to retrieve a specific number of jobs. The default `limit` is 10. my_backend = "" recent_jobs = service.jobs(backend_name=my_backend, limit=10) print(f"Retrieved {len(recent_jobs)} recent jobs from {my_backend}\n") # Get results from all jobs for job in recent_jobs: print(f"Job ID: {job.job_id()}") print(f"Status: {job.status()}") # Retrieve results if the job is complete if str(job.status()) == "DONE": try: results = job.result() print(f"Results: {results}") except Exception as e: print(f"Error retrieving results: {e}") else: print("Results: Not available (job still running or failed)") print() ``` ### Retrieve results on IBM Quantum Platform 1. Go to the [Workloads page](/workloads). 2. Use the search or filter options to find your job by name, date, or status. 3. Click on the job to view its results and details. ## Retrieve backend properties ### Retrieve backend properties with Qiskit You can use `job.properties()` to retrieve backend properties, including error rates, at the time of the job execution. This example demonstrates how to retrieve backend properties that were current at the time a job was executed, including $T_1$/$T_2$ times and error rates for a specific qubit (0). ```python from qiskit_ibm_runtime import QiskitRuntimeService service = QiskitRuntimeService() # Retrieve a specific job by ID job = service.job("") print(f"Job ID: {job.job_id()}") print(f"Backend: {job.backend}\n") # Fetch backend properties at the time of job execution properties = job.properties() if properties: print("Backend Properties at Job Execution Time:") print("=" * 60) # Get T1 (relaxation time) for qubit 0 t1 = properties.t1(0) print(f"Qubit 0 T1 (relaxation time): {t1}") # Get T2 (dephasing time) for qubit 0 t2 = properties.t2(0) print(f"Qubit 0 T2 (dephasing time): {t2}") # Get readout error for qubit 0 readout_error = properties.readout_error(0) print(f"Qubit 0 readout error: {readout_error}") # Get all properties for a specific qubit print("All properties for qubit 0:") qubit_props = properties.qubit_property(0) for prop_name, prop_value in qubit_props.items(): print(f" {prop_name}: {prop_value}") else: print("No properties available for this job") ``` > **Deprecated provider packages** > > `service.jobs()` also returns jobs run from the deprecated `qiskit-ibm-provider` package. Jobs submitted by the older (also deprecated) `qiskit-ibmq-provider` package are no longer available. ### Retrieve backend properties on IBM Quantum Platform You can see calibration data for the backend at the time of job execution, as well as at job creation. 1. Go to the [Workloads page](/workloads) 2. Click a workload to open its Details page 3. Under Quantum computer, click View calibration history 4. Use the dropdown menu to change from viewing the data "At job execution start" to "At job creation" ## Cancel a job Cancel a job that is queued or running. Once a job is canceled, it cannot be resumed. ### Cancel with Qiskit Use the `job.cancel()` method to cancel a job programmatically. ```python from qiskit_ibm_runtime import QiskitRuntimeService service = QiskitRuntimeService() # Retrieve the job job = service.job("") # Cancel the job job.cancel() print(f"Job {job.job_id()} has been canceled") ``` ### Cancel on IBM Quantum Platform 1. **From the workloads table**: Click the overflow menu at the end of the row for the workload you want to cancel, and select **Cancel**. 2. **From the job details page**: Click on the workload to open its details page, use the **Actions** dropdown at the top, and select **Cancel**. ## Next steps > **Recommendations** > > - Review the [`QiskitRuntimeService` API reference](/docs/api/qiskit-ibm-runtime/qiskit-runtime-service) for additional job management methods. > - Explore [execution modes](/docs/guides/execution-modes) to understand batch and session workload types.