# QuREKA Guide
# Overview
[](https://docs.qureka.io/uploads/images/gallery/2026-02/qurkea.png)
QuREKA is a hybrid quantum computing cloud platform built on the foundation of the Qube series solutions (QubeStack, QubePad, QubeSIM). It integrates classical computing infrastructure with quantum computing resources to provide a high-performance environment capable of tackling complex computational problems and optimization tasks.
By integrating core elements—such as a hybrid computing engine that automatically partitions and distributes classical and quantum operations, GPU-based high-performance simulators, resource orchestration, and real-time monitoring with advanced security—QuREKA ensures stable and efficient management of complex quantum-classical workloads.
Users can interact with the platform through a web-based console to submit jobs, monitor resources, and analyze results. The platform offers an intuitive and efficient development environment featuring project-based workspaces, GUI-based circuit design tools, and a variety of sample code templates.
At its core, QuREKA integrates the NVIDIA CUDA-Q architecture at the engine level to support GPU-accelerated large-scale quantum simulations and hybrid algorithm optimization. This allows existing CUDA and AI developers to utilize their familiar codebases and workflows within QuREKA, enabling rapid development of quantum algorithms without the need for additional environment configuration.
# Service Preparation
## Registration
QuREKA is accessible instantly via web browser without the need for any software installation. Users can prepare to use all QuREKA services simply by accessing the QuREKA portal and completing the registration and login process.
[](https://docs.qureka.io/uploads/images/gallery/2026-02/h9WclpP33z.png)
## API Key Generation
After logging in, click the Login or Get Started button on the QuREKA portal to access the console page. Upon successful access, the dashboard for your personal workspace will appear as shown in the image above.
\[Dashboard Screen Image\]
To use QuREKA's resources and SDKs, users must first obtain an API key. Click the \[Generate API Key\] button on the dashboard to issue your key.
[](https://docs.qureka.io/uploads/images/gallery/2026-02/MngYUpCZn5.png)
\[CAUTION\] For security reasons, never share your API key with others. If you suspect your key has been compromised, please regenerate it immediately.
## Workspace Creation and Invitation
QuREKA provides a management environment based on Workspaces for efficient collaboration. In addition to personal workspaces, users can create team workspaces for collaborative development and invite colleagues.
### Creating a Team Workspace
You can create a new team workspace by clicking the Workspace Switcher icon located at the top right of the screen.
[](https://docs.qureka.io/uploads/images/gallery/2026-02/oc91x47pNw.png)
### Inviting Members to a Workspace
You can invite collaborators to your workspace. An invitation email will be sent to the email address entered during the invitation process.
[](https://docs.qureka.io/uploads/images/gallery/2026-02/zDYWcspMLu.png)
Workspace owners can add and manage development personnel later through the Workspace Management page.
# Getting Started
Let’s walk through the process of requesting quantum jobs and verifying the results on QuREKA.
A Quantum Job refers to a sequence of programs or algorithms that include quantum circuits. These can range from a single circuit to complex classical-quantum hybrid computations such as VQE or QAOA. In this guide, we will create a simple quantum job containing a single quantum circuit.
## 1. Creating a Quantum Job
###
Creating a Quantum Server
To write and execute quantum circuit code, you must first create a Quantum Server. A Quantum Server provides dedicated computational resources for developing quantum algorithms.
- Access Path: You can access this via the Dashboard or the \[Quantum Server\] menu in the sidebar.
- How to Create: Click the \[Create\] button within the menu to create a new Quantum Server.
- Server Types by Subscription: The types and specifications (vCPU, RAM, GPU, etc.) of the Quantum Servers available to you vary depending on your current Subscription Plan. If the desired server specification is not active, please update your plan on the Subscription page.
[](https://docs.qureka.io/uploads/images/gallery/2026-02/b2XP3LwFxM.png)
### Development Environment Configuration
All Quantum Servers on QuREKA provide an optimized environment with NVIDIA CUDA-Q pre-installed. You can immediately begin developing CUDA-Q based quantum algorithms through Jupyter Notebook without any additional framework installation.
## 2. Writing a Quantum Circuit
QuREKA provides DGX infrastructure optimized for NVIDIA CUDA-Q, so we highly recommend developing with CUDA-Q. The following example demonstrates creating a GHZ State using three qubits.
**\[Code Cell\]**
```python
import cudaq
@cudaq.kernel
def ghz(numQubits: int):
# Create a qubit vector
qubits = cudaq.qvector(numQubits)
# Apply Hadamard gate to the first qubit (creating superposition)
h(qubits.front())
# Create entanglement between qubits using controlled-X (CNOT) gates
x.ctrl(qubits[0], qubits[1])
x.ctrl(qubits[1], qubits[2])
# Measure all qubits
mz(qubits)
# Verify circuit validity via simulation before submitting the actual job
sample_result = cudaq.sample(ghz, 3)
print(sample_result)
```
**\[Output\]**
```
{ 000:491 111:509 }
```
Note: The output shows measurement counts for a total of 8 states from 000 to 111. Due to the probabilistic nature (randomness) of quantum computing, results may vary with each execution.
## 3. Submitting a Quantum Job
Submit your written circuit to an actual quantum resource (Backend) for execution. You can select various backends provided by QuREKA using the cudaq.set\_target function. For authentication, you will need the API Key issued during the service preparation stage.
The following example shows how to set the target to the MIMIQ simulator and submit a job.
**\[Code Cell\]**
```python
import cudaq
# Configure execution environment and authentication
backend = "sdt.qubesim-mimiq"
api_key = "TYPE_YOUR_API_KEY" # Enter the API key issued from your Dashboard
# Set QuREKA quantum backend target
cudaq.set_target("qureka", backend="sdt.qubesim-mimiq", api_key="api_key")
# Submit quantum job and receive results
result = cudaq.sample(ghz, 3)
print(result)
```
## 4. Monitoring Your Job
You can monitor the status and history of your submitted quantum jobs through the following paths:
- 'TASK' Tab (Right Side): Monitor the status of your currently submitted job in real-time within the right panel of the Quantum Server (Jupyter Notebook).
- 'Quantum Jobs' Menu (Console): View detailed results and statistics for all jobs, including past execution history, in the \[Quantum Jobs\] menu of the main QuREKA console.
[](https://docs.qureka.io/uploads/images/gallery/2026-06/5chRUr5ycq.png)
# QuREKA Interfaces
**Understanding QuREKA System Structure**
All information and resources on the QuREKA platform are managed based on the **Workspace**.
- **Workspace-Based Information:** All menus in the left sidebar—including Dashboard, Quantum Server, and Quantum Jobs—display data specific to the currently selected workspace.
- **Resource Isolation:** Each workspace maintains its own independent API keys, credits, and quantum servers. When collaborating on different projects or with different teams, please ensure you switch to the appropriate workspace using the workspace switcher icon in the upper right corner before proceeding with your work.
# Dashboard
The Dashboard is the central hub of QuREKA, where you can manage Quantum Servers, handle subscription plans, and monitor job trends and lists at a glance.
By using the configuration button on the upper right, users can customize the dashboard with their preferred components (widgets). Each item’s position and size can be freely adjusted to create an optimized layout tailored to the user's needs.
[](https://docs.qureka.io/uploads/images/gallery/2026-02/L1YqqwkVBc.png)
### Key Dashboard Components
#### **Plan Summary**
- View and manage the current subscription plan of the workspace.
- For security and billing management, only the Workspace Owner has the authority to change the subscription plan.
#### **Credits Usage**
- Monitor the remaining credits and current usage status of the workspace in real-time to manage your budget effectively.
#### **API Key Management**
- Manage the unique API key assigned to each individual within the workspace.
- This key is mandatory for user authentication when submitting quantum jobs. Reissuance features are provided for security in case of key exposure.
#### **Quantum Server**
- Manage dedicated computational resources for quantum algorithm development.
- You can immediately create a Quantum Server via the **\[Create\]** button. Once created, you can start developing in the following environments:
- **Notebook**: A code-based development environment powered by JupyterLab.
- **Composer**: A GUI-based environment for designing quantum circuits using drag-and-drop functionality.
- **No-code**: A simplified development environment that requires no coding (scheduled for a future update).
Note: The available types and specifications (vCPU, RAM, GPU, etc.) of Quantum Servers depend on your current **Subscription Plan**.
#### **Job Trend**
- Provides a visual representation of the daily trend for quantum jobs executed within the workspace, helping users understand their usage patterns.
#### **Recent Jobs**
- Quickly check the list and status of the most recent jobs in the workspace.
- Click the **\[More\]** button to navigate to the **Quantum Jobs** tab for a detailed history of all tasks.
# Workspace
A Workspace is the fundamental unit for team collaboration and resource management. On the Workspace Management page, you can control basic information about the current workspace and manage participating members.
[](https://docs.qureka.io/uploads/images/gallery/2026-02/3afT121INn.png)
### Workspace Information
This section provides essential details about the workspace. You can check the workspace name, creation date, and the current Owner.
### Member Management
This feature allows for the systematic management of users within the workspace. Administrators can freely adjust the member composition and permissions according to the nature of the project.
- **Inviting and Verifying Members:** You can invite new team members to collaborate by entering their email addresses. Through the invitation menu, you can check the list of sent invitations and monitor the real-time status of members pending acceptance.
- **User Permission Management:** You can set or change permissions for each member belonging to the workspace. This allows you to control the scope of resource access according to each member's specific role.
- **Member Removal:** You can remove members with whom collaboration is no longer required. Upon removal, all access rights to the resources within that workspace are immediately revoked.
# Quantum Server
The Quantum Server page allows you to manage dedicated computational resources for developing and simulating quantum algorithms. You can create servers, control their operational status, and access the development environment here.
### 1. Creating a Quantum Server
To establish a new development environment, you must first create a Quantum Server.
- **Creation Method**: Click the **\[+ Create\]** button at the upper right of the page.
- **Select Specifications (SPEC)**: First, select the server specifications (SPEC) you wish to use.
- **Note**: The available server types vary depending on your current Subscription Plan.
- **Enter Name**: Input a name for the server you are creating.
- **Credit Pre-deduction**: Upon accessing the Quantum Server after it starts, **credits will be pre-deducted** based on the server specifications. You can preview the amount of credits to be deducted on the screen during the creation process.
### 2. Quantum Server List
Displays a list of all created Quantum Servers along with their detailed information.
#### **SPEC (Server Specifications)**
Hardware resource information based on the selected plan.
[](https://docs.qureka.io/uploads/images/gallery/2026-02/5zytB5YVJY.png)
- **CPU**: The Central Processing Unit that handles classical computations and system processes for quantum circuits.
- **RAM**: Memory space required for storing data during simulations. Higher qubit counts require larger RAM capacity.
- **GPU**: Enables GPU resources for high-performance simulations. It significantly accelerates computational speed via platforms like CUDA-Q.
- **Storage**: Physical storage space for saving code files, datasets, and job results.
#### **Features**
Core features and technology stacks supported by the server.
[](https://docs.qureka.io/uploads/images/gallery/2026-02/AGRPAHqvN2.png)
- **QPU**: Supports connectivity to submit and execute jobs on actual Quantum Processing Units.
- **Composer**: Provides a GUI-based environment for designing quantum circuits using drag-and-drop functionality.
- **AI Assistant**: Grants access to AI-powered assistance for code writing and algorithm development.
- **CUDA-Q**: Features NVIDIA’s high-performance quantum computing platform pre-installed for an optimized environment.
#### **Status**
- **RUNNING**: The server is currently active, and the development environment is accessible.
- **STOPPED**: The server operation is temporarily paused.
#### **Manage**
Control the server using the icons on the right side of the list.
[](https://docs.qureka.io/uploads/images/gallery/2026-02/bSzqOyPy91.png)
- **Open**: Launches and accesses the QubePad development environment.
- **Stop**: Stops the running server. This is recommended when not in use to prevent unnecessary resource consumption.
- **Restart**: Resumes a stopped server and switches it back to the running state.
- **Delete**: Removes the server. Please proceed with caution, as all data within the server will be permanently lost upon deletion.
# Quantum Jobs
Here is the English translation for the **Quantum Jobs** section:
---
The Quantum Jobs page is where you can monitor the quantum jobs executed within your workspace. It allows you to track the progress of all submitted tasks and conduct a detailed analysis of the results for completed jobs.
[](https://docs.qureka.io/uploads/images/gallery/2026-02/F8kVDoHamt.png)
### 1. Quantum Jobs List
Quantum jobs executed in the workspace are identified and distinguished by the following information:
- **Provider**: The provider of the quantum resources.
- **Device Name**: The name of the hardware or simulator used to execute the job.
- **User**: The user who submitted the job.
- **Execution Type**: The specific execution type of the job.
- **Submitted At**: The date and time the job was submitted.
- **Started At**: The date and time the job execution began.
### 2. Job Details
By selecting a specific job from the list, you can view more in-depth information via the details panel on the right:
- **Status**: Displays the current status of the job (e.g., **DONE**, **RUNNING**, **PENDING**, **FAILED**).
- **Completed At**: The date and time the job was finally completed.
- **Job ID**: The unique identification number for the task.
- **Qubits**: The number of qubits utilized in the circuit.
- **Shots**: The number of times the circuit was repeatedly executed.
- **Circuit**: Allows you to directly review the submitted quantum circuit code.
### 3. Result Verification and Download
Users can review the results of completed (**DONE**) jobs on the details screen and download the data if necessary.
# Quantum Resources
The Quantum Resources page is where you can check the real-time status and detailed specifications of various quantum computers (QPUs) and simulators provided by QuREKA, as well as manage access permissions for each member.
[](https://docs.qureka.io/uploads/images/gallery/2026-02/AhPkyOGsxG.png)
### 1. Quantum Resources List
Key information for all currently available quantum resources is displayed in a list format:
- **Provider**: The supplier providing the quantum resources (e.g., Rigetti, IQM, IonQ, SDT, etc.).
- **Device Name**: The unique name of the specific device.
- **Status**: Indicates the current connection status of the resource.
- **ONLINE**: The resource is in a normal state, allowing for job submission and execution.
- **OFFLINE**: The resource is currently unavailable due to maintenance or other reasons.
- **Type**: Distinguishes the type of resource.
- **QPU**: Actual quantum hardware that performs computations using physical quantum elements.
- **SIMULATOR**: A virtual execution environment that uses high-performance computing (HPC) resources to mathematically calculate the results of quantum algorithms instead of using an actual quantum computer.
- **Qubits**: The total number of qubits available on the device.
- **Permission**: Shows the current access permission status set for the resource.
### 2. Resource Management
Administrators (Admins) can directly control the resource access permissions visible to workspace members. These can be configured via the More (⋮) icon on the right side of the list:
- **Admin Only**: Only users with administrator privileges can view the resource and submit jobs.
- **User Accessible**: General workspace members can also view the resource in the list and use it to execute their jobs.
### 3. Resource Details
By clicking on a specific resource, a details panel appears on the right where you can find more in-depth technical information:
- **Resource ID**: A unique ID used to identify the resource within the system.
- **Status**: Provides a detailed view of the resource's current operational status.
- **External Host**: Information regarding the external address where the resource is hosted.
# Billing & Payments
This section is for managing the workspace's subscription plans, credits, and payment methods. All payment-related information is strictly managed for security.
### 1. Subscription History
A menu to check and manage the current subscription status of the workspace.
[](https://docs.qureka.io/uploads/images/gallery/2026-02/jbPKnPV6gs.png)
- **Current Plan**: You can check the subscription plan currently in use and, if necessary, upgrade to a higher plan or cancel the current subscription.
- **Registered Payment Method**: You can register a payment method for recurring subscription payments.
- **Security Notice**: Only the **Workspace Owner** can register or change payment methods; this area is not visible to other members.
- **History**: You can review the past subscription payment history of the workspace. Subscriptions are automatically renewed every **30 days** by default.
### 2. Credit History
Manage the status of credits used for quantum jobs and server usage within the workspace and track the consumption flow within the organization.
[](https://docs.qureka.io/uploads/images/gallery/2026-02/szdrpLGLnf.png)
- **Credit Status**: Check the remaining credit balance in real-time. If credits are insufficient, you can purchase additional credits via the **\[Purchase\]** button.
- **Credit History**: You can view all records of credit recharges (purchases) and usage (deductions).
- **Organization Consumption Monitoring**: It provides detailed logs of **how all members within the workspace have consumed credits** (e.g., quantum server usage, quantum job submissions), allowing for transparent cost management and tracking at the organizational level.
### 3. Payment & Refund History
Monitor all financial transaction records that occurred within the workspace.
[](https://docs.qureka.io/uploads/images/gallery/2026-02/YjSgpL7kxo.png)
- You can collectively view all **Purchase History**, such as subscription payments and credit recharges, as well as **Refund History** resulting from cancellations.
# QuREKA-Lab
Quantum Server
QuREKA Lab is a **dedicated quantum algorithm development environment** established by creating a Quantum Server.
- **Server-Based Environment**: You can access the lab by clicking the **\[Open\]** button in the Quantum Server list. It provides a development interface powered by JupyterLab.
- **Customized Specifications**: The development environment is configured precisely according to the hardware specifications (CPU, RAM, GPU, and Storage) you selected during the Quantum Server creation step.
- **Consistent Development Experience**: Based on high-performance computing resources allocated according to your subscription plan, you can reliably perform complex quantum simulations and algorithm designs.
# Notebook
QuREKA Lab provides a powerful Python development environment based on JupyterLab, supporting an efficient workflow through dedicated extensions and AI-powered tools optimized for quantum algorithm development.
[](https://docs.qureka.io/uploads/images/gallery/2026-06/notebook.gif)
### 1. Jupyter Notebook Environment
- **Python-Based Development**: Utilize standard Python libraries and quantum computing frameworks within a JupyterLab-based environment.
- **Instant Start**: Create new Jupyter Notebook files and begin development immediately.
- **Folder Management**: Create new folders to organize your notebook files, and delete folders that are no longer needed.
[](https://docs.qureka.io/uploads/images/gallery/2026-06/create-folder.gif) [](https://docs.qureka.io/uploads/images/gallery/2026-06/Ctydelete-folder.gif)
- **Sample Files Provided**: **Sample Notebooks** containing example code for major quantum algorithms are provided by default to assist with learning and practice.
### 2. Dedicated Extensions and Support Tools
QuREKA Lab places optimized tools in the left and right sidebars for development convenience.
- **AI Assistant (Left Panel)**: Provides **AI-powered assistance** for quantum algorithm development and coding. You can easily access the conversational assistant from the left sidebar to receive support for complex implementation processes.
[](https://docs.qureka.io/uploads/images/gallery/2026-06/qubenaut.png)
- **Right Panel Extensions**:
- **Task (Job Monitoring)**: Monitor the real-time status and success/failure of your submitted quantum jobs.
[](https://docs.qureka.io/uploads/images/gallery/2026-06/lNJsRSq1EN.png)
- **Resource (Resource Information)**: View a list of available QPUs and simulators along with their detailed specifications.
[](https://docs.qureka.io/uploads/images/gallery/2026-06/HDAVtMveHg.png)
- **Workspace (Workspace Information)**: Check current workspace details and your real-time credit balance.
[](https://docs.qureka.io/uploads/images/gallery/2026-06/SDJQ927dmv.png)
# Circuit Composer
Circuit Composer is a **GUI-based quantum circuit design tool** utilizing drag-and-drop functionality. It allows users to intuitively construct circuits without complex coding and view simulation results in real-time.
[](https://docs.qureka.io/uploads/images/gallery/2026-06/circuit-composer.gif)
### Key Features
- **Intuitive Design**: Build circuits by placing gates and efficiently manage logical structures using slicers and barriers.
- **Real-time Simulation**: Instantly updates output states and histograms for up to 16 qubits using GPU acceleration upon any design modification.
- **Visual Analysis**: Provides a clear understanding of qubit phase changes and dynamic state flows through graphics and animations.
- **Multi-Environment Support**: Convert designed circuits into over 10 different quantum languages, such as Qiskit and Cirq, or directly submit them to actual QPU and simulator resources.
# Git Management
Notebook provides a built-in Git panel that allows you to clone repositories, pull the latest changes, and push your work to a remote repository.
### 1. Opening the Git Panel
Click the **Git icon** in the left sidebar to open the Git panel.
[](https://docs.qureka.io/uploads/images/gallery/2026-06/2026-06-12-4-05-07.png)
### 2. Cloning a Repository
You can bring an existing remote repository into your workspace.
- Click **Clone a Repository** in the **Git panel**.
- In the dialog that appears, enter the repository URL.
- Leave the two option checkboxes at their default values without modification.
- **Include submodules**: Clones any Git submodules embedded in the repository along with the main repository. Check this if the project includes externally linked repositories.
- **Download the repository**: Downloads the files only, without Git history or branch information. Use this if you only need the code without version control.
- Click **Clone** to begin. The cloned repository will appear in the file browser on the left.
[](https://docs.qureka.io/uploads/images/gallery/2026-06/2026-06-12-3-57-47.png)
[](https://docs.qureka.io/uploads/images/gallery/2026-06/Ih52026-06-12-4-08-57.png)
### 3. Pulling Changes
Pull downloads the latest changes from the remote repository and applies them to your workspace.
- Click the **Pull from Remote** button at the top of the **Git panel**.
[](https://docs.qureka.io/uploads/images/gallery/2026-06/6da2026-06-12-4-03-55.png)
### 4. Pushing Changes
Push uploads your committed changes to the remote repository.
- Click the **Push to Remote** button at the top of the **Git panel**.
[](https://docs.qureka.io/uploads/images/gallery/2026-06/X7K2026-06-12-4-03-55.png)
# QuREKA OpenAPI
## 1. Overview
QuREKA OpenAPI is the external REST API for the QuREKA quantum computing cloud. With a single API key, you can:
- Query available quantum devices (QPUs, emulators)
- Submit OpenQASM 2.0 circuits
- Retrieve execution results
Base URL: `https://openapi.qureka.io`
Common rules:
- All request/response bodies are JSON, and timestamp fields are epoch milliseconds (long).
- List endpoints support pagination via `page`, `size`, and `sort` query parameters, with the total count returned in the `X-Total-Count` response header.
- Error responses follow the RFC 7807 Problem Details format.
## 2. Authentication
Every request requires a `QUREKA-API-KEY` header. The gateway validates the key and automatically exchanges it for an internal access token, so no separate login process or token refresh is required.
API keys are issued per workspace. Keys are issued per user and per workspace, and every request is automatically scoped to that workspace. There is no need to pass a workspace ID separately in the path or as a parameter.
The typical flow is: check workspace → select device → check credit balance → submit job.
```
curl https://openapi.qureka.io/api/providers \\
-H "QUREKA-API-KEY: YOUR\_API\_KEY"
```
API keys are issued from the API Key widget on each workspace's dashboard in the QuREKA console. The key is shown in plaintext only once, at issuance, and cannot be retrieved again afterward. If a key is leaked, it must be reissued immediately.
| Status code | Meaning |
|---|---|
| 401 | Key missing, expired, or disabled |
| 403 | No permission for the requested resource |
## 3. Workspace
### GET /api/workspace — Get my workspace
Returns information about the workspace (tenant) the API key belongs to. Used to validate key validity and determine workspace context.
Response fields:
| Field | Type | Description |
|---|---|---|
| id / name | string | Workspace ID, name |
| personal | boolean | Whether this is a personal workspace |
| memberCount | long | Number of members |
| createdAt | long | Creation timestamp |
```
curl https://openapi.qureka.io/api/workspace \\
-H "QUREKA-API-KEY: YOUR\_API\_KEY"
```
Response: 200 success, 401 invalid key
## 4. Providers & Devices
Query the quantum hardware providers and devices (QPUs, emulators) accessible to the workspace.
### GET /api/providers — List providers
Returns all registered quantum hardware providers, paginated.
Query parameters:
| Parameter | Type | Description |
|---|---|---|
| page / size / sort | int / int / string (optional) | Pagination |
| searchField | enum (optional) | NAME, CODE |
| searchKeyword | string (optional) | Search term |
Response (array): id, name, iconPath, desc, createdAt, updatedAt
### GET /api/providers/{id} — Get a single provider
Same response schema as the list endpoint. 200 success, 404 provider not found.
### GET /api/devices — List available devices
Returns devices accessible to the workspace (published devices with an attached credit policy). This endpoint must be used to confirm a valid `deviceCode` value before submitting a job.
Query parameters:
| Parameter | Type | Description |
|---|---|---|
| status | enum (optional) | ONLINE, MAINTENANCE |
| type | enum (optional) | QPU, EMULATOR |
| searchField / searchKeyword | enum / string (optional) | NAME, CODE, PROVIDER\_NAME |
| page / size / sort | int / int / string (optional) | Pagination |
Response (array):
| Field | Type | Description |
|---|---|---|
| device | Device | Device details (same schema as Get a device) |
| accessRole | enum | ADMIN, USER |
| creditPolicy | CreditPolicy | Billing method (FIXED or VENDOR\_DYNAMIC) and credit policy |
Response: 200 success, 403 no workspace access
### GET /api/devices/{deviceId} — Get a single device
| Field | Type | Description |
|---|---|---|
| id / name / code | string | Device ID, name, target code (used as deviceCode when submitting a job) |
| type | enum | QPU, EMULATOR |
| qubitCount | int | Number of qubits |
| platform | string | Platform (QPU only) |
| simulationMethods | enum\[\] | STATE\_VECTOR, DENSITY\_MATRIX, TENSOR\_NETWORK, MPS, CLIFFORD (emulator only) |
| status | enum | ONLINE, MAINTENANCE |
| provider | Provider | Provider details |
| executionWindows | object\[\] | Available execution time windows — executionDay, windowStartHour, windowEndHour |
| nativeGates | object\[\] | Native gates — name, description (QPU only) |
| shotsRange | object | Allowed shot range — min, max (QPU only) |
| creditPolicy | CreditPolicy | Linked credit policy |
Response: 200 success, 403 no device access, 404 device not found
## 5. Credits
Check the workspace's credit balance and track usage history. For fixed-billing (FIXED) devices, credit is pre-deducted per policy at submission time. For dynamically-billed (VENDOR\_DYNAMIC) devices, a quote is generated first, and once the quote is confirmed for submission, the confirmed estimated credit amount is deducted.
(Note: SDT's credit system has a dual structure of paid credits and free points. The deduction order is points → subscription credits → purchased credits. The negative-credit repayment scheme has been confirmed as discontinued.)
### GET /api/credits/wallet — Get credit balance
Check this before submitting a job to prevent rejection due to insufficient credit.
| Field | Type | Description |
|---|---|---|
| totalCredit | decimal | Total available credit |
| purchaseCredit | decimal | Purchased credit |
| subscriptionCredit | decimal | Subscription credit |
| point | decimal | Bonus points |
| expiringCredit | object? | Next expiring credit — amount, expireAt |
| expiringPoint | object? | Next expiring point — amount, expireAt |
```
curl https://openapi.qureka.io/api/credits/wallet \\
-H "QUREKA-API-KEY: YOUR\_API\_KEY"
```
### GET /api/credits/histories — Get credit history
Query the workspace's credit transaction history (charges, usage, expiration, refunds).
Query parameters (all optional):
| Parameter | Type | Description |
|---|---|---|
| creditHistoryType | enum\[\] | Transaction type filter (charge, usage, expiration, refund) |
| createdAtFrom / createdAtTo | long | Time range filter (epoch millis) |
| page / size / sort | int / int / string | Pagination (default sort: createdAt DESC) |
Response (array):
| Field | Type | Description |
|---|---|---|
| id | string | Transaction ID |
| creditHistoryType | enum | Transaction type |
| title | string | Human-readable description |
| credit | decimal | Amount (negative when used) |
| remainingCredit | decimal | Balance after transaction |
| resourceType / resourceId / resourceName | string | Related resource (e.g., device) |
| jobId | string? | Related quantum job (if any) |
| createdAt | long | Transaction timestamp |
| expirationAt | long? | Expiration timestamp of charged credit (if applicable) |
### IonQ dynamic billing (VENDOR\_DYNAMIC)
For devices such as IonQ, where cost varies by circuit and shot count, billing is not calculated at a fixed rate. Cost is first estimated via an IonQ dry run, and the actual execution is submitted only after confirming the estimated credit amount. Dry runs are not billed.
1. Request a cost estimate and poll status until the quote is complete.
2. Check the quote's estimated credit, whether debiasing was applied, and its validity period. A quote is valid for 12 hours from completion.
3. Submitting a valid quote creates an execution job; upon entering `INITIATED` status, the confirmed estimated credit is pre-deducted.
4. If submission fails (`SUBMIT\_FAILED`), the pre-deducted credit is automatically refunded. Submitted jobs and deduction records can be cross-referenced by jobId.
Devices subject to dynamic billing are marked with `creditPolicy.pricingMode` set to `VENDOR\_DYNAMIC`. Actual unit prices, exchange rates, discount rates, and calculation formulas are not exposed in the API response.
## 6. Quantum Jobs
Submit OpenQASM 2.0 circuits, track their status, and retrieve results. Backends (IonQ, IQM, MIMIQ, KREO, etc.) are automatically routed based on `deviceCode`.
### POST /api/quantum-jobs — Submit a job
Submits an OpenQASM 2.0 circuit to the specified fixed-billing (FIXED) device. Credit is pre-deducted according to the device's credit policy, so balance and the device's shot limit should be checked before submission. For IonQ dynamic-billing (VENDOR\_DYNAMIC) devices, a quote must first be confirmed via cost estimation, then that quote is submitted.
Request body:
| Field | Type | Description |
|---|---|---|
| deviceCode | string (required) | Target device code — e.g., `ionq.forte-1`, `sdt.qubesim-mimiq` |
| circuit | string (required) | OpenQASM 2.0 circuit source |
| shots | int ≥ 1 (required) | Number of measurement shots |
| submissionType | enum (required) | CUDAQ, COMPOSER |
| name | string (optional) | Job name. Auto-generated if omitted |
```
curl -X POST https://openapi.qureka.io/api/quantum-jobs \\
-H "QUREKA-API-KEY: YOUR\_API\_KEY" \\
-H "Content-Type: application/json" \\
-d '{
"deviceCode": "sdt.qubesim-mimiq",
"circuit": "OPENQASM 2.0;\\ninclude \\"qelib1.inc\\";\\nqreg q\[2\];\\ncreg c\[2\];\\nh q\[0\];\\ncx q\[0\],q\[1\];\\nmeasure q -> c;",
"shots": 1000,
"submissionType": "COMPOSER"
}'
```
Response (201 Created):
```json
{
"id": "3f9c1a2e-...", // QuREKA job ID — used for subsequent queries
"jobId": "a81b7c...", // External backend job ID
"jobStatus": "SUBMITTED"
}
```
Response: 201 submitted, 400 parameter error (circuit syntax, shot range, etc.)
### GET /api/quantum-jobs — List jobs
Query the workspace's jobs with filtering, search, and pagination.
Visibility scope depends on role. If the API key belongs to a workspace admin, all jobs in the workspace are returned. If it belongs to a regular member, only that user's own jobs are returned; this is enforced server-side and cannot be bypassed via parameters. An admin who wants to narrow results to a specific user can filter with `searchField=USER\_NAME&searchKeyword=...`.
Query parameters (all optional):
| Parameter | Type | Description |
|---|---|---|
| deviceType | enum | QPU, EMULATOR |
| jobStatuses | enum\[\] | INITIATED, SUBMITTED, RUNNING, DONE, FAILED, SUBMIT\_FAILED, CANCELLED, STOPPED, UNKNOWN |
| submissionType | enum | CUDAQ, COMPOSER |
| jobQubitsFrom/To, jobShotsFrom/To | int | Qubit and shot range |
| createdAtFrom/To, submittedAtFrom/To, completedAtFrom/To | long | Time range filters (epoch millis) |
| searchField + searchKeyword | enum + string | USER\_NAME, PROVIDER\_NAME, DEVICE\_NAME, DEVICE\_CODE, JOB\_ID |
| page / size / sort | int / int / string | Pagination |
Response is an array of the same Job object as Get a job; total count is returned in the `X-Total-Count` header.
### GET /api/quantum-jobs/{id} — Get a single job
If the job is in SUBMITTED or RUNNING status, the latest status is synchronized from the backend at request time, so this endpoint can safely be used for polling.
Key response fields:
| Field | Type | Description |
|---|---|---|
| id / jobId | string | QuREKA job ID, external backend job ID |
| jobStatus | enum | INITIATED → SUBMITTED → RUNNING → DONE / FAILED / SUBMIT\_FAILED / CANCELLED / STOPPED |
| deviceCode / deviceName / deviceType / providerName | string | Execution device details |
| jobQubits / jobShots | int | Number of qubits, shots |
| jobCircuit | string | Submitted circuit source |
| jobResult | string | Raw backend result (use Get job results for structured output) |
| errorMessage | string? | Error message on failure |
| createdAt / submittedAt / startedAt / completedAt | long | Lifecycle timestamps |
| preChargedAmount / usedCredit | decimal | Pre-deducted amount, used credit. For dynamically-billed jobs, this records the confirmed quote credit |
| tenantId / tenantName / userId / userName | string | Ownership information |
Response: 200 success, 404 job not found
### GET /api/quantum-jobs/{id}/result — Get structured results
Automatically detects the backend's native result format (Braket JSON, MIMIQ JSON, etc.) and returns probability distributions, measurement counts, and state vectors as a unified JSON. Used for visualization and post-processing.
```json
{
"probabilities": { "00": 0.503, "11": 0.497 },
"counts": { "00": 503, "11": 497 },
"stateVector": \[
{ "basis": "00", "real": 0.7071, "imag": 0,
"amplitude": "0.7071+0.0000i", "probability": 0.5 }
\],
"metadata": {
"providerName": "SDT", "deviceName": "QubeSim MIMIQ",
"qubits": 2, "shots": 1000,
"isPartialResult": false, "fidelity": 0.999
}
}
```
(`stateVector` is included only in emulator results.)
Response: 200 result returned, 400 resultNotReady (result not yet generated), 404 job not found
### GET /api/quantum-jobs/{id}/download — Download results
Downloads the job result as a plain text file (text/plain, attachment). Filename convention: `job\_result\_{jobId}\_{yyyy-MM-dd}.txt`
Response: 200 download, 400 resultEmpty (no result), 404 job not found
## 7. Enum reference
| Enum | Values |
|---|---|
| JobStatus | INITIATED, SUBMITTED, RUNNING, DONE, FAILED, SUBMIT\_FAILED, CANCELLED, STOPPED, UNKNOWN |
| JobSubmissionType | CUDAQ, COMPOSER |
| JobLanguage | OPENQASM\_20 |
| DeviceType | QPU, EMULATOR |
| DeviceStatus | ONLINE, MAINTENANCE |
| SimulationMethod | STATE\_VECTOR, DENSITY\_MATRIX, TENSOR\_NETWORK, MPS, CLIFFORD |
| DeductionType (credit) | TASK, SHOT, TIME |
| PricingMode (credit) | FIXED, VENDOR\_DYNAMIC |
\---
## 8. Using the CUDA-Q client (`qubestack-cudaq`)
Instead of calling the REST API directly, in an NVIDIA CUDA-Q environment you can submit jobs to the same Job Engine through the QuREKA backend plugin `qubestack-cudaq`. This package internally handles the REST API calls (job submission, polling, result retrieval) on your behalf.
### Distribution
`qubestack-cudaq` is publicly distributed via PyPI (Python Package Index).
\- PyPI page: https://pypi.org/project/qubestack-cudaq/
\- Latest version: 1.0.86 (as of the 2026-07-21 release — confirmation needed: re-verify the latest version at time of publication)
\- License: Apache License 2.0
\- Distributed by: SDT Inc.
\- Requirement: Python 3.12 or higher
### Installation
No separate registration or internal repository access is required; it can be installed directly from public PyPI.
```
pip install qubestack-cudaq
```
`cuda-quantum-cu12==0.14.0` is installed automatically as a dependency.
Verify installation:
```
pip show qubestack-cudaq
```
To install a specific version:
```
pip install qubestack-cudaq==1.0.86
```
The Academic notebook comes pre-included in the `qubestack-pad` notebook image.
### Version compatibility matrix
The four packages `qubestack-cudaq`, `cuda-quantum-cu12`, `cudaq-qec`, and `cudaq-solvers` must be distributed together as ABI-compatible versions. This is enforced by the `qubestack-cudaq` CI via `scripts/verify\_academic.sh`.
| qubestack-cudaq | cuda-quantum-cu12 | cudaq-qec | cudaq-solvers |
|---|---|---|---|
| 1.0.x (current) | 0.14.0 | 0.6.0 | 0.6.0 |
(Internal note: an internal tracking document exists explaining the rationale for version pinning and the criteria for adding new rows. Since this is an external document, the ticket number has not been exposed — confirmation needed.)
### Quick start
```python
import cudaq
# Configure QuREKA target
cudaq.set\_target("qureka", backend="sdt.qubesim-mimiq", api\_key="YOUR\_API\_KEY")
# Define quantum kernel
@cudaq.kernel
def bell\_state():
q = cudaq.qvector(2)
h(q\[0\])
cx(q\[0\], q\[1\])
mz(q)
# Execute
result = cudaq.sample(bell\_state, shots\_count=1000)
print(result)
```
(Note: `set\_target` is a setting used to designate the QuREKA backend for QPU submission and management purposes — it is not for local CPU/GPU simulation.)
### Supported backends
| Backend | Identifier |
|---|---|
| QPerfect MIMIQ | `sdt.qubesim-mimiq` |
| IQM Garnet | `iqm.garnet` |
| IQM Emerald | `iqm.emerald` |
| IonQ Forte (direct IonQ Cloud v0.4 connection) | `ionq.forte-1` |
| SDT KREO | `sdt.kreo-sc20` |
### Configuration parameters
| Parameter | Required | Description |
|---|---|---|
| backend | Required | Quantum backend identifier (see table above) |
| api\_key | Required | QuREKA API key |
| option | Optional | Backend-specific options (JSON string) |
License: Apache License 2.0
\---
## Items requiring confirmation
\- Discrepancy between the actual implementation state of the deployed Swagger UI and this document (v1 target spec)
\- How to summarize the internal rationale document for version pinning for external use, without exposing the ticket number
\- Whether the term "simulation" as used by CUDA-Q Academic conflicts with SDT's internal terminology standard (emulation/emulator terminology; simulator/simulation prohibited) — since the original term is NVIDIA's own terminology (CUDA-Q, GPU simulation), it should be distinguished from SDT's own usage
\- Whether a concrete JSON schema example is needed for the `option` parameter (backend-specific options)
# IonQ cost estimation
## Overview
When submitting jobs to IonQ devices on QuREKA, a cost estimation step is required before the job can be submitted. This allows you to review the expected credit usage in advance.
---
## How It Works
### 1. Cost Estimation Request
Before submitting a job, QuREKA automatically initiates a cost estimation. No credits are deducted at this stage.
### 2. Review Estimation Results
Once the estimation is complete, you can review the expected credit amount in Quantum Jobs. Estimation results are valid for **12 hours** from the time of completion. Your job must be submitted within this window.
### 3. Job Submission and Credit Deduction
After reviewing the estimated cost, confirm and submit your job. Credits are deducted at the point of submission.
### 4. View Results
Once the job is complete, you can check the execution results in Quantum Jobs. A full record of credit deductions is available in your credit history.
---
## Debiasing (Error Mitigation)
Debiasing is an optional error mitigation feature provided by IonQ that can be applied at the time of job submission.
Enabling Debiasing raises the minimum charge threshold. If your estimated credit usage exceeds this threshold, no additional charge applies.
You can choose whether to enable Debiasing during the estimation review step. Your selection will affect the final amount of credits deducted.
---
## Important Notes
- No credits are deducted during the cost estimation process
- If the estimation result expires (after 12 hours), you will need to request a new estimation
- Job submission will be rejected if your credit balance is insufficient