QDash

Appearance

v0.0.1

QDash API​

QDash API

API for QDash

Contact​

oqtopus-team@googlegroups.com

Servers​

/api

auth​

Login user​

POST
/auth/login

Authenticate user and return access token.

Validates user credentials against the database and returns an access token
for subsequent authenticated requests.

Parameters

username : str
User's username provided via form data
password : str
User's password provided via form data

Returns

TokenResponse
Response containing access_token, token_type, and username

Raises

HTTPException
401 if authentication fails due to incorrect username or password

Request Body​

Schema
[object Object]

Responses​

Successful Response
application/json
JSON
{
"access_token": "string",
"token_type": "string",
"username": "string",
"default_project_id": "string"
}

Samples​

cURL
curl -X POST \
'http://localhost/auth/login' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/auth/login', {method:'POST',headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/auth/login';
$method = 'POST';
$headers = [
    'Content-Type' => 'application/json',
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>
Python
import requests

url = 'http://localhost/auth/login'

headers = {
    'Content-Type': 'application/json'
}

response = requests.post(url, headers=headers)
print(response.json())

Register a new user (admin only)​

POST
/auth/register

Register a new user account (admin only).

Creates a new user in the database with hashed password and generates
an access token for immediate use. Only admin users can create new accounts.

Parameters

user_data : UserCreate
User registration data including username, password, and optional full_name
current_user : User
Current authenticated admin user

Returns

UserWithToken
Newly created user information including access_token

Raises

HTTPException
403 if the current user is not an admin
400 if the username is already registered

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Request Body​

JSON
{
"username": "string",
"password": "string",
"full_name": "string"
}

Responses​

Successful Response
application/json
JSON
{
"username": "string",
"full_name": "string",
"disabled": "string",
"default_project_id": "string",
"system_role": "string",
"access_token": "string"
}

Samples​

cURL
curl -X POST \
'http://localhost/auth/register' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/auth/register', {method:'POST',headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/auth/register';
$method = 'POST';
$headers = [
    'Content-Type' => 'application/json',
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>
Python
import requests

url = 'http://localhost/auth/register'

headers = {
    'Content-Type': 'application/json'
}

response = requests.post(url, headers=headers)
print(response.json())

Get current user​

GET
/auth/me

Get current authenticated user information.

Returns the profile information of the currently authenticated user
based on the provided access token.

Parameters

current_user : User
Current authenticated user injected via dependency

Returns

User
Current user's profile information including username, full_name,
and disabled status

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Responses​

Successful Response
application/json
JSON
{
"username": "string",
"full_name": "string",
"disabled": "string",
"default_project_id": "string",
"system_role": "string"
}

Samples​

cURL
curl -X GET \
'http://localhost/auth/me' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/auth/me', {headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/auth/me';
$method = 'GET';
$headers = [
    'Content-Type' => 'application/json',
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>
Python
import requests

url = 'http://localhost/auth/me'

headers = {
    'Content-Type': 'application/json'
}

response = requests.get(url, headers=headers)
print(response.json())

Logout user​

POST
/auth/logout

Logout the current user.

This endpoint serves as a logout confirmation. Since authentication tokens
are managed client-side (via cookies), no server-side session invalidation
is required. The client is responsible for removing the stored credentials.

Returns

dict[str, str]
Success message confirming logout

Responses​

Successful Response
application/json
JSON
{
"additionalProperties": "string"
}

Samples​

cURL
curl -X POST \
'http://localhost/auth/logout' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/auth/logout', {method:'POST',headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/auth/logout';
$method = 'POST';
$headers = [
    'Content-Type' => 'application/json',
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>
Python
import requests

url = 'http://localhost/auth/logout'

headers = {
    'Content-Type': 'application/json'
}

response = requests.post(url, headers=headers)
print(response.json())

Change user password​

POST
/auth/change-password

Change the current user's password.

Validates the current password and updates to the new password.

Parameters

password_data : PasswordChange
Contains current_password and new_password
current_user : User
Current authenticated user injected via dependency

Returns

dict[str, str]
Success message confirming password change

Raises

HTTPException
400 if current password is incorrect
400 if new password is empty

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Request Body​

JSON
{
"current_password": "string",
"new_password": "string"
}

Responses​

Successful Response
application/json
JSON
{
"additionalProperties": "string"
}

Samples​

cURL
curl -X POST \
'http://localhost/auth/change-password' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/auth/change-password', {method:'POST',headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/auth/change-password';
$method = 'POST';
$headers = [
    'Content-Type' => 'application/json',
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>
Python
import requests

url = 'http://localhost/auth/change-password'

headers = {
    'Content-Type': 'application/json'
}

response = requests.post(url, headers=headers)
print(response.json())

Reset user password (admin only)​

POST
/auth/reset-password

Reset a user's password (admin only).

Allows administrators to reset any user's password without knowing
the current password. This is useful for password recovery scenarios.

Parameters

password_data : PasswordReset
Contains username and new_password
current_user : User
Current authenticated admin user

Returns

dict[str, str]
Success message confirming password reset

Raises

HTTPException
403 if the current user is not an admin
404 if the target user is not found
400 if new password is empty

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Request Body​

JSON
{
"username": "string",
"new_password": "string"
}

Responses​

Successful Response
application/json
JSON
{
"additionalProperties": "string"
}

Samples​

cURL
curl -X POST \
'http://localhost/auth/reset-password' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/auth/reset-password', {method:'POST',headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/auth/reset-password';
$method = 'POST';
$headers = [
    'Content-Type' => 'application/json',
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>
Python
import requests

url = 'http://localhost/auth/reset-password'

headers = {
    'Content-Type': 'application/json'
}

response = requests.post(url, headers=headers)
print(response.json())

admin​

List all users​

GET
/admin/users

List all users in the system (admin only).

Parameters

admin : User
Current admin user (verified by dependency)
skip : int
Number of users to skip for pagination
limit : int
Maximum number of users to return

Returns

UserListResponse
List of users with total count

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Parameters​

Query Parameters

skip
Typeinteger
limit
Typeinteger

Responses​

Successful Response
application/json
JSON
{
"users": [
{
"username": "string",
"full_name": "string",
"disabled": true,
"system_role": "string",
"default_project_id": "string"
}
],
"total": 0
}

Samples​

cURL
curl -X GET \
'http://localhost/admin/users' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/admin/users', {headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/admin/users';
$method = 'GET';
$headers = [
    'Content-Type' => 'application/json',
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>
Python
import requests

url = 'http://localhost/admin/users'

headers = {
    'Content-Type': 'application/json'
}

response = requests.get(url, headers=headers)
print(response.json())

Get user details​

GET
/admin/users/{username}

Get detailed information about a specific user (admin only).

Parameters

username : str
Username to look up
admin : User
Current admin user (verified by dependency)

Returns

UserDetailResponse
Detailed user information

Raises

HTTPException
404 if user not found

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Parameters​

Path Parameters

username*
Typestring
Required

Responses​

Successful Response
application/json
JSON
{
"username": "string",
"full_name": "string",
"disabled": true,
"system_role": "string",
"default_project_id": "string",
"created_at": "string",
"updated_at": "string"
}

Samples​

cURL
curl -X GET \
'http://localhost/admin/users/{username}' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/admin/users/{username}', {headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/admin/users/{username}';
$method = 'GET';
$headers = [
    'Content-Type' => 'application/json',
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>
Python
import requests

url = 'http://localhost/admin/users/{username}'

headers = {
    'Content-Type': 'application/json'
}

response = requests.get(url, headers=headers)
print(response.json())

Update user settings​

PUT
/admin/users/{username}

Update user settings (admin only).

Parameters

username : str
Username to update
request : UpdateUserRequest
Update request with fields to modify
admin : User
Current admin user (verified by dependency)

Returns

UserDetailResponse
Updated user information

Raises

HTTPException
404 if user not found
400 if trying to demote the last admin

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Parameters​

Path Parameters

username*
Typestring
Required

Request Body​

JSON
{
"full_name": "string",
"disabled": "string",
"system_role": "string"
}

Responses​

Successful Response
application/json
JSON
{
"username": "string",
"full_name": "string",
"disabled": true,
"system_role": "string",
"default_project_id": "string",
"created_at": "string",
"updated_at": "string"
}

Samples​

cURL
curl -X PUT \
'http://localhost/admin/users/{username}' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/admin/users/{username}', {method:'PUT',headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/admin/users/{username}';
$method = 'PUT';
$headers = [
    'Content-Type' => 'application/json',
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>
Python
import requests

url = 'http://localhost/admin/users/{username}'

headers = {
    'Content-Type': 'application/json'
}

response = requests.put(url, headers=headers)
print(response.json())

Delete user​

DELETE
/admin/users/{username}

Delete a user account (admin only).

Parameters

username : str
Username to delete
admin : User
Current admin user (verified by dependency)

Returns

dict[str, str]
Success message

Raises

HTTPException
404 if user not found
400 if trying to delete self or last admin

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Parameters​

Path Parameters

username*
Typestring
Required

Responses​

Successful Response
application/json
JSON
{
"additionalProperties": "string"
}

Samples​

cURL
curl -X DELETE \
'http://localhost/admin/users/{username}' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/admin/users/{username}', {method:'DELETE',headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/admin/users/{username}';
$method = 'DELETE';
$headers = [
    'Content-Type' => 'application/json',
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>
Python
import requests

url = 'http://localhost/admin/users/{username}'

headers = {
    'Content-Type': 'application/json'
}

response = requests.delete(url, headers=headers)
print(response.json())

List all projects​

GET
/admin/projects

List all projects in the system (admin only).

Parameters

admin : User
Current admin user (verified by dependency)
skip : int
Number of projects to skip for pagination
limit : int
Maximum number of projects to return

Returns

ProjectListResponse
List of projects with total count

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Parameters​

Query Parameters

skip
Typeinteger
limit
Typeinteger

Responses​

Successful Response
application/json
JSON
{
"projects": [
{
"project_id": "string",
"name": "string",
"owner_username": "string",
"description": "string",
"member_count": 0,
"created_at": "string"
}
],
"total": 0
}

Samples​

cURL
curl -X GET \
'http://localhost/admin/projects' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/admin/projects', {headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/admin/projects';
$method = 'GET';
$headers = [
    'Content-Type' => 'application/json',
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>
Python
import requests

url = 'http://localhost/admin/projects'

headers = {
    'Content-Type': 'application/json'
}

response = requests.get(url, headers=headers)
print(response.json())

Delete project​

DELETE
/admin/projects/{project_id}

Delete a project and all its memberships (admin only).

Parameters

project_id : str
Project ID to delete
admin : User
Current admin user (verified by dependency)

Returns

dict[str, str]
Success message

Raises

HTTPException
404 if project not found
400 if trying to delete own project

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Parameters​

Path Parameters

project_id*
Typestring
Required

Responses​

Successful Response
application/json
JSON
{
"additionalProperties": "string"
}

Samples​

cURL
curl -X DELETE \
'http://localhost/admin/projects/{project_id}' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/admin/projects/{project_id}', {method:'DELETE',headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/admin/projects/{project_id}';
$method = 'DELETE';
$headers = [
    'Content-Type' => 'application/json',
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>
Python
import requests

url = 'http://localhost/admin/projects/{project_id}'

headers = {
    'Content-Type': 'application/json'
}

response = requests.delete(url, headers=headers)
print(response.json())

List project members​

GET
/admin/projects/{project_id}/members

List all members of a project (admin only).

Parameters

project_id : str
Project ID to list members for
admin : User
Current admin user (verified by dependency)

Returns

MemberListResponse
List of members with total count

Raises

HTTPException
404 if project not found

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Parameters​

Path Parameters

project_id*
Typestring
Required

Responses​

Successful Response
application/json
JSON
{
"members": [
{
"username": "string",
"full_name": "string",
"role": "string",
"status": "string"
}
],
"total": 0
}

Samples​

cURL
curl -X GET \
'http://localhost/admin/projects/{project_id}/members' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/admin/projects/{project_id}/members', {headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/admin/projects/{project_id}/members';
$method = 'GET';
$headers = [
    'Content-Type' => 'application/json',
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>
Python
import requests

url = 'http://localhost/admin/projects/{project_id}/members'

headers = {
    'Content-Type': 'application/json'
}

response = requests.get(url, headers=headers)
print(response.json())

Add member to project​

POST
/admin/projects/{project_id}/members

Add a member to a project as viewer (admin only).

Parameters

project_id : str
Project ID to add member to
request : AddMemberRequest
Member details (username)
admin : User
Current admin user (verified by dependency)

Returns

MemberItem
Created member info

Raises

HTTPException
404 if project or user not found
400 if user is already a member

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Parameters​

Path Parameters

project_id*
Typestring
Required

Request Body​

JSON
{
"username": "string"
}

Responses​

Successful Response
application/json
JSON
{
"username": "string",
"full_name": "string",
"role": "string",
"status": "string"
}

Samples​

cURL
curl -X POST \
'http://localhost/admin/projects/{project_id}/members' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/admin/projects/{project_id}/members', {method:'POST',headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/admin/projects/{project_id}/members';
$method = 'POST';
$headers = [
    'Content-Type' => 'application/json',
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>
Python
import requests

url = 'http://localhost/admin/projects/{project_id}/members'

headers = {
    'Content-Type': 'application/json'
}

response = requests.post(url, headers=headers)
print(response.json())

Remove member from project​

DELETE
/admin/projects/{project_id}/members/{username}

Remove a member from a project (admin only).

Parameters

project_id : str
Project ID to remove member from
username : str
Username to remove
admin : User
Current admin user (verified by dependency)

Returns

dict[str, str]
Success message

Raises

HTTPException
404 if project or member not found
400 if trying to remove the owner

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Parameters​

Path Parameters

project_id*
Typestring
Required
username*
Typestring
Required

Responses​

Successful Response
application/json
JSON
{
"additionalProperties": "string"
}

Samples​

cURL
curl -X DELETE \
'http://localhost/admin/projects/{project_id}/members/{username}' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/admin/projects/{project_id}/members/{username}', {method:'DELETE',headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/admin/projects/{project_id}/members/{username}';
$method = 'DELETE';
$headers = [
    'Content-Type' => 'application/json',
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>
Python
import requests

url = 'http://localhost/admin/projects/{project_id}/members/{username}'

headers = {
    'Content-Type': 'application/json'
}

response = requests.delete(url, headers=headers)
print(response.json())

Create project for user​

POST
/admin/users/{username}/project

Create a default project for a user who doesn't have one (admin only).

Parameters

username : str
Username to create project for
admin : User
Current admin user (verified by dependency)

Returns

UserDetailResponse
Updated user information with new project

Raises

HTTPException
404 if user not found
400 if user already has a project

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Parameters​

Path Parameters

username*
Typestring
Required

Responses​

Successful Response
application/json
JSON
{
"username": "string",
"full_name": "string",
"disabled": true,
"system_role": "string",
"default_project_id": "string",
"created_at": "string",
"updated_at": "string"
}

Samples​

cURL
curl -X POST \
'http://localhost/admin/users/{username}/project' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/admin/users/{username}/project', {method:'POST',headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/admin/users/{username}/project';
$method = 'POST';
$headers = [
    'Content-Type' => 'application/json',
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>
Python
import requests

url = 'http://localhost/admin/users/{username}/project'

headers = {
    'Content-Type': 'application/json'
}

response = requests.post(url, headers=headers)
print(response.json())

projects​

List user's projects​

GET
/projects

List all projects the user has access to.

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Responses​

Successful Response
application/json
JSON
{
"projects": [
{
"project_id": "string",
"owner_username": "string",
"name": "string",
"description": "string",
"tags": [
"string"
],
"default_role": "string",
"created_at": "string",
"updated_at": "string"
}
],
"total": 0
}

Samples​

cURL
curl -X GET \
'http://localhost/projects' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/projects', {headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/projects';
$method = 'GET';
$headers = [
    'Content-Type' => 'application/json',
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>
Python
import requests

url = 'http://localhost/projects'

headers = {
    'Content-Type': 'application/json'
}

response = requests.get(url, headers=headers)
print(response.json())

Create a new project​

POST
/projects

Create a new project with the current user as owner.

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Request Body​

JSON
{
"name": "string",
"description": "string",
"tags": [
"string"
]
}

Responses​

Successful Response
application/json
JSON
{
"project_id": "string",
"owner_username": "string",
"name": "string",
"description": "string",
"tags": [
"string"
],
"default_role": "string",
"created_at": "string",
"updated_at": "string"
}

Samples​

cURL
curl -X POST \
'http://localhost/projects' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/projects', {method:'POST',headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/projects';
$method = 'POST';
$headers = [
    'Content-Type' => 'application/json',
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>
Python
import requests

url = 'http://localhost/projects'

headers = {
    'Content-Type': 'application/json'
}

response = requests.post(url, headers=headers)
print(response.json())

Get project details​

GET
/projects/{project_id}

Get details of a specific project.

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Parameters​

Path Parameters

project_id*

Project identifier

Typestring
Required

Responses​

Successful Response
application/json
JSON
{
"project_id": "string",
"owner_username": "string",
"name": "string",
"description": "string",
"tags": [
"string"
],
"default_role": "string",
"created_at": "string",
"updated_at": "string"
}

Samples​

cURL
curl -X GET \
'http://localhost/projects/{project_id}' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/projects/{project_id}', {headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/projects/{project_id}';
$method = 'GET';
$headers = [
    'Content-Type' => 'application/json',
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>
Python
import requests

url = 'http://localhost/projects/{project_id}'

headers = {
    'Content-Type': 'application/json'
}

response = requests.get(url, headers=headers)
print(response.json())

Delete project​

DELETE
/projects/{project_id}

Delete a project. Owner only.

Warning: This will delete the project but NOT the associated data.
Data cleanup should be handled separately.

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Parameters​

Path Parameters

project_id*

Project identifier

Typestring
Required

Responses​

Successful Response

Samples​

cURL
curl -X DELETE \
'http://localhost/projects/{project_id}' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/projects/{project_id}', {method:'DELETE',headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/projects/{project_id}';
$method = 'DELETE';
$headers = [
    'Content-Type' => 'application/json',
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>
Python
import requests

url = 'http://localhost/projects/{project_id}'

headers = {
    'Content-Type': 'application/json'
}

response = requests.delete(url, headers=headers)
print(response.json())

Update project​

PATCH
/projects/{project_id}

Update project settings. Owner only.

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Parameters​

Path Parameters

project_id*

Project identifier

Typestring
Required

Request Body​

JSON
{
"name": "string",
"description": "string",
"tags": "string",
"default_role": "string"
}

Responses​

Successful Response
application/json
JSON
{
"project_id": "string",
"owner_username": "string",
"name": "string",
"description": "string",
"tags": [
"string"
],
"default_role": "string",
"created_at": "string",
"updated_at": "string"
}

Samples​

cURL
curl -X PATCH \
'http://localhost/projects/{project_id}' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/projects/{project_id}', {method:'PATCH',headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/projects/{project_id}';
$method = 'PATCH';
$headers = [
    'Content-Type' => 'application/json',
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>
Python
import requests

url = 'http://localhost/projects/{project_id}'

headers = {
    'Content-Type': 'application/json'
}

response = requests.patch(url, headers=headers)
print(response.json())

List project members​

GET
/projects/{project_id}/members

List all members of a project.

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Parameters​

Path Parameters

project_id*

Project identifier

Typestring
Required

Responses​

Successful Response
application/json
JSON
{
"members": [
{
"project_id": "string",
"username": "string",
"role": "string",
"status": "string",
"invited_by": "string",
"last_accessed_at": "string"
}
],
"total": 0
}

Samples​

cURL
curl -X GET \
'http://localhost/projects/{project_id}/members' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/projects/{project_id}/members', {headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/projects/{project_id}/members';
$method = 'GET';
$headers = [
    'Content-Type' => 'application/json',
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>
Python
import requests

url = 'http://localhost/projects/{project_id}/members'

headers = {
    'Content-Type': 'application/json'
}

response = requests.get(url, headers=headers)
print(response.json())

Invite a member​

POST
/projects/{project_id}/members

Invite a user to the project. Admin only.

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Parameters​

Path Parameters

project_id*
Typestring
Required

Request Body​

JSON
{
"username": "string",
"role": "string"
}

Responses​

Successful Response
application/json
JSON
{
"project_id": "string",
"username": "string",
"role": "string",
"status": "string",
"invited_by": "string",
"last_accessed_at": "string"
}

Samples​

cURL
curl -X POST \
'http://localhost/projects/{project_id}/members' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/projects/{project_id}/members', {method:'POST',headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/projects/{project_id}/members';
$method = 'POST';
$headers = [
    'Content-Type' => 'application/json',
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>
Python
import requests

url = 'http://localhost/projects/{project_id}/members'

headers = {
    'Content-Type': 'application/json'
}

response = requests.post(url, headers=headers)
print(response.json())

Remove member​

DELETE
/projects/{project_id}/members/{username}

Remove a member from the project. Admin only.

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Parameters​

Path Parameters

project_id*
Typestring
Required
username*
Typestring
Required

Responses​

Successful Response

Samples​

cURL
curl -X DELETE \
'http://localhost/projects/{project_id}/members/{username}' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/projects/{project_id}/members/{username}', {method:'DELETE',headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/projects/{project_id}/members/{username}';
$method = 'DELETE';
$headers = [
    'Content-Type' => 'application/json',
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>
Python
import requests

url = 'http://localhost/projects/{project_id}/members/{username}'

headers = {
    'Content-Type': 'application/json'
}

response = requests.delete(url, headers=headers)
print(response.json())

Update member role​

PATCH
/projects/{project_id}/members/{username}

Update a member's role. Admin only.

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Parameters​

Path Parameters

project_id*
Typestring
Required
username*
Typestring
Required

Request Body​

JSON
{
"role": "string"
}

Responses​

Successful Response
application/json
JSON
{
"project_id": "string",
"username": "string",
"role": "string",
"status": "string",
"invited_by": "string",
"last_accessed_at": "string"
}

Samples​

cURL
curl -X PATCH \
'http://localhost/projects/{project_id}/members/{username}' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/projects/{project_id}/members/{username}', {method:'PATCH',headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/projects/{project_id}/members/{username}';
$method = 'PATCH';
$headers = [
    'Content-Type' => 'application/json',
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>
Python
import requests

url = 'http://localhost/projects/{project_id}/members/{username}'

headers = {
    'Content-Type': 'application/json'
}

response = requests.patch(url, headers=headers)
print(response.json())

Transfer project ownership​

POST
/projects/{project_id}/transfer

Transfer project ownership to another user. Admin only.

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Parameters​

Path Parameters

project_id*
Typestring
Required

Request Body​

JSON
{
"username": "string",
"role": "string"
}

Responses​

Successful Response
application/json
JSON
{
"project_id": "string",
"owner_username": "string",
"name": "string",
"description": "string",
"tags": [
"string"
],
"default_role": "string",
"created_at": "string",
"updated_at": "string"
}

Samples​

cURL
curl -X POST \
'http://localhost/projects/{project_id}/transfer' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/projects/{project_id}/transfer', {method:'POST',headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/projects/{project_id}/transfer';
$method = 'POST';
$headers = [
    'Content-Type' => 'application/json',
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>
Python
import requests

url = 'http://localhost/projects/{project_id}/transfer'

headers = {
    'Content-Type': 'application/json'
}

response = requests.post(url, headers=headers)
print(response.json())

execution​

Get a calibration figure by its path​

GET
/executions/figure

Fetch a calibration figure by its file path.

Retrieves a PNG image file from the server's filesystem and returns it
as a streaming response.

Parameters

path : str
Absolute file path to the calibration figure image

Returns

FileResponse
PNG image data as a file response with media type "image/png"

Raises

HTTPException
404 if the file does not exist at the specified path

Parameters​

Query Parameters

path*
Typestring
Required

Responses​

Successful Response

Samples​

cURL
curl -X GET \
'http://localhost/executions/figure' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/executions/figure', {headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/executions/figure';
$method = 'GET';
$headers = [
    'Content-Type' => 'application/json',
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>
Python
import requests

url = 'http://localhost/executions/figure'

headers = {
    'Content-Type': 'application/json'
}

response = requests.get(url, headers=headers)
print(response.json())

Get the execution lock status​

GET
/executions/lock-status

Fetch the current status of the execution lock.

The execution lock prevents concurrent calibration workflows from running
simultaneously. This endpoint checks whether a lock is currently held.

Parameters

ctx : ProjectContext
Project context with user and project information
execution_service : ExecutionService
Service for execution operations

Returns

ExecutionLockStatusResponse
Response containing lock status (True if locked, False if available)

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Parameters​

Header Parameters

X-Project-Id

Responses​

Successful Response
application/json
JSON
{
"lock": true
}

Samples​

cURL
curl -X GET \
'http://localhost/executions/lock-status' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/executions/lock-status', {headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/executions/lock-status';
$method = 'GET';
$headers = [
    'Content-Type' => 'application/json',
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>
Python
import requests

url = 'http://localhost/executions/lock-status'

headers = {
    'Content-Type': 'application/json'
}

response = requests.get(url, headers=headers)
print(response.json())

List executions​

GET
/executions

List executions for a given chip with pagination.

Parameters

ctx : ProjectContext
Project context with user and project information
execution_service : ExecutionService
Service for execution operations
chip_id : str
ID of the chip to fetch executions for
skip : int
Number of items to skip (default: 0)
limit : int
Number of items to return (default: 20, max: 100)

Returns

ListExecutionsResponse
Wrapped list of executions for the chip

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Parameters​

Header Parameters

X-Project-Id

Query Parameters

chip_id*

Chip ID to filter executions

Typestring
Required
skip

Number of items to skip

Typeinteger
limit

Number of items to return

Typeinteger

Responses​

Successful Response
application/json
JSON
{
"executions": [
{
"name": "string",
"execution_id": "string",
"status": "string",
"start_at": "string",
"end_at": "string",
"elapsed_time": "string",
"tags": [
"string"
],
"note": {
"additionalProperties": "string"
}
}
],
"total": "string",
"skip": "string",
"limit": "string"
}

Samples​

cURL
curl -X GET \
'http://localhost/executions' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/executions', {headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/executions';
$method = 'GET';
$headers = [
    'Content-Type' => 'application/json',
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>
Python
import requests

url = 'http://localhost/executions'

headers = {
    'Content-Type': 'application/json'
}

response = requests.get(url, headers=headers)
print(response.json())

Get an execution by its ID​

GET
/executions/{execution_id}

Return the execution detail by its ID.

Parameters

execution_id : str
ID of the execution to fetch
ctx : ProjectContext
Project context with user and project information
execution_service : ExecutionService
Service for execution operations

Returns

ExecutionResponseDetail
Detailed execution information

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Parameters​

Header Parameters

X-Project-Id

Path Parameters

execution_id*
Typestring
Required

Responses​

Successful Response
application/json
JSON
{
"name": "string",
"status": "string",
"start_at": "string",
"end_at": "string",
"elapsed_time": "string",
"task": [
{
"task_id": "string",
"qid": "string",
"name": "string",
"upstream_id": "string",
"status": "string",
"message": "string",
"input_parameters": "string",
"output_parameters": "string",
"output_parameter_names": "string",
"note": "string",
"figure_path": "string",
"json_figure_path": "string",
"raw_data_path": "string",
"start_at": "string",
"end_at": "string",
"elapsed_time": "string",
"task_type": "string",
"default_view": true
}
],
"note": {
"additionalProperties": "string"
}
}

Samples​

cURL
curl -X GET \
'http://localhost/executions/{execution_id}' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/executions/{execution_id}', {headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/executions/{execution_id}';
$method = 'GET';
$headers = [
    'Content-Type' => 'application/json',
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>
Python
import requests

url = 'http://localhost/executions/{execution_id}'

headers = {
    'Content-Type': 'application/json'
}

response = requests.get(url, headers=headers)
print(response.json())

file​

Download file​

GET
/files/raw-data

Download a raw data file from the server.

Retrieves a file from the server's filesystem and returns it as a downloadable
response.

Parameters

path : str
Absolute file path to the file to download

Returns

FileResponse
The file as a downloadable response

Raises

HTTPException
404 if the file does not exist at the specified path

Parameters​

Query Parameters

path*
Typestring
Required

Responses​

Successful Response

Samples​

cURL
curl -X GET \
'http://localhost/files/raw-data' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/files/raw-data', {headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/files/raw-data';
$method = 'GET';
$headers = [
    'Content-Type' => 'application/json',
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>
Python
import requests

url = 'http://localhost/files/raw-data'

headers = {
    'Content-Type': 'application/json'
}

response = requests.get(url, headers=headers)
print(response.json())

Download file or directory as zip​

GET
/files/zip

Download a file or directory as a ZIP archive.

Creates a ZIP archive of the specified file or directory and returns it
as a downloadable response. The archive is created in a temporary directory
and cleaned up after the response is sent.

Parameters

path : str
Absolute path to the file or directory to archive

Returns

FileResponse
ZIP archive as a downloadable response with media type "application/zip"

Raises

HTTPException
404 if the path does not exist
500 if there is an error creating the ZIP archive

Parameters​

Query Parameters

path*
Typestring
Required

Responses​

Successful Response

Samples​

cURL
curl -X GET \
'http://localhost/files/zip' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/files/zip', {headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/files/zip';
$method = 'GET';
$headers = [
    'Content-Type' => 'application/json',
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>
Python
import requests

url = 'http://localhost/files/zip'

headers = {
    'Content-Type': 'application/json'
}

response = requests.get(url, headers=headers)
print(response.json())

Get file tree for entire config directory​

GET
/files/tree

Get file tree structure for entire config directory (all chips).

Returns

File tree structure

Responses​

Successful Response
application/json
JSON
[
{
"name": "string",
"path": "string",
"type": "string",
"children": "string"
}
]

Samples​

cURL
curl -X GET \
'http://localhost/files/tree' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/files/tree', {headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/files/tree';
$method = 'GET';
$headers = [
    'Content-Type' => 'application/json',
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>
Python
import requests

url = 'http://localhost/files/tree'

headers = {
    'Content-Type': 'application/json'
}

response = requests.get(url, headers=headers)
print(response.json())

Get file content for editing​

GET
/files/content

Get file content for editing.

Args:

path: Relative path from CONFIG_BASE_PATH (e.g., "64Qv2/config/chip.yaml")

Returns:

File content and metadata

Parameters​

Query Parameters

path*
Typestring
Required

Responses​

Successful Response
application/json
JSON
{
"additionalProperties": "string"
}

Samples​

cURL
curl -X GET \
'http://localhost/files/content' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/files/content', {headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/files/content';
$method = 'GET';
$headers = [
    'Content-Type' => 'application/json',
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>
Python
import requests

url = 'http://localhost/files/content'

headers = {
    'Content-Type': 'application/json'
}

response = requests.get(url, headers=headers)
print(response.json())

Save file content​

PUT
/files/content

Save file content.

Args:

request: Save file request with path and content

Returns:

Success message

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Request Body​

JSON
{
"path": "string",
"content": "string"
}

Responses​

Successful Response
application/json
JSON
{
"additionalProperties": "string"
}

Samples​

cURL
curl -X PUT \
'http://localhost/files/content' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/files/content', {method:'PUT',headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/files/content';
$method = 'PUT';
$headers = [
    'Content-Type' => 'application/json',
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>
Python
import requests

url = 'http://localhost/files/content'

headers = {
    'Content-Type': 'application/json'
}

response = requests.put(url, headers=headers)
print(response.json())

Validate file content (YAML/JSON)​

POST
/files/validate

Validate YAML or JSON content.

Args:

request: Validation request with content and file_type

Returns:

Validation result

Request Body​

JSON
{
"content": "string",
"file_type": "string"
}

Responses​

Successful Response
application/json
JSON
{
"additionalProperties": "string"
}

Samples​

cURL
curl -X POST \
'http://localhost/files/validate' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/files/validate', {method:'POST',headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/files/validate';
$method = 'POST';
$headers = [
    'Content-Type' => 'application/json',
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>
Python
import requests

url = 'http://localhost/files/validate'

headers = {
    'Content-Type': 'application/json'
}

response = requests.post(url, headers=headers)
print(response.json())

Get Git status of config directory​

GET
/files/git/status

Get Git status of config directory.

Returns

Git status information

Responses​

Successful Response
application/json
JSON
{
"additionalProperties": "string"
}

Samples​

cURL
curl -X GET \
'http://localhost/files/git/status' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/files/git/status', {headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/files/git/status';
$method = 'GET';
$headers = [
    'Content-Type' => 'application/json',
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>
Python
import requests

url = 'http://localhost/files/git/status'

headers = {
    'Content-Type': 'application/json'
}

response = requests.get(url, headers=headers)
print(response.json())

Pull latest config from Git repository​

POST
/files/git/pull

Pull latest config from Git repository.

Returns

Pull operation result

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Responses​

Successful Response
application/json
JSON
{
"additionalProperties": "string"
}

Samples​

cURL
curl -X POST \
'http://localhost/files/git/pull' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/files/git/pull', {method:'POST',headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/files/git/pull';
$method = 'POST';
$headers = [
    'Content-Type' => 'application/json',
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>
Python
import requests

url = 'http://localhost/files/git/pull'

headers = {
    'Content-Type': 'application/json'
}

response = requests.post(url, headers=headers)
print(response.json())

Push config changes to Git repository​

POST
/files/git/push

Push config changes to Git repository.

Args:

request: Push request with commit message

Returns:

Push operation result

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Request Body​

JSON
{
"commit_message": "string"
}

Responses​

Successful Response
application/json
JSON
{
"additionalProperties": "string"
}

Samples​

cURL
curl -X POST \
'http://localhost/files/git/push' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/files/git/push', {method:'POST',headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/files/git/push';
$method = 'POST';
$headers = [
    'Content-Type' => 'application/json',
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>
Python
import requests

url = 'http://localhost/files/git/push'

headers = {
    'Content-Type': 'application/json'
}

response = requests.post(url, headers=headers)
print(response.json())

calibration​

Get the calibration note​

GET
/calibrations/note

Get the latest calibration note for the master task.

Retrieves the most recent calibration note from the database, sorted by timestamp
in descending order. The note contains metadata about calibration parameters
and configuration.

Parameters

ctx : ProjectContext
Project context with user and project information
calibration_service : CalibrationService
Service for calibration operations

Returns

CalibrationNoteResponse
The latest calibration note containing username, execution_id, task_id,
note content, and timestamp

Raises

HTTPException
404 if no calibration note is found

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Parameters​

Header Parameters

X-Project-Id

Responses​

Successful Response
application/json
JSON
{
"username": "string",
"execution_id": "string",
"task_id": "string",
"note": {
"additionalProperties": "string"
},
"timestamp": "string"
}

Samples​

cURL
curl -X GET \
'http://localhost/calibrations/note' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/calibrations/note', {headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/calibrations/note';
$method = 'GET';
$headers = [
    'Content-Type' => 'application/json',
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>
Python
import requests

url = 'http://localhost/calibrations/note'

headers = {
    'Content-Type': 'application/json'
}

response = requests.get(url, headers=headers)
print(response.json())

copilot​

Get Copilot configuration​

GET
/copilot/config

Get Copilot configuration for the metrics assistant.

Retrieves the Copilot configuration from YAML, including:

  • enabled: Whether Copilot is enabled
  • evaluation_metrics: Which metrics to use for multi-metric evaluation
  • scoring: Thresholds for good/excellent ratings per metric
  • system_prompt: The AI assistant's system prompt
  • initial_message: The initial greeting message

Returns

dict[str, Any]
Copilot configuration dictionary

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Responses​

Successful Response
application/json
JSON
{
"additionalProperties": "string"
}

Samples​

cURL
curl -X GET \
'http://localhost/copilot/config' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/copilot/config', {headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/copilot/config';
$method = 'GET';
$headers = [
    'Content-Type' => 'application/json',
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>
Python
import requests

url = 'http://localhost/copilot/config'

headers = {
    'Content-Type': 'application/json'
}

response = requests.get(url, headers=headers)
print(response.json())

settings​

Operations​

GET/settings

Get settings​

GET
/settings

Get settings from the server

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Responses​

Successful Response
application/json
JSON
{
"env": "string",
"client_url": "string",
"prefect_api_url": "string",
"slack_bot_token": "string",
"slack_channel_id": "string",
"postgres_data_path": "string",
"mongo_data_path": "string",
"calib_data_path": "string",
"backend": "string",
"mongo_db_name": "string",
"mongo_port": 0,
"mongo_express_port": 0,
"postgres_port": 0,
"prefect_port": 0,
"api_port": 0,
"ui_port": 0,
"log_level": "string",
"timezone": "string"
}

Samples​

cURL
curl -X GET \
'http://localhost/settings' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/settings', {headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/settings';
$method = 'GET';
$headers = [
    'Content-Type' => 'application/json',
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>
Python
import requests

url = 'http://localhost/settings'

headers = {
    'Content-Type': 'application/json'
}

response = requests.get(url, headers=headers)
print(response.json())

chip​

List all chips​

GET
/chips

List all chips with summary information.

Returns chip metadata (id, size, topology, qubit/coupling counts).
For detailed qubit/coupling data, use the dedicated endpoints.

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Parameters​

Header Parameters

X-Project-Id

Responses​

Successful Response
application/json
JSON
{
"chips": [
{
"chip_id": "string",
"size": 0,
"topology_id": "string",
"qubit_count": 0,
"coupling_count": 0,
"installed_at": "string"
}
],
"total": 0
}

Samples​

cURL
curl -X GET \
'http://localhost/chips' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/chips', {headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/chips';
$method = 'GET';
$headers = [
    'Content-Type' => 'application/json',
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>
Python
import requests

url = 'http://localhost/chips'

headers = {
    'Content-Type': 'application/json'
}

response = requests.get(url, headers=headers)
print(response.json())

Create a new chip​

POST
/chips

Create a new chip in the current project.

Parameters

request : CreateChipRequest
Chip creation request containing chip_id and size
ctx : ProjectContext
Project context with owner permission

Returns

ChipResponse
Created chip information

Raises

HTTPException
If chip_id already exists or size is invalid

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Parameters​

Header Parameters

X-Project-Id

Request Body​

JSON
{
"chip_id": "string",
"size": 0,
"topology_id": "string"
}

Responses​

Successful Response
application/json
JSON
{
"chip_id": "string",
"size": 0,
"topology_id": "string",
"qubit_count": 0,
"coupling_count": 0,
"installed_at": "string"
}

Samples​

cURL
curl -X POST \
'http://localhost/chips' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/chips', {method:'POST',headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/chips';
$method = 'POST';
$headers = [
    'Content-Type' => 'application/json',
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>
Python
import requests

url = 'http://localhost/chips'

headers = {
    'Content-Type': 'application/json'
}

response = requests.post(url, headers=headers)
print(response.json())

Get available dates for a chip​

GET
/chips/{chip_id}/dates

Fetch available dates for a chip from execution counter.

Parameters

chip_id : str
ID of the chip
ctx : ProjectContext
Project context with user and project information
chip_service : ChipService
Service for chip operations

Returns

ChipDatesResponse
List of available dates

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Parameters​

Header Parameters

X-Project-Id

Path Parameters

chip_id*
Typestring
Required

Responses​

Successful Response
application/json
JSON
{
"data": [
"string"
]
}

Samples​

cURL
curl -X GET \
'http://localhost/chips/{chip_id}/dates' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/chips/{chip_id}/dates', {headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/chips/{chip_id}/dates';
$method = 'GET';
$headers = [
    'Content-Type' => 'application/json',
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>
Python
import requests

url = 'http://localhost/chips/{chip_id}/dates'

headers = {
    'Content-Type': 'application/json'
}

response = requests.get(url, headers=headers)
print(response.json())

Get multiplexer details​

GET
/chips/{chip_id}/muxes/{mux_id}

Get the multiplexer details.

Parameters

chip_id : str
ID of the chip
mux_id : int
ID of the multiplexer
ctx : ProjectContext
Project context with user and project information
chip_service : ChipService
Service for chip operations

Returns

MuxDetailResponse
Multiplexer details

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Parameters​

Header Parameters

X-Project-Id

Path Parameters

chip_id*
Typestring
Required
mux_id*
Typeinteger
Required

Responses​

Successful Response
application/json
JSON
{
"mux_id": 0,
"detail": {
"additionalProperties": {
}
}
}

Samples​

cURL
curl -X GET \
'http://localhost/chips/{chip_id}/muxes/{mux_id}' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/chips/{chip_id}/muxes/{mux_id}', {headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/chips/{chip_id}/muxes/{mux_id}';
$method = 'GET';
$headers = [
    'Content-Type' => 'application/json',
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>
Python
import requests

url = 'http://localhost/chips/{chip_id}/muxes/{mux_id}'

headers = {
    'Content-Type': 'application/json'
}

response = requests.get(url, headers=headers)
print(response.json())

List all multiplexers for a chip​

GET
/chips/{chip_id}/muxes

List all multiplexers for a chip.

Parameters

chip_id : str
ID of the chip
ctx : ProjectContext
Project context with user and project information
chip_service : ChipService
Service for chip operations

Returns

ListMuxResponse
List of multiplexer details

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Parameters​

Header Parameters

X-Project-Id

Path Parameters

chip_id*
Typestring
Required

Responses​

Successful Response
application/json
JSON
{
"muxes": {
"additionalProperties": {
}
}
}

Samples​

cURL
curl -X GET \
'http://localhost/chips/{chip_id}/muxes' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/chips/{chip_id}/muxes', {headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/chips/{chip_id}/muxes';
$method = 'GET';
$headers = [
    'Content-Type' => 'application/json',
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>
Python
import requests

url = 'http://localhost/chips/{chip_id}/muxes'

headers = {
    'Content-Type': 'application/json'
}

response = requests.get(url, headers=headers)
print(response.json())

Get chip details​

GET
/chips/{chip_id}

Get chip details including metadata and counts.

Returns chip metadata (size, topology, qubit/coupling counts).
For detailed qubit/coupling data, use the dedicated endpoints.

Parameters

chip_id : str
ID of the chip
ctx : ProjectContext
Project context with user and project information
chip_service : ChipService
Service for chip operations

Returns

ChipResponse
Chip details

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Parameters​

Header Parameters

X-Project-Id

Path Parameters

chip_id*
Typestring
Required

Responses​

Successful Response
application/json
JSON
{
"chip_id": "string",
"size": 0,
"topology_id": "string",
"qubit_count": 0,
"coupling_count": 0,
"installed_at": "string"
}

Samples​

cURL
curl -X GET \
'http://localhost/chips/{chip_id}' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/chips/{chip_id}', {headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/chips/{chip_id}';
$method = 'GET';
$headers = [
    'Content-Type' => 'application/json',
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>
Python
import requests

url = 'http://localhost/chips/{chip_id}'

headers = {
    'Content-Type': 'application/json'
}

response = requests.get(url, headers=headers)
print(response.json())

List qubits for a chip​

GET
/chips/{chip_id}/qubits

List qubits for a chip with pagination.

Retrieves qubit data from the separate QubitDocument collection.
Supports filtering by specific qubit IDs.

Parameters

chip_id : str
ID of the chip
ctx : ProjectContext
Project context with user and project information
chip_service : ChipService
Service for chip operations
limit : int
Maximum number of qubits to return (default 50, max 256)
offset : int
Number of qubits to skip for pagination
qids : list[str] | None
Optional list of specific qubit IDs to fetch

Returns

ListQubitsResponse
List of qubits with pagination info

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Parameters​

Header Parameters

X-Project-Id

Path Parameters

chip_id*
Typestring
Required

Query Parameters

limit
Typeinteger
offset
Typeinteger
qids

Responses​

Successful Response
application/json
JSON
{
"qubits": [
{
"qid": "string",
"chip_id": "string",
"status": "string",
"data": {
"additionalProperties": "string"
}
}
],
"total": 0,
"limit": 0,
"offset": 0
}

Samples​

cURL
curl -X GET \
'http://localhost/chips/{chip_id}/qubits' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/chips/{chip_id}/qubits', {headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/chips/{chip_id}/qubits';
$method = 'GET';
$headers = [
    'Content-Type' => 'application/json',
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>
Python
import requests

url = 'http://localhost/chips/{chip_id}/qubits'

headers = {
    'Content-Type': 'application/json'
}

response = requests.get(url, headers=headers)
print(response.json())

Get a single qubit​

GET
/chips/{chip_id}/qubits/{qid}

Get a single qubit by ID.

This is 10-18x faster than fetching the full chip and extracting one qubit.

Parameters

chip_id : str
ID of the chip
qid : str
ID of the qubit
ctx : ProjectContext
Project context with user and project information
chip_service : ChipService
Service for chip operations

Returns

QubitResponse
Qubit data

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Parameters​

Header Parameters

X-Project-Id

Path Parameters

chip_id*
Typestring
Required
qid*
Typestring
Required

Responses​

Successful Response
application/json
JSON
{
"qid": "string",
"chip_id": "string",
"status": "string",
"data": {
"additionalProperties": "string"
}
}

Samples​

cURL
curl -X GET \
'http://localhost/chips/{chip_id}/qubits/{qid}' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/chips/{chip_id}/qubits/{qid}', {headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/chips/{chip_id}/qubits/{qid}';
$method = 'GET';
$headers = [
    'Content-Type' => 'application/json',
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>
Python
import requests

url = 'http://localhost/chips/{chip_id}/qubits/{qid}'

headers = {
    'Content-Type': 'application/json'
}

response = requests.get(url, headers=headers)
print(response.json())

List couplings for a chip​

GET
/chips/{chip_id}/couplings

List couplings for a chip with pagination.

Retrieves coupling data from the separate CouplingDocument collection.

Parameters

chip_id : str
ID of the chip
ctx : ProjectContext
Project context with user and project information
chip_service : ChipService
Service for chip operations
limit : int
Maximum number of couplings to return (default 100, max 512)
offset : int
Number of couplings to skip for pagination

Returns

ListCouplingsResponse
List of couplings with pagination info

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Parameters​

Header Parameters

X-Project-Id

Path Parameters

chip_id*
Typestring
Required

Query Parameters

limit
Typeinteger
offset
Typeinteger

Responses​

Successful Response
application/json
JSON
{
"couplings": [
{
"qid": "string",
"chip_id": "string",
"status": "string",
"data": {
"additionalProperties": "string"
}
}
],
"total": 0,
"limit": 0,
"offset": 0
}

Samples​

cURL
curl -X GET \
'http://localhost/chips/{chip_id}/couplings' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/chips/{chip_id}/couplings', {headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/chips/{chip_id}/couplings';
$method = 'GET';
$headers = [
    'Content-Type' => 'application/json',
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>
Python
import requests

url = 'http://localhost/chips/{chip_id}/couplings'

headers = {
    'Content-Type': 'application/json'
}

response = requests.get(url, headers=headers)
print(response.json())

Get a single coupling​

GET
/chips/{chip_id}/couplings/{coupling_id}

Get a single coupling by ID.

Parameters

chip_id : str
ID of the chip
coupling_id : str
ID of the coupling (e.g., "0-1")
ctx : ProjectContext
Project context with user and project information
chip_service : ChipService
Service for chip operations

Returns

CouplingResponse
Coupling data

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Parameters​

Header Parameters

X-Project-Id

Path Parameters

chip_id*
Typestring
Required
coupling_id*
Typestring
Required

Responses​

Successful Response
application/json
JSON
{
"qid": "string",
"chip_id": "string",
"status": "string",
"data": {
"additionalProperties": "string"
}
}

Samples​

cURL
curl -X GET \
'http://localhost/chips/{chip_id}/couplings/{coupling_id}' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/chips/{chip_id}/couplings/{coupling_id}', {headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/chips/{chip_id}/couplings/{coupling_id}';
$method = 'GET';
$headers = [
    'Content-Type' => 'application/json',
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>
Python
import requests

url = 'http://localhost/chips/{chip_id}/couplings/{coupling_id}'

headers = {
    'Content-Type': 'application/json'
}

response = requests.get(url, headers=headers)
print(response.json())

Get aggregated metrics summary​

GET
/chips/{chip_id}/metrics/summary

Get aggregated metrics summary for a chip.

Computes statistics (averages, counts) on the database side.
Returns ~0.1KB of data, ideal for dashboard overview.

Parameters

chip_id : str
ID of the chip
ctx : ProjectContext
Project context with user and project information
chip_service : ChipService
Service for chip operations

Returns

MetricsSummaryResponse
Aggregated metrics summary

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Parameters​

Header Parameters

X-Project-Id

Path Parameters

chip_id*
Typestring
Required

Responses​

Successful Response
application/json
JSON
{
"chip_id": "string",
"qubit_count": 0,
"averages": {
"additionalProperties": {
}
}
}

Samples​

cURL
curl -X GET \
'http://localhost/chips/{chip_id}/metrics/summary' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/chips/{chip_id}/metrics/summary', {headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/chips/{chip_id}/metrics/summary';
$method = 'GET';
$headers = [
    'Content-Type' => 'application/json',
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>
Python
import requests

url = 'http://localhost/chips/{chip_id}/metrics/summary'

headers = {
    'Content-Type': 'application/json'
}

response = requests.get(url, headers=headers)
print(response.json())

Get heatmap data for a single metric​

GET
/chips/{chip_id}/metrics/heatmap/{metric}

Get heatmap data for a single metric.

Returns only the values needed for heatmap visualization (~5KB).
Much more efficient than fetching full chip data (~300KB+).

Supported metrics:

  • Qubit: t1, t2_echo, t2_star, qubit_frequency, anharmonicity,
    average_readout_fidelity, x90_gate_fidelity, x180_gate_fidelity
  • Coupling: zx90_gate_fidelity, bell_state_fidelity, static_zz_interaction

Parameters

chip_id : str
ID of the chip
metric : str
Name of the metric to retrieve
ctx : ProjectContext
Project context with user and project information
chip_service : ChipService
Service for chip operations

Returns

MetricHeatmapResponse
Metric values keyed by qubit/coupling ID

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Parameters​

Header Parameters

X-Project-Id

Path Parameters

chip_id*
Typestring
Required
metric*
Typestring
Required

Responses​

Successful Response
application/json
JSON
{
"chip_id": "string",
"metric": "string",
"values": {
"additionalProperties": {
}
},
"unit": "string"
}

Samples​

cURL
curl -X GET \
'http://localhost/chips/{chip_id}/metrics/heatmap/{metric}' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/chips/{chip_id}/metrics/heatmap/{metric}', {headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/chips/{chip_id}/metrics/heatmap/{metric}';
$method = 'GET';
$headers = [
    'Content-Type' => 'application/json',
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>
Python
import requests

url = 'http://localhost/chips/{chip_id}/metrics/heatmap/{metric}'

headers = {
    'Content-Type': 'application/json'
}

response = requests.get(url, headers=headers)
print(response.json())

task​

List all tasks​

GET
/tasks

List all tasks.

Parameters

ctx : ProjectContext
The project context with user and project information.
task_repo : MongoTaskDefinitionRepository
Repository for task definition operations.
backend : str | None
Optional backend name to filter tasks by.

Returns

ListTaskResponse
The list of tasks.

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Parameters​

Header Parameters

X-Project-Id

Query Parameters

backend

Optional backend name to filter tasks by

Responses​

Successful Response
application/json
JSON
{
"tasks": [
{
"name": "string",
"description": "string",
"backend": "string",
"task_type": "string",
"input_parameters": {
"additionalProperties": {
}
},
"output_parameters": {
"additionalProperties": {
}
}
}
]
}

Samples​

cURL
curl -X GET \
'http://localhost/tasks' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/tasks', {headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/tasks';
$method = 'GET';
$headers = [
    'Content-Type' => 'application/json',
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>
Python
import requests

url = 'http://localhost/tasks'

headers = {
    'Content-Type': 'application/json'
}

response = requests.get(url, headers=headers)
print(response.json())

Get task result by task ID​

GET
/tasks/{task_id}/result

Get task result by task_id.

Parameters

task_id : str
The task ID to search for.
ctx : ProjectContext
The project context with user and project information.

Returns

TaskResultResponse
The task result information including figure paths.

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Parameters​

Header Parameters

X-Project-Id

Path Parameters

task_id*
Typestring
Required

Responses​

Successful Response
application/json
JSON
{
"task_id": "string",
"task_name": "string",
"qid": "string",
"status": "string",
"execution_id": "string",
"figure_path": [
"string"
],
"json_figure_path": [
"string"
],
"input_parameters": {
"additionalProperties": "string"
},
"output_parameters": {
"additionalProperties": "string"
},
"start_at": "string",
"end_at": "string",
"elapsed_time": "string"
}

Samples​

cURL
curl -X GET \
'http://localhost/tasks/{task_id}/result' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/tasks/{task_id}/result', {headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/tasks/{task_id}/result';
$method = 'GET';
$headers = [
    'Content-Type' => 'application/json',
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>
Python
import requests

url = 'http://localhost/tasks/{task_id}/result'

headers = {
    'Content-Type': 'application/json'
}

response = requests.get(url, headers=headers)
print(response.json())

task-file​

Get task file settings​

GET
/task-files/settings

Get task file settings from config/settings.yaml.

Uses ConfigLoader for unified loading with local override support.

Returns

Task file settings including default backend

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Responses​

Successful Response
application/json
JSON
{
"default_backend": "string",
"default_view_mode": "string",
"sort_order": "string"
}

Samples​

cURL
curl -X GET \
'http://localhost/task-files/settings' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/task-files/settings', {headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/task-files/settings';
$method = 'GET';
$headers = [
    'Content-Type' => 'application/json',
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>
Python
import requests

url = 'http://localhost/task-files/settings'

headers = {
    'Content-Type': 'application/json'
}

response = requests.get(url, headers=headers)
print(response.json())

List available task file backends​

GET
/task-files/backends

List all available backend directories in calibtasks.

Returns

List of backend names and paths

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Responses​

Successful Response
application/json
JSON
{
"backends": [
{
"name": "string",
"path": "string"
}
]
}

Samples​

cURL
curl -X GET \
'http://localhost/task-files/backends' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/task-files/backends', {headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/task-files/backends';
$method = 'GET';
$headers = [
    'Content-Type' => 'application/json',
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>
Python
import requests

url = 'http://localhost/task-files/backends'

headers = {
    'Content-Type': 'application/json'
}

response = requests.get(url, headers=headers)
print(response.json())

Get file tree for a specific backend​

GET
/task-files/tree

Get file tree structure for a specific backend directory.

Args:

backend: Backend name (e.g., "qubex", "fake")

Returns:

File tree structure for the backend

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Parameters​

Query Parameters

backend*
Typestring
Required

Responses​

Successful Response
application/json
JSON
[
{
"name": "string",
"path": "string",
"type": "string",
"children": "string"
}
]

Samples​

cURL
curl -X GET \
'http://localhost/task-files/tree' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/task-files/tree', {headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/task-files/tree';
$method = 'GET';
$headers = [
    'Content-Type' => 'application/json',
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>
Python
import requests

url = 'http://localhost/task-files/tree'

headers = {
    'Content-Type': 'application/json'
}

response = requests.get(url, headers=headers)
print(response.json())

Get task file content for viewing/editing​

GET
/task-files/content

Get task file content for viewing/editing.

Args:

path: Relative path from CALIBTASKS_BASE_PATH (e.g., "qubex/one_qubit_coarse/check_rabi.py")

Returns:

File content and metadata

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Parameters​

Query Parameters

path*
Typestring
Required

Responses​

Successful Response
application/json
JSON
{
"additionalProperties": "string"
}

Samples​

cURL
curl -X GET \
'http://localhost/task-files/content' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/task-files/content', {headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/task-files/content';
$method = 'GET';
$headers = [
    'Content-Type' => 'application/json',
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>
Python
import requests

url = 'http://localhost/task-files/content'

headers = {
    'Content-Type': 'application/json'
}

response = requests.get(url, headers=headers)
print(response.json())

Save task file content​

PUT
/task-files/content

Save task file content.

Args:

request: Save file request with path and content

Returns:

Success message

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Request Body​

JSON
{
"path": "string",
"content": "string"
}

Responses​

Successful Response
application/json
JSON
{
"additionalProperties": "string"
}

Samples​

cURL
curl -X PUT \
'http://localhost/task-files/content' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/task-files/content', {method:'PUT',headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/task-files/content';
$method = 'PUT';
$headers = [
    'Content-Type' => 'application/json',
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>
Python
import requests

url = 'http://localhost/task-files/content'

headers = {
    'Content-Type': 'application/json'
}

response = requests.put(url, headers=headers)
print(response.json())

List all tasks in a backend​

GET
/task-files/tasks

List all task definitions found in a backend directory.

Parses Python files to extract task names, types, and descriptions.
Results are cached and invalidated when files are modified.

Args:

backend: Backend name (e.g., "qubex", "fake")
sort_order: Sort order for tasks ("type_then_name", "name_only", "file_path")

Returns:

List of task information

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Parameters​

Query Parameters

backend*
Typestring
Required
sort_order

Responses​

Successful Response
application/json
JSON
{
"tasks": [
{
"name": "string",
"class_name": "string",
"task_type": "string",
"description": "string",
"file_path": "string"
}
]
}

Samples​

cURL
curl -X GET \
'http://localhost/task-files/tasks' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/task-files/tasks', {headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/task-files/tasks';
$method = 'GET';
$headers = [
    'Content-Type' => 'application/json',
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>
Python
import requests

url = 'http://localhost/task-files/tasks'

headers = {
    'Content-Type': 'application/json'
}

response = requests.get(url, headers=headers)
print(response.json())

task-result​

Get latest qubit task results​

GET
/task-results/qubits/latest

Get the latest qubit task results for all qubits on a chip.

Retrieves the most recent task result for each qubit on the specified chip.
Results include fidelity threshold status based on x90 gate fidelity.

Parameters

chip_id : str
ID of the chip to fetch results for
task : str
Name of the task to fetch results for
ctx : ProjectContext
Project context with user and project information

Returns

LatestTaskResultResponse
Task results for all qubits, keyed by qubit ID

Raises

ValueError
If the chip is not found for the current project

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Parameters​

Header Parameters

X-Project-Id

Query Parameters

chip_id*

Chip ID

Typestring
Required
task*

Task name

Typestring
Required

Responses​

Successful Response
application/json
JSON
{
"task_name": "string",
"result": {
"additionalProperties": {
}
}
}

Samples​

cURL
curl -X GET \
'http://localhost/task-results/qubits/latest' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/task-results/qubits/latest', {headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/task-results/qubits/latest';
$method = 'GET';
$headers = [
    'Content-Type' => 'application/json',
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>
Python
import requests

url = 'http://localhost/task-results/qubits/latest'

headers = {
    'Content-Type': 'application/json'
}

response = requests.get(url, headers=headers)
print(response.json())

Get historical qubit task results​

GET
/task-results/qubits/history

Get historical qubit task results for a specific date.

Retrieves task results from a specific historical date using chip history
snapshots. Results are filtered to tasks executed within the specified
day in JST timezone.

Parameters

chip_id : str
ID of the chip to fetch results for
task : str
Name of the task to fetch results for
date : str
Date in YYYYMMDD format (JST timezone)
ctx : ProjectContext
Project context with user and project information

Returns

LatestTaskResultResponse
Historical task results for all qubits, keyed by qubit ID

Raises

ValueError
If the chip history is not found for the specified date

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Parameters​

Header Parameters

X-Project-Id

Query Parameters

chip_id*

Chip ID

Typestring
Required
task*

Task name

Typestring
Required
date*

Date in YYYYMMDD format

Typestring
Required

Responses​

Successful Response
application/json
JSON
{
"task_name": "string",
"result": {
"additionalProperties": {
}
}
}

Samples​

cURL
curl -X GET \
'http://localhost/task-results/qubits/history' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/task-results/qubits/history', {headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/task-results/qubits/history';
$method = 'GET';
$headers = [
    'Content-Type' => 'application/json',
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>
Python
import requests

url = 'http://localhost/task-results/qubits/history'

headers = {
    'Content-Type': 'application/json'
}

response = requests.get(url, headers=headers)
print(response.json())

Get qubit task history​

GET
/task-results/qubits/{qid}/history

Get complete task history for a specific qubit.

Retrieves all historical task results for a specific qubit, sorted by
end time in descending order. Useful for tracking calibration trends
over time.

Parameters

qid : str
Qubit ID to fetch history for
chip_id : str
ID of the chip containing the qubit
task : str
Name of the task to fetch history for
ctx : ProjectContext
Project context with user and project information

Returns

TaskHistoryResponse
All historical task results, keyed by task_id

Raises

ValueError
If the chip is not found for the current project

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Parameters​

Header Parameters

X-Project-Id

Path Parameters

qid*
Typestring
Required

Query Parameters

chip_id*

Chip ID

Typestring
Required
task*

Task name

Typestring
Required

Responses​

Successful Response
application/json
JSON
{
"name": "string",
"data": {
"additionalProperties": {
}
}
}

Samples​

cURL
curl -X GET \
'http://localhost/task-results/qubits/{qid}/history' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/task-results/qubits/{qid}/history', {headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/task-results/qubits/{qid}/history';
$method = 'GET';
$headers = [
    'Content-Type' => 'application/json',
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>
Python
import requests

url = 'http://localhost/task-results/qubits/{qid}/history'

headers = {
    'Content-Type': 'application/json'
}

response = requests.get(url, headers=headers)
print(response.json())

Get latest coupling task results​

GET
/task-results/couplings/latest

Get the latest coupling task results for all couplings on a chip.

Retrieves the most recent task result for each coupling (qubit pair) on
the specified chip. Results include fidelity threshold status based on
Bell state fidelity.

Parameters

chip_id : str
ID of the chip to fetch results for
task : str
Name of the task to fetch results for
ctx : ProjectContext
Project context with user and project information

Returns

LatestTaskResultResponse
Task results for all couplings, keyed by coupling ID (e.g., "0-1")

Raises

ValueError
If the chip is not found for the current project

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Parameters​

Header Parameters

X-Project-Id

Query Parameters

chip_id*

Chip ID

Typestring
Required
task*

Task name

Typestring
Required

Responses​

Successful Response
application/json
JSON
{
"task_name": "string",
"result": {
"additionalProperties": {
}
}
}

Samples​

cURL
curl -X GET \
'http://localhost/task-results/couplings/latest' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/task-results/couplings/latest', {headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/task-results/couplings/latest';
$method = 'GET';
$headers = [
    'Content-Type' => 'application/json',
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>
Python
import requests

url = 'http://localhost/task-results/couplings/latest'

headers = {
    'Content-Type': 'application/json'
}

response = requests.get(url, headers=headers)
print(response.json())

Get historical coupling task results​

GET
/task-results/couplings/history

Get historical coupling task results for a specific date.

Retrieves task results from a specific historical date using chip history
snapshots. Results are filtered to tasks executed within the specified
day in JST timezone.

Parameters

chip_id : str
ID of the chip to fetch results for
task : str
Name of the task to fetch results for
date : str
Date in YYYYMMDD format (JST timezone)
ctx : ProjectContext
Project context with user and project information

Returns

LatestTaskResultResponse
Historical task results for all couplings, keyed by coupling ID

Raises

ValueError
If the chip history is not found for the specified date

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Parameters​

Header Parameters

X-Project-Id

Query Parameters

chip_id*

Chip ID

Typestring
Required
task*

Task name

Typestring
Required
date*

Date in YYYYMMDD format

Typestring
Required

Responses​

Successful Response
application/json
JSON
{
"task_name": "string",
"result": {
"additionalProperties": {
}
}
}

Samples​

cURL
curl -X GET \
'http://localhost/task-results/couplings/history' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/task-results/couplings/history', {headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/task-results/couplings/history';
$method = 'GET';
$headers = [
    'Content-Type' => 'application/json',
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>
Python
import requests

url = 'http://localhost/task-results/couplings/history'

headers = {
    'Content-Type': 'application/json'
}

response = requests.get(url, headers=headers)
print(response.json())

Get coupling task history​

GET
/task-results/couplings/{coupling_id}/history

Get complete task history for a specific coupling.

Retrieves all historical task results for a specific coupling (qubit pair),
sorted by end time in descending order. Useful for tracking two-qubit
calibration trends over time.

Parameters

coupling_id : str
Coupling ID to fetch history for (e.g., "0-1")
chip_id : str
ID of the chip containing the coupling
task : str
Name of the task to fetch history for
ctx : ProjectContext
Project context with user and project information

Returns

TaskHistoryResponse
All historical task results, keyed by task_id

Raises

ValueError
If the chip is not found for the current project

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Parameters​

Header Parameters

X-Project-Id

Path Parameters

coupling_id*
Typestring
Required

Query Parameters

chip_id*

Chip ID

Typestring
Required
task*

Task name

Typestring
Required

Responses​

Successful Response
application/json
JSON
{
"name": "string",
"data": {
"additionalProperties": {
}
}
}

Samples​

cURL
curl -X GET \
'http://localhost/task-results/couplings/{coupling_id}/history' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/task-results/couplings/{coupling_id}/history', {headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/task-results/couplings/{coupling_id}/history';
$method = 'GET';
$headers = [
    'Content-Type' => 'application/json',
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>
Python
import requests

url = 'http://localhost/task-results/couplings/{coupling_id}/history'

headers = {
    'Content-Type': 'application/json'
}

response = requests.get(url, headers=headers)
print(response.json())

Get timeseries task results by tag and parameter​

GET
/task-results/timeseries

Get timeseries task results filtered by tag and parameter.

Retrieves time series data for calibration parameters, optionally filtered
to a specific qubit. Useful for plotting parameter trends over time.

Parameters

chip_id : str
ID of the chip to fetch results for
tag : str
Tag to filter tasks by (e.g., calibration category)
parameter : str
Name of the output parameter to retrieve
start_at : str
Start time in ISO format for the time range
end_at : str
End time in ISO format for the time range
ctx : ProjectContext
Project context with user and project information
qid : str | None
Optional qubit ID to filter results to a specific qubit

Returns

TimeSeriesData
Time series data keyed by qubit ID, each containing a list of
parameter values with timestamps

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Parameters​

Header Parameters

X-Project-Id

Query Parameters

chip_id*

Chip ID

Typestring
Required
tag*

Tag to filter by

Typestring
Required
parameter*

Parameter name

Typestring
Required
start_at*

Start time in ISO format

Typestring
Required
end_at*

End time in ISO format

Typestring
Required
qid

Optional qubit ID to filter by

Responses​

Successful Response
application/json
JSON
{
"data": {
"additionalProperties": [
]
}
}

Samples​

cURL
curl -X GET \
'http://localhost/task-results/timeseries' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/task-results/timeseries', {headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/task-results/timeseries';
$method = 'GET';
$headers = [
    'Content-Type' => 'application/json',
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>
Python
import requests

url = 'http://localhost/task-results/timeseries'

headers = {
    'Content-Type': 'application/json'
}

response = requests.get(url, headers=headers)
print(response.json())

Download multiple figures as a ZIP file​

POST
/task-results/figures/download

Download multiple calibration figures as a ZIP file.

Creates a ZIP archive containing all requested figure files and returns it
as a streaming response.

Parameters

paths : list[str]
List of absolute file paths to the calibration figures
filename : str
Filename for the ZIP archive (default: "figures.zip")

Returns

StreamingResponse
ZIP archive containing all requested files

Raises

HTTPException
400 if no paths are provided or if any path does not exist

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Request Body​

JSON
{
"paths": [
"string"
],
"filename": "string"
}

Responses​

Successful Response
application/json
JSON
[
]

Samples​

cURL
curl -X POST \
'http://localhost/task-results/figures/download' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/task-results/figures/download', {method:'POST',headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/task-results/figures/download';
$method = 'POST';
$headers = [
    'Content-Type' => 'application/json',
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>
Python
import requests

url = 'http://localhost/task-results/figures/download'

headers = {
    'Content-Type': 'application/json'
}

response = requests.post(url, headers=headers)
print(response.json())

tag​

Operations​

GET/tags

List all tags​

GET
/tags

List all tags for the current project.

Retrieves all tags associated with the current project's calibration data.
Tags are used to categorize and filter task results.

Parameters

ctx : ProjectContext
Project context with user and project information
tag_repo : MongoTagRepository
Repository for tag operations

Returns

ListTagResponse
Wrapped list of tag names

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Parameters​

Header Parameters

X-Project-Id

Responses​

Successful Response
application/json
JSON
{
"tags": [
{
"name": "string"
}
]
}

Samples​

cURL
curl -X GET \
'http://localhost/tags' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/tags', {headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/tags';
$method = 'GET';
$headers = [
    'Content-Type' => 'application/json',
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>
Python
import requests

url = 'http://localhost/tags'

headers = {
    'Content-Type': 'application/json'
}

response = requests.get(url, headers=headers)
print(response.json())

device-topology​

Get the device topology​

POST
/device-topology

Get the device topology.

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Parameters​

Header Parameters

X-Project-Id

Request Body​

JSON
{
"name": "string",
"device_id": "string",
"qubits": [
"string"
],
"exclude_couplings": [
"string"
],
"condition": {
"coupling_fidelity": {
"min": 0,
"max": 0,
"is_within_24h": true
},
"qubit_fidelity": {
"min": 0,
"max": 0,
"is_within_24h": true
},
"readout_fidelity": {
"min": 0,
"max": 0,
"is_within_24h": true
},
"only_maximum_connected": true
}
}

Responses​

Successful Response
application/json
JSON
{
"name": "string",
"device_id": "string",
"qubits": [
{
"id": 0,
"physical_id": 0,
"position": {
"x": 0,
"y": 0
},
"fidelity": 0,
"meas_error": {
"prob_meas1_prep0": 0,
"prob_meas0_prep1": 0,
"readout_assignment_error": 0
},
"qubit_lifetime": {
"t1": 0,
"t2": 0
},
"gate_duration": {
"rz": 0,
"sx": 0,
"x": 0
}
}
],
"couplings": [
{
"control": 0,
"target": 0,
"fidelity": 0,
"gate_duration": {
"rzx90": 0
}
}
],
"calibrated_at": "string"
}

Samples​

cURL
curl -X POST \
'http://localhost/device-topology' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/device-topology', {method:'POST',headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/device-topology';
$method = 'POST';
$headers = [
    'Content-Type' => 'application/json',
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>
Python
import requests

url = 'http://localhost/device-topology'

headers = {
    'Content-Type': 'application/json'
}

response = requests.post(url, headers=headers)
print(response.json())

Get the device topology plot​

POST
/device-topology/plot

Get the device topology as a PNG image.

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Parameters​

Header Parameters

X-Project-Id

Request Body​

JSON
{
"name": "string",
"device_id": "string",
"qubits": [
{
"id": 0,
"physical_id": 0,
"position": {
"x": 0,
"y": 0
},
"fidelity": 0,
"meas_error": {
"prob_meas1_prep0": 0,
"prob_meas0_prep1": 0,
"readout_assignment_error": 0
},
"qubit_lifetime": {
"t1": 0,
"t2": 0
},
"gate_duration": {
"rz": 0,
"sx": 0,
"x": 0
}
}
],
"couplings": [
{
"control": 0,
"target": 0,
"fidelity": 0,
"gate_duration": {
"rzx90": 0
}
}
],
"calibrated_at": "string"
}

Responses​

Successful Response

Samples​

cURL
curl -X POST \
'http://localhost/device-topology/plot' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/device-topology/plot', {method:'POST',headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/device-topology/plot';
$method = 'POST';
$headers = [
    'Content-Type' => 'application/json',
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>
Python
import requests

url = 'http://localhost/device-topology/plot'

headers = {
    'Content-Type': 'application/json'
}

response = requests.post(url, headers=headers)
print(response.json())

backend​

Operations​

GET/backends

List all backends​

GET
/backends

Retrieve a list of all registered backends

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Parameters​

Header Parameters

X-Project-Id

Responses​

Successful Response
application/json
JSON
{
"backends": [
{
"name": "string",
"username": "string"
}
]
}

Samples​

cURL
curl -X GET \
'http://localhost/backends' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/backends', {headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/backends';
$method = 'GET';
$headers = [
    'Content-Type' => 'application/json',
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>
Python
import requests

url = 'http://localhost/backends'

headers = {
    'Content-Type': 'application/json'
}

response = requests.get(url, headers=headers)
print(response.json())

flow​

List all flows​

GET
/flows

List all Flows for the current project.

Returns metadata only (no code content for performance).

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Parameters​

Header Parameters

X-Project-Id

Responses​

Successful Response
application/json
JSON
{
"flows": [
{
"name": "string",
"description": "string",
"chip_id": "string",
"flow_function_name": "string",
"created_at": "string",
"updated_at": "string",
"tags": [
"string"
]
}
]
}

Samples​

cURL
curl -X GET \
'http://localhost/flows' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/flows', {headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/flows';
$method = 'GET';
$headers = [
    'Content-Type' => 'application/json',
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>
Python
import requests

url = 'http://localhost/flows'

headers = {
    'Content-Type': 'application/json'
}

response = requests.get(url, headers=headers)
print(response.json())

Save a flow​

POST
/flows

Save a Flow to file system and MongoDB.

Steps:

  1. Validate flow name
  2. Validate flow code contains expected function
  3. Create user directory if not exists
  4. Write code to file: user_flows/{username}/{name}.py
  5. Upsert metadata to MongoDB
  6. Return file path and success message

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Parameters​

Header Parameters

X-Project-Id

Request Body​

JSON
{
"name": "string",
"description": "string",
"code": "string",
"flow_function_name": "string",
"chip_id": "string",
"default_parameters": {
"additionalProperties": "string"
},
"tags": [
"string"
]
}

Responses​

Successful Response
application/json
JSON
{
"name": "string",
"file_path": "string",
"message": "string"
}

Samples​

cURL
curl -X POST \
'http://localhost/flows' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/flows', {method:'POST',headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/flows';
$method = 'POST';
$headers = [
    'Content-Type' => 'application/json',
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>
Python
import requests

url = 'http://localhost/flows'

headers = {
    'Content-Type': 'application/json'
}

response = requests.post(url, headers=headers)
print(response.json())

List all flow templates​

GET
/flows/templates

List all available flow templates.

Returns metadata only (no code content for performance).

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Responses​

Successful Response
application/json
JSON
[
{
"id": "string",
"name": "string",
"description": "string",
"category": "string",
"filename": "string",
"function_name": "string"
}
]

Samples​

cURL
curl -X GET \
'http://localhost/flows/templates' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/flows/templates', {headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/flows/templates';
$method = 'GET';
$headers = [
    'Content-Type' => 'application/json',
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>
Python
import requests

url = 'http://localhost/flows/templates'

headers = {
    'Content-Type': 'application/json'
}

response = requests.get(url, headers=headers)
print(response.json())

Get a flow template​

GET
/flows/templates/{template_id}

Get flow template details including code content.

Steps:

  1. Find template metadata
  2. Read Python file content
  3. Return combined data

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Parameters​

Path Parameters

template_id*
Typestring
Required

Responses​

Successful Response
application/json
JSON
{
"id": "string",
"name": "string",
"description": "string",
"category": "string",
"filename": "string",
"function_name": "string",
"code": "string"
}

Samples​

cURL
curl -X GET \
'http://localhost/flows/templates/{template_id}' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/flows/templates/{template_id}', {headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/flows/templates/{template_id}';
$method = 'GET';
$headers = [
    'Content-Type' => 'application/json',
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>
Python
import requests

url = 'http://localhost/flows/templates/{template_id}'

headers = {
    'Content-Type': 'application/json'
}

response = requests.get(url, headers=headers)
print(response.json())

List flow helper files​

GET
/flows/helpers

List all Python files in the qdash.workflow.service module.

Returns list of filenames that users can view for reference.

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Responses​

Successful Response
application/json
JSON
[
"string"
]

Samples​

cURL
curl -X GET \
'http://localhost/flows/helpers' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/flows/helpers', {headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/flows/helpers';
$method = 'GET';
$headers = [
    'Content-Type' => 'application/json',
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>
Python
import requests

url = 'http://localhost/flows/helpers'

headers = {
    'Content-Type': 'application/json'
}

response = requests.get(url, headers=headers)
print(response.json())

Get flow helper file content​

GET
/flows/helpers/{filename}

Get the content of a flow helper file.

Args:
filename: Name of the Python file (e.g., "session.py")

Returns:
File content as string

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Parameters​

Path Parameters

filename*
Typestring
Required

Responses​

Successful Response
application/json
JSON
"string"

Samples​

cURL
curl -X GET \
'http://localhost/flows/helpers/{filename}' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/flows/helpers/{filename}', {headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/flows/helpers/{filename}';
$method = 'GET';
$headers = [
    'Content-Type' => 'application/json',
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>
Python
import requests

url = 'http://localhost/flows/helpers/{filename}'

headers = {
    'Content-Type': 'application/json'
}

response = requests.get(url, headers=headers)
print(response.json())

List all flow schedules for current user​

GET
/flows/schedules

List all Flow schedules (cron and one-time) for the current project.

Args:

ctx: Project context with user and project information
limit: Maximum number of schedules to return (max 100)
offset: Number of schedules to skip

Returns:

List of all flow schedules

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Parameters​

Header Parameters

X-Project-Id

Query Parameters

limit
Typeinteger
offset
Typeinteger

Responses​

Successful Response
application/json
JSON
{
"schedules": [
{
"schedule_id": "string",
"flow_name": "string",
"schedule_type": "string",
"cron": "string",
"next_run": "string",
"active": true,
"created_at": "string"
}
]
}

Samples​

cURL
curl -X GET \
'http://localhost/flows/schedules' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/flows/schedules', {headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/flows/schedules';
$method = 'GET';
$headers = [
    'Content-Type' => 'application/json',
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>
Python
import requests

url = 'http://localhost/flows/schedules'

headers = {
    'Content-Type': 'application/json'
}

response = requests.get(url, headers=headers)
print(response.json())

Delete a flow schedule​

DELETE
/flows/schedules/{schedule_id}

Delete a Flow schedule (cron or one-time).

Schedule ID Types:

  • Cron schedules: schedule_id is the deployment_id (UUID format)
  • One-time schedules: schedule_id is the flow_run_id (UUID format)

The API automatically determines the type and handles accordingly:

  • Cron: Removes the schedule from the deployment (schedule=None)
  • One-time: Deletes the scheduled flow run

Args:

schedule_id: Schedule ID (deployment_id for cron, flow_run_id for one-time)
ctx: Project context with user and project information

Returns:

Standardized response with schedule type information

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Parameters​

Header Parameters

X-Project-Id

Path Parameters

schedule_id*
Typestring
Required

Responses​

Successful Response
application/json
JSON
{
"message": "string",
"schedule_id": "string",
"schedule_type": "string"
}

Samples​

cURL
curl -X DELETE \
'http://localhost/flows/schedules/{schedule_id}' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/flows/schedules/{schedule_id}', {method:'DELETE',headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/flows/schedules/{schedule_id}';
$method = 'DELETE';
$headers = [
    'Content-Type' => 'application/json',
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>
Python
import requests

url = 'http://localhost/flows/schedules/{schedule_id}'

headers = {
    'Content-Type': 'application/json'
}

response = requests.delete(url, headers=headers)
print(response.json())

Update a flow schedule​

PATCH
/flows/schedules/{schedule_id}

Update a Flow schedule (cron schedules only).

Can update: active status, cron expression, parameters.

Args:

schedule_id: Schedule ID (deployment_id)
request: Update request
ctx: Project context with user and project information

Returns:

Success message

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Parameters​

Header Parameters

X-Project-Id

Path Parameters

schedule_id*
Typestring
Required

Request Body​

JSON
{
"active": true,
"cron": "string",
"parameters": "string",
"timezone": "string"
}

Responses​

Successful Response
application/json
JSON
{
"message": "string",
"schedule_id": "string"
}

Samples​

cURL
curl -X PATCH \
'http://localhost/flows/schedules/{schedule_id}' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/flows/schedules/{schedule_id}', {method:'PATCH',headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/flows/schedules/{schedule_id}';
$method = 'PATCH';
$headers = [
    'Content-Type' => 'application/json',
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>
Python
import requests

url = 'http://localhost/flows/schedules/{schedule_id}'

headers = {
    'Content-Type': 'application/json'
}

response = requests.patch(url, headers=headers)
print(response.json())

Get flow details​

GET
/flows/{name}

Get Flow details including code content.

Steps:

  1. Find metadata in MongoDB
  2. Read code from file
  3. Return combined data

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Parameters​

Header Parameters

X-Project-Id

Path Parameters

name*
Typestring
Required

Responses​

Successful Response
application/json
JSON
{
"name": "string",
"description": "string",
"code": "string",
"flow_function_name": "string",
"chip_id": "string",
"default_parameters": {
"additionalProperties": "string"
},
"file_path": "string",
"created_at": "string",
"updated_at": "string",
"tags": [
"string"
]
}

Samples​

cURL
curl -X GET \
'http://localhost/flows/{name}' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/flows/{name}', {headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/flows/{name}';
$method = 'GET';
$headers = [
    'Content-Type' => 'application/json',
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>
Python
import requests

url = 'http://localhost/flows/{name}'

headers = {
    'Content-Type': 'application/json'
}

response = requests.get(url, headers=headers)
print(response.json())

Delete a flow​

DELETE
/flows/{name}

Delete a Flow.

Steps:

  1. Delete Prefect deployment
  2. Delete file from user_flows/{username}/{name}.py
  3. Delete metadata from MongoDB

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Parameters​

Header Parameters

X-Project-Id

Path Parameters

name*
Typestring
Required

Responses​

Successful Response
application/json
JSON
{
"additionalProperties": "string"
}

Samples​

cURL
curl -X DELETE \
'http://localhost/flows/{name}' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/flows/{name}', {method:'DELETE',headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/flows/{name}';
$method = 'DELETE';
$headers = [
    'Content-Type' => 'application/json',
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>
Python
import requests

url = 'http://localhost/flows/{name}'

headers = {
    'Content-Type': 'application/json'
}

response = requests.delete(url, headers=headers)
print(response.json())

Execute a flow​

POST
/flows/{name}/execute

Execute a Flow via Prefect deployment.

Steps:

  1. Find flow metadata in MongoDB
  2. Merge request parameters with default_parameters
  3. Create flow run via Prefect Client
  4. Return execution_id and URLs

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Parameters​

Header Parameters

X-Project-Id

Path Parameters

name*
Typestring
Required

Request Body​

JSON
{
"parameters": {
"additionalProperties": "string"
}
}

Responses​

Successful Response
application/json
JSON
{
"execution_id": "string",
"flow_run_url": "string",
"qdash_ui_url": "string",
"message": "string"
}

Samples​

cURL
curl -X POST \
'http://localhost/flows/{name}/execute' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/flows/{name}/execute', {method:'POST',headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/flows/{name}/execute';
$method = 'POST';
$headers = [
    'Content-Type' => 'application/json',
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>
Python
import requests

url = 'http://localhost/flows/{name}/execute'

headers = {
    'Content-Type': 'application/json'
}

response = requests.post(url, headers=headers)
print(response.json())

Schedule a flow execution (cron or one-time)​

POST
/flows/{name}/schedule

Schedule a Flow execution with cron or one-time schedule.

Args:

name: Flow name
request: Schedule request (must provide either cron or scheduled_time)
ctx: Project context with user and project information

Returns:

Schedule response with schedule_id and details

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Parameters​

Header Parameters

X-Project-Id

Path Parameters

name*
Typestring
Required

Request Body​

JSON
{
"cron": "string",
"scheduled_time": "string",
"parameters": {
"additionalProperties": "string"
},
"active": true,
"timezone": "string"
}

Responses​

Successful Response
application/json
JSON
{
"schedule_id": "string",
"flow_name": "string",
"schedule_type": "string",
"cron": "string",
"next_run": "string",
"active": true,
"message": "string"
}

Samples​

cURL
curl -X POST \
'http://localhost/flows/{name}/schedule' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/flows/{name}/schedule', {method:'POST',headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/flows/{name}/schedule';
$method = 'POST';
$headers = [
    'Content-Type' => 'application/json',
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>
Python
import requests

url = 'http://localhost/flows/{name}/schedule'

headers = {
    'Content-Type': 'application/json'
}

response = requests.post(url, headers=headers)
print(response.json())

List schedules for a specific flow​

GET
/flows/{name}/schedules

List all schedules (cron and one-time) for a specific Flow.

Args:

name: Flow name
ctx: Project context with user and project information
limit: Maximum number of schedules to return (max 100)
offset: Number of schedules to skip

Returns:

List of schedules for the flow

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Parameters​

Header Parameters

X-Project-Id

Path Parameters

name*
Typestring
Required

Query Parameters

limit
Typeinteger
offset
Typeinteger

Responses​

Successful Response
application/json
JSON
{
"schedules": [
{
"schedule_id": "string",
"flow_name": "string",
"schedule_type": "string",
"cron": "string",
"next_run": "string",
"active": true,
"created_at": "string"
}
]
}

Samples​

cURL
curl -X GET \
'http://localhost/flows/{name}/schedules' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/flows/{name}/schedules', {headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/flows/{name}/schedules';
$method = 'GET';
$headers = [
    'Content-Type' => 'application/json',
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>
Python
import requests

url = 'http://localhost/flows/{name}/schedules'

headers = {
    'Content-Type': 'application/json'
}

response = requests.get(url, headers=headers)
print(response.json())

metrics​

Get metrics configuration​

GET
/metrics/config

Get metrics metadata configuration for visualization.

Retrieves the metrics configuration loaded from YAML, including display
metadata for all qubit and coupling metrics used in the dashboard.

Returns

dict[str, Any]
Dictionary with metrics configuration including:
- qubit_metrics: Metadata for single-qubit metrics (frequency, T1, T2, fidelities)
- coupling_metrics: Metadata for two-qubit coupling metrics (ZX90, Bell state)
- color_scale: Color scale configuration for heatmap visualization

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Responses​

Successful Response
application/json
JSON
{
"additionalProperties": "string"
}

Samples​

cURL
curl -X GET \
'http://localhost/metrics/config' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/metrics/config', {headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/metrics/config';
$method = 'GET';
$headers = [
    'Content-Type' => 'application/json',
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>
Python
import requests

url = 'http://localhost/metrics/config'

headers = {
    'Content-Type': 'application/json'
}

response = requests.get(url, headers=headers)
print(response.json())

Get Chip Metrics​

GET
/metrics/chips/{chip_id}/metrics

Get chip calibration metrics for visualization.

This endpoint returns calibration metrics for a specific chip from the database, including:

  • Qubit frequency, anharmonicity, T1, T2 echo times
  • Gate fidelities (single-qubit and two-qubit)
  • Readout fidelities

Args:

chip_id: The chip identifier
ctx: Project context with user and project information
within_hours: Optional filter to only include data from last N hours (e.g., 24)
selection_mode: "latest" to get most recent values, "best" to get optimal values

Returns:

ChipMetricsResponse with all metrics data

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Parameters​

Header Parameters

X-Project-Id

Path Parameters

chip_id*
Typestring
Required

Query Parameters

within_hours

Filter to data within N hours (e.g., 24)

selection_mode

Selection mode: 'latest' for most recent, 'best' for optimal values

Typestring
Enumlatest, best

Responses​

Successful Response
application/json
JSON
{
"chip_id": "string",
"username": "string",
"qubit_count": 0,
"within_hours": "string",
"qubit_metrics": {
"qubit_frequency": "string",
"anharmonicity": "string",
"t1": "string",
"t2_echo": "string",
"t2_star": "string",
"average_readout_fidelity": "string",
"x90_gate_fidelity": "string",
"x180_gate_fidelity": "string"
},
"coupling_metrics": {
"zx90_gate_fidelity": "string",
"bell_state_fidelity": "string",
"static_zz_interaction": "string"
}
}

Samples​

cURL
curl -X GET \
'http://localhost/metrics/chips/{chip_id}/metrics' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/metrics/chips/{chip_id}/metrics', {headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/metrics/chips/{chip_id}/metrics';
$method = 'GET';
$headers = [
    'Content-Type' => 'application/json',
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>
Python
import requests

url = 'http://localhost/metrics/chips/{chip_id}/metrics'

headers = {
    'Content-Type': 'application/json'
}

response = requests.get(url, headers=headers)
print(response.json())

Get Qubit Metric History​

GET
/metrics/chips/{chip_id}/qubits/{qid}/history

Get historical metric data for a specific qubit with task_id for figure display.

This endpoint queries TaskResultHistoryDocument to retrieve calibration
history for a specific metric, including multiple executions on the same day.
Each history item includes task_id for displaying calibration figures.

Args:

chip_id: The chip identifier
qid: The qubit identifier (e.g., "0", "Q00")
ctx: Project context with user and project information
metric: Metric name to retrieve history for
limit: Maximum number of history items (None for unlimited within time range)
within_days: Optional filter to only include data from last N days

Returns:

QubitMetricHistoryResponse with historical metric data and task_ids

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Parameters​

Header Parameters

X-Project-Id

Path Parameters

chip_id*
Typestring
Required
qid*
Typestring
Required

Query Parameters

metric*

Metric name (e.g., t1, qubit_frequency)

Typestring
Required
limit

Max number of history items (None for unlimited)

within_days

Filter to last N days

Responses​

Successful Response
application/json
JSON
{
"chip_id": "string",
"qid": "string",
"metric_name": "string",
"username": "string",
"history": [
{
"value": "string",
"execution_id": "string",
"task_id": "string",
"timestamp": "string",
"calibrated_at": "string"
}
]
}

Samples​

cURL
curl -X GET \
'http://localhost/metrics/chips/{chip_id}/qubits/{qid}/history' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/metrics/chips/{chip_id}/qubits/{qid}/history', {headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/metrics/chips/{chip_id}/qubits/{qid}/history';
$method = 'GET';
$headers = [
    'Content-Type' => 'application/json',
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>
Python
import requests

url = 'http://localhost/metrics/chips/{chip_id}/qubits/{qid}/history'

headers = {
    'Content-Type': 'application/json'
}

response = requests.get(url, headers=headers)
print(response.json())

Get Coupling Metric History​

GET
/metrics/chips/{chip_id}/couplings/{coupling_id}/history

Get historical metric data for a specific coupling with task_id for figure display.

This endpoint queries TaskResultHistoryDocument to retrieve calibration
history for a specific coupling metric, including multiple executions on the same day.
Each history item includes task_id for displaying calibration figures.

Args:

chip_id: The chip identifier
coupling_id: The coupling identifier (e.g., "0-1", "2-3")
ctx: Project context with user and project information
metric: Metric name to retrieve history for
limit: Maximum number of history items (None for unlimited within time range)
within_days: Optional filter to only include data from last N days

Returns:

QubitMetricHistoryResponse with historical metric data and task_ids
(Note: qid field contains coupling_id for coupling metrics)

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Parameters​

Header Parameters

X-Project-Id

Path Parameters

chip_id*
Typestring
Required
coupling_id*
Typestring
Required

Query Parameters

metric*

Metric name (e.g., zx90_gate_fidelity, bell_state_fidelity)

Typestring
Required
limit

Max number of history items (None for unlimited)

within_days

Filter to last N days

Responses​

Successful Response
application/json
JSON
{
"chip_id": "string",
"qid": "string",
"metric_name": "string",
"username": "string",
"history": [
{
"value": "string",
"execution_id": "string",
"task_id": "string",
"timestamp": "string",
"calibrated_at": "string"
}
]
}

Samples​

cURL
curl -X GET \
'http://localhost/metrics/chips/{chip_id}/couplings/{coupling_id}/history' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/metrics/chips/{chip_id}/couplings/{coupling_id}/history', {headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/metrics/chips/{chip_id}/couplings/{coupling_id}/history';
$method = 'GET';
$headers = [
    'Content-Type' => 'application/json',
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>
Python
import requests

url = 'http://localhost/metrics/chips/{chip_id}/couplings/{coupling_id}/history'

headers = {
    'Content-Type': 'application/json'
}

response = requests.get(url, headers=headers)
print(response.json())

Download metrics as PDF report​

POST
/metrics/chips/{chip_id}/metrics/pdf

Download chip metrics as a PDF report.

Generates a comprehensive PDF report containing:

  • Cover page with chip information and report metadata
  • Heatmap visualizations for each metric
  • Statistics for each metric (coverage, average, min, max, std dev)

The report includes all qubit metrics (8 types) and coupling metrics (3 types)
that have data available.

Args:
chip_id: Chip identifier
within_hours: Optional time filter in hours
selection_mode: "latest" for most recent values, "best" for optimal values

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Parameters​

Header Parameters

X-Project-Id

Path Parameters

chip_id*
Typestring
Required

Query Parameters

within_hours

Filter to data within N hours

selection_mode

Selection mode: 'latest' or 'best'

Typestring
Enumlatest, best

Responses​

PDF report file
JSON
[
]

Samples​

cURL
curl -X POST \
'http://localhost/metrics/chips/{chip_id}/metrics/pdf' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/metrics/chips/{chip_id}/metrics/pdf', {method:'POST',headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/metrics/chips/{chip_id}/metrics/pdf';
$method = 'POST';
$headers = [
    'Content-Type' => 'application/json',
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>
Python
import requests

url = 'http://localhost/metrics/chips/{chip_id}/metrics/pdf'

headers = {
    'Content-Type': 'application/json'
}

response = requests.post(url, headers=headers)
print(response.json())

topology​

List available topologies​

GET
/topology/list

List all available topology definitions.

Args:

size: Optional filter by number of qubits

Returns:

dict: List of topology summaries with id, name, and num_qubits

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Parameters​

Query Parameters

size

Responses​

Successful Response
application/json
JSON
{
"additionalProperties": "string"
}

Samples​

cURL
curl -X GET \
'http://localhost/topology/list' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/topology/list', {headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/topology/list';
$method = 'GET';
$headers = [
    'Content-Type' => 'application/json',
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>
Python
import requests

url = 'http://localhost/topology/list'

headers = {
    'Content-Type': 'application/json'
}

response = requests.get(url, headers=headers)
print(response.json())

Get topology by ID​

GET
/topology/{topology_id}

Get a specific topology definition.

Args:

topology_id: Topology identifier (e.g., "square-lattice-mux-64")

Returns:

dict: Complete topology definition with qubits and couplings

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Parameters​

Path Parameters

topology_id*
Typestring
Required

Responses​

Successful Response
application/json
JSON
{
"additionalProperties": "string"
}

Samples​

cURL
curl -X GET \
'http://localhost/topology/{topology_id}' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/topology/{topology_id}', {headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/topology/{topology_id}';
$method = 'GET';
$headers = [
    'Content-Type' => 'application/json',
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>
Python
import requests

url = 'http://localhost/topology/{topology_id}'

headers = {
    'Content-Type': 'application/json'
}

response = requests.get(url, headers=headers)
print(response.json())

config​

Get all configuration​

GET
/config/all

Fetch all application configuration in a single request

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Responses​

Successful Response
application/json
JSON
{
"ui": {
"task_files": {
"default_backend": "string",
"default_view_mode": "string",
"sort_order": "string"
}
},
"metrics": {
"additionalProperties": "string"
},
"copilot": {
"additionalProperties": "string"
}
}

Samples​

cURL
curl -X GET \
'http://localhost/config/all' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/config/all', {headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/config/all';
$method = 'GET';
$headers = [
    'Content-Type' => 'application/json',
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>
Python
import requests

url = 'http://localhost/config/all'

headers = {
    'Content-Type': 'application/json'
}

response = requests.get(url, headers=headers)
print(response.json())
Powered by VitePress OpenAPI

Released under the Apache 2.0 License.

Copyright © 2024-present OQTOPUS Team