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.

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

Parameters

user_data : UserCreate
User registration data including username, password, and optional full_name
current_user : User
Current authenticated admin user
auth_service : AuthService
The auth service instance

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.

Parameters

current_user : User
Current authenticated user injected via dependency

Returns

User
Current user's profile information

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.

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.

Parameters

password_data : PasswordChange
Contains current_password and new_password
current_user : User
Current authenticated user injected via dependency
auth_service : AuthService
The auth service instance

Returns

dict[str, str]
Success message confirming password change

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

Parameters

password_data : PasswordReset
Contains username and new_password
current_user : User
Current authenticated admin user
auth_service : AuthService
The auth service instance

Returns

dict[str, str]
Success message confirming password reset

Raises

HTTPException
403 if the current user is not an admin

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​

Reload configuration caches​

POST
/admin/config/reload

Reload cached YAML configuration (admin only).

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Responses​

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

Samples​

cURL
curl -X POST \
'http://localhost/admin/config/reload' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/admin/config/reload', {method:'POST',headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/admin/config/reload';
$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/config/reload'

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

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

List all users​

GET
/admin/users

List all users in the system (admin only).

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

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

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

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

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

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

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

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

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

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.

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",
"flow_name": "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",
"run_parameters": "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"
},
"tags": [
"string"
],
"chip_id": "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())

Cancel a running or scheduled execution​

POST
/executions/{flow_run_id}/cancel

Cancel a running or scheduled execution via Prefect.

Sends a cancellation request to Prefect for the specified flow run.
The flow_run_id is the Prefect flow run UUID, which can be obtained from
the execution detail's note.flow_run_id field.
Only executions in SCHEDULED, PENDING, RUNNING, or PAUSED state can be cancelled.

Parameters

flow_run_id : str
Prefect flow run UUID
ctx : ProjectContext
Project context with user and project information
execution_service : ExecutionService
Service for execution operations

Returns

CancelExecutionResponse
Cancellation result with status

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Parameters​

Header Parameters

X-Project-Id

Path Parameters

flow_run_id*
Typestring
Required

Responses​

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

Samples​

cURL
curl -X POST \
'http://localhost/executions/{flow_run_id}/cancel' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/executions/{flow_run_id}/cancel', {method:'POST',headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/executions/{flow_run_id}/cancel';
$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/executions/{flow_run_id}/cancel'

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

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

Re-execute a flow from snapshot parameters​

POST
/executions/{execution_id}/re-execute

Re-execute a flow using snapshot parameters from a previous execution.

Parameters

execution_id : str
ID of the source execution to snapshot parameters from
request : ReExecuteRequest
Re-execution request with flow_name and optional parameter_overrides
ctx : ProjectContext
Project context with user and project information
execution_service : ExecutionService
Service for execution operations
flow_service : FlowService
Service for flow operations

Returns

ExecuteFlowResponse
Execution result with IDs and URLs

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Parameters​

Header Parameters

X-Project-Id

Path Parameters

execution_id*
Typestring
Required

Request Body​

JSON
{
"flow_name": "string",
"parameter_overrides": {
"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/executions/{execution_id}/re-execute' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/executions/{execution_id}/re-execute', {method:'POST',headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/executions/{execution_id}/re-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/executions/{execution_id}/re-execute'

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

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

file​

Download file​

GET
/files/raw-data

Download a raw data file from the server.

Parameters

path : str
Absolute file path to the file to download

Returns

FileResponse
The file as a downloadable response

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.

Parameters

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

Returns

FileResponse
ZIP archive as a downloadable response

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.

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

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

Import seed parameters from qubex or manual input​

POST
/calibrations/seed-import

Import initial calibration parameters from qubex params or manual input.

This endpoint allows importing seed parameters that are typically loaded
from qubex's params directory (e.g., qubit_frequency, readout_amplitude)
into QDash's calibration database for tracking and provenance.

Parameters

ctx : ProjectContext
Project context with user and project information
service : SeedImportService
Service for seed import operations
request : SeedImportRequest
Import request specifying source, chip_id, and parameters

Returns

SeedImportResponse
Results of the import operation including counts and individual results

Examples

Import from qubex params:

{
    "chip_id": "64Qv3",
    "source": "qubex_params",
    "parameters": ["qubit_frequency", "readout_amplitude"]
}

Manual import:

{
    "chip_id": "64Qv3",
    "source": "manual",
    "manual_data": {
        "qubit_frequency": {"Q00": 7.9, "Q01": 8.6}
    }
}

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Parameters​

Header Parameters

X-Project-Id

Request Body​

JSON
{
"chip_id": "string",
"source": "string",
"parameters": [
"qubit_frequency",
"readout_amplitude",
"control_amplitude"
],
"qids": [
"Q00",
"Q01",
"Q02"
],
"manual_data": "string"
}

Responses​

Successful Response
application/json
JSON
{
"chip_id": "string",
"source": "string",
"imported_count": 0,
"skipped_count": 0,
"error_count": 0,
"results": [
{
"parameter_name": "string",
"qid": "string",
"value": "string",
"unit": "string",
"status": "string",
"message": "string"
}
],
"provenance_activity_id": "string"
}

Samples​

cURL
curl -X POST \
'http://localhost/calibrations/seed-import' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/calibrations/seed-import', {method:'POST',headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/calibrations/seed-import';
$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/calibrations/seed-import'

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

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

Get available seed parameters for a chip​

GET
/calibrations/seed-parameters/{chip_id}

Get list of available parameter files in qubex params directory.

Parameters

ctx : ProjectContext
Project context with user and project information
service : SeedImportService
Service for seed import operations
chip_id : str
Chip ID to check parameters for

Returns

list[str]
List of available parameter names (e.g., ["qubit_frequency", "readout_amplitude"])

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Parameters​

Header Parameters

X-Project-Id

Path Parameters

chip_id*
Typestring
Required

Responses​

Successful Response
application/json
JSON
[
"string"
]

Samples​

cURL
curl -X GET \
'http://localhost/calibrations/seed-parameters/{chip_id}' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/calibrations/seed-parameters/{chip_id}', {headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/calibrations/seed-parameters/{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/calibrations/seed-parameters/{chip_id}'

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

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

Compare YAML seed values with QDash values​

GET
/calibrations/seed-compare/{chip_id}

Compare seed parameter values from YAML files with current QDash values.

This endpoint allows users to preview what will be imported and see
the difference between YAML source values and current QDash values.

Parameters

ctx : ProjectContext
Project context with user and project information
service : SeedImportService
Service for seed import operations
chip_id : str
Chip ID to compare parameters for
parameters : str | None
Comma-separated list of parameters to compare (None = all available)

Returns

dict
Comparison data with structure:
{
"chip_id": str,
"parameters": {
"param_name": {
"unit": str,
"qubits": {
"Q0": {
"yaml_value": float | None,
"qdash_value": float | None,
"status": "new" | "same" | "different"
}
}
}
}
}

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Parameters​

Header Parameters

X-Project-Id

Path Parameters

chip_id*
Typestring
Required

Query Parameters

parameters

Responses​

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

Samples​

cURL
curl -X GET \
'http://localhost/calibrations/seed-compare/{chip_id}' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/calibrations/seed-compare/{chip_id}', {headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/calibrations/seed-compare/{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/calibrations/seed-compare/{chip_id}'

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

Analyze calibration result with AI​

POST
/copilot/analyze

Analyze a calibration task result using LLM.

Constructs a rich context from task knowledge, qubit parameters,
and experimental data, then sends it to the configured LLM for analysis.

Parameters

request : AnalyzeRequest
The analysis request containing task info, IDs, and user message.

Returns

AnalysisResponse
Structured analysis from the LLM.

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Request Body​

JSON
{
"task_name": "string",
"chip_id": "string",
"qid": "string",
"execution_id": "string",
"task_id": "string",
"message": "string",
"image_base64": "string",
"conversation_history": [
{
"additionalProperties": "string"
}
]
}

Responses​

Successful Response
application/json
JSON
{
"summary": "string",
"assessment": "string",
"explanation": "string",
"potential_issues": [
"string"
],
"recommendations": [
"string"
]
}

Samples​

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

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

response = requests.post(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",
"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.
service : TaskService
The task service instance.
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.
service : TaskService
The task service instance.

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",
"flow_name": "string",
"figure_path": [
"string"
],
"json_figure_path": [
"string"
],
"input_parameters": {
"additionalProperties": "string"
},
"output_parameters": {
"additionalProperties": "string"
},
"run_parameters": {
"additionalProperties": "string"
},
"tags": [
"string"
],
"source_task_id": "string",
"re_executions": [
{
"task_id": "string",
"task_name": "string",
"qid": "string",
"status": "string",
"start_at": "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())

List all task knowledge entries​

GET
/task-knowledge

List all available task knowledge entries with summary info.

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Responses​

Successful Response
application/json
JSON
{
"items": [
{
"name": "string",
"category": "string",
"summary": "string",
"failure_mode_count": 0,
"case_count": 0,
"image_count": 0,
"has_analysis_guide": true
}
],
"categories": {
"additionalProperties": "string"
}
}

Samples​

cURL
curl -X GET \
'http://localhost/task-knowledge' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/task-knowledge', {headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/task-knowledge';
$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-knowledge'

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

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

Get raw markdown for a task knowledge entry​

GET
/tasks/{task_name}/knowledge/markdown

Get raw markdown content for a task knowledge entry.

Returns the index.md content with image references replaced
by inline base64 data URIs for self-contained rendering.

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Parameters​

Path Parameters

task_name*
Typestring
Required

Responses​

Successful Response

Samples​

cURL
curl -X GET \
'http://localhost/tasks/{task_name}/knowledge/markdown' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/tasks/{task_name}/knowledge/markdown', {headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/tasks/{task_name}/knowledge/markdown';
$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_name}/knowledge/markdown'

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

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

Get task knowledge for LLM analysis​

GET
/tasks/{task_name}/knowledge

Get structured domain knowledge for a calibration task.

Returns LLM-oriented knowledge including physical principles,
expected behavior, evaluation criteria, and failure modes.

Parameters

task_name : str
The task name (e.g. "CheckT1", "CheckRabi").
service : TaskService
The task service instance.
backend : str
The backend name (default "qubex").

Returns

TaskKnowledgeResponse
Structured task knowledge.

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Parameters​

Path Parameters

task_name*
Typestring
Required

Query Parameters

backend

Backend name

Typestring

Responses​

Successful Response
application/json
JSON
{
"name": "string",
"category": "string",
"summary": "string",
"what_it_measures": "string",
"physical_principle": "string",
"expected_result": {
"description": "string",
"result_type": "string",
"x_axis": "string",
"y_axis": "string",
"z_axis": "string",
"fit_model": "string",
"typical_range": "string",
"good_visual": "string"
},
"evaluation_criteria": "string",
"check_questions": [
"string"
],
"failure_modes": [
{
"severity": "string",
"description": "string",
"cause": "string",
"visual": "string",
"next_action": "string"
}
],
"tips": [
"string"
],
"output_parameters_info": [
{
"name": "string",
"description": "string"
}
],
"analysis_guide": [
"string"
],
"prerequisites": [
"string"
],
"images": [
{
"alt_text": "string",
"relative_path": "string",
"section": "string",
"base64_data": "string"
}
],
"cases": [
{
"title": "string",
"date": "string",
"severity": "string",
"chip_id": "string",
"qid": "string",
"status": "string",
"symptom": "string",
"root_cause": "string",
"resolution": "string",
"lesson_learned": [
"string"
]
}
],
"prompt_text": "string"
}

Samples​

cURL
curl -X GET \
'http://localhost/tasks/{task_name}/knowledge' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/tasks/{task_name}/knowledge', {headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/tasks/{task_name}/knowledge';
$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_name}/knowledge'

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.

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

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

Get backend configuration​

GET
/task-files/backend-config

Get backend configuration from backend.yaml.

Returns

Backend configuration

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Responses​

Successful Response
application/json
JSON
{
"default_backend": "string",
"backends": {
"additionalProperties": {
}
},
"categories": {
"additionalProperties": [
]
}
}

Samples​

cURL
curl -X GET \
'http://localhost/task-files/backend-config' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/task-files/backend-config', {headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/task-files/backend-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/task-files/backend-config'

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

response = requests.get(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.

Args:

backend: Backend name (e.g., "qubex", "fake")
sort_order: Sort order for tasks
enabled_only: If True, only return tasks that are enabled

Returns:

List of task information

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Parameters​

Query Parameters

backend*
Typestring
Required
sort_order
enabled_only
Typeboolean

Responses​

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

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
service : TaskResultService
Injected task result service

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
service : TaskResultService
Injected task result service

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
service : TaskResultService
Injected task result service

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
service : TaskResultService
Injected task result service

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
service : TaskResultService
Injected task result service

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
service : TaskResultService
Injected task result service

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
service : TaskResultService
Injected task result service
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())

Re-execute a single task from its task result​

POST
/task-results/{task_id}/re-execute

Re-execute a single task using the system single-task-executor deployment.

Looks up the TaskResultHistoryDocument to extract task_name, qid, chip_id,
execution_id, and tags, then delegates to FlowService to create a Prefect
flow run via the system deployment.

Parameters

task_id : str
The task result ID to re-execute
ctx : ProjectContext
Project context with user and project information
service : TaskResultService
Injected task result service
flow_service : FlowService
Injected flow service

Returns

ExecuteFlowResponse
Execution result with IDs and URLs

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Parameters​

Header Parameters

X-Project-Id

Path Parameters

task_id*
Typestring
Required

Request Body​

JSON
{
"parameter_overrides": "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/task-results/{task_id}/re-execute' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/task-results/{task_id}/re-execute', {method:'POST',headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/task-results/{task_id}/re-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/task-results/{task_id}/re-execute'

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

response = requests.post(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())

issue​

List all issues across tasks​

GET
/issues

List all root issues across the project, with reply counts.

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Parameters​

Header Parameters

X-Project-Id

Query Parameters

skip

Number of items to skip

Typeinteger
limit

Max items to return

Typeinteger
task_id

Filter by task ID

is_closed

Filter by closed status. Default false (open only). Set to true for closed, or omit/null for all.

Responses​

Successful Response
application/json
JSON
{
"issues": [
{
"id": "string",
"task_id": "string",
"username": "string",
"title": "string",
"content": "string",
"created_at": "string",
"updated_at": "string",
"parent_id": "string",
"reply_count": 0,
"is_closed": true,
"is_ai_reply": true
}
],
"total": 0,
"skip": 0,
"limit": 0
}

Samples​

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

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

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

Get a single issue by ID​

GET
/issues/{issue_id}

Get a single root issue by its ID, including reply count.

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Parameters​

Header Parameters

X-Project-Id

Path Parameters

issue_id*
Typestring
Required

Responses​

Successful Response
application/json
JSON
{
"id": "string",
"task_id": "string",
"username": "string",
"title": "string",
"content": "string",
"created_at": "string",
"updated_at": "string",
"parent_id": "string",
"reply_count": 0,
"is_closed": true,
"is_ai_reply": true
}

Samples​

cURL
curl -X GET \
'http://localhost/issues/{issue_id}' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/issues/{issue_id}', {headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/issues/{issue_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/issues/{issue_id}'

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

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

Delete an issue​

DELETE
/issues/{issue_id}

Delete an issue. Only the author can delete their own issue.

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Parameters​

Header Parameters

X-Project-Id

Path Parameters

issue_id*
Typestring
Required

Responses​

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

Samples​

cURL
curl -X DELETE \
'http://localhost/issues/{issue_id}' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/issues/{issue_id}', {method:'DELETE',headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/issues/{issue_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/issues/{issue_id}'

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

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

Update an issue​

PATCH
/issues/{issue_id}

Update an issue's content (and title for root issues). Only the author can edit.

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Parameters​

Header Parameters

X-Project-Id

Path Parameters

issue_id*
Typestring
Required

Request Body​

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

Responses​

Successful Response
application/json
JSON
{
"id": "string",
"task_id": "string",
"username": "string",
"title": "string",
"content": "string",
"created_at": "string",
"updated_at": "string",
"parent_id": "string",
"reply_count": 0,
"is_closed": true,
"is_ai_reply": true
}

Samples​

cURL
curl -X PATCH \
'http://localhost/issues/{issue_id}' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/issues/{issue_id}', {method:'PATCH',headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/issues/{issue_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/issues/{issue_id}'

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

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

List replies for an issue​

GET
/issues/{issue_id}/replies

List all replies to a specific issue, sorted by creation time ascending.

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Parameters​

Header Parameters

X-Project-Id

Path Parameters

issue_id*
Typestring
Required

Responses​

Successful Response
application/json
JSON
[
{
"id": "string",
"task_id": "string",
"username": "string",
"title": "string",
"content": "string",
"created_at": "string",
"updated_at": "string",
"parent_id": "string",
"reply_count": 0,
"is_closed": true,
"is_ai_reply": true
}
]

Samples​

cURL
curl -X GET \
'http://localhost/issues/{issue_id}/replies' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/issues/{issue_id}/replies', {headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/issues/{issue_id}/replies';
$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/issues/{issue_id}/replies'

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

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

Close an issue​

PATCH
/issues/{issue_id}/close

Close an issue thread. Only the author or project owner can close.

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Parameters​

Header Parameters

X-Project-Id

Path Parameters

issue_id*
Typestring
Required

Responses​

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

Samples​

cURL
curl -X PATCH \
'http://localhost/issues/{issue_id}/close' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/issues/{issue_id}/close', {method:'PATCH',headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/issues/{issue_id}/close';
$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/issues/{issue_id}/close'

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

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

Reopen an issue​

PATCH
/issues/{issue_id}/reopen

Reopen a closed issue thread. Only the author or project owner can reopen.

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Parameters​

Header Parameters

X-Project-Id

Path Parameters

issue_id*
Typestring
Required

Responses​

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

Samples​

cURL
curl -X PATCH \
'http://localhost/issues/{issue_id}/reopen' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/issues/{issue_id}/reopen', {method:'PATCH',headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/issues/{issue_id}/reopen';
$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/issues/{issue_id}/reopen'

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

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

List issues for a task result​

GET
/task-results/{task_id}/issues

List all issues for a task result, sorted by creation time ascending.

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Parameters​

Header Parameters

X-Project-Id

Path Parameters

task_id*
Typestring
Required

Responses​

Successful Response
application/json
JSON
[
{
"id": "string",
"task_id": "string",
"username": "string",
"title": "string",
"content": "string",
"created_at": "string",
"updated_at": "string",
"parent_id": "string",
"reply_count": 0,
"is_closed": true,
"is_ai_reply": true
}
]

Samples​

cURL
curl -X GET \
'http://localhost/task-results/{task_id}/issues' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/task-results/{task_id}/issues', {headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/task-results/{task_id}/issues';
$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/{task_id}/issues'

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

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

Create an issue on a task result​

POST
/task-results/{task_id}/issues

Create a new issue on a task result.

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Parameters​

Header Parameters

X-Project-Id

Path Parameters

task_id*
Typestring
Required

Request Body​

JSON
{
"title": "string",
"content": "string",
"parent_id": "string"
}

Responses​

Successful Response
application/json
JSON
{
"id": "string",
"task_id": "string",
"username": "string",
"title": "string",
"content": "string",
"created_at": "string",
"updated_at": "string",
"parent_id": "string",
"reply_count": 0,
"is_closed": true,
"is_ai_reply": true
}

Samples​

cURL
curl -X POST \
'http://localhost/task-results/{task_id}/issues' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/task-results/{task_id}/issues', {method:'POST',headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/task-results/{task_id}/issues';
$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/{task_id}/issues'

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

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

issue-knowledge​

List knowledge cases​

GET
/issue-knowledge

List issue-derived knowledge cases with optional filters.

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Parameters​

Header Parameters

X-Project-Id

Query Parameters

skip
Typeinteger
limit
Typeinteger
status

Filter by status: draft, approved, rejected

task_name

Filter by task name

Responses​

Successful Response
application/json
JSON
{
"items": [
{
"id": "string",
"issue_id": "string",
"task_id": "string",
"task_name": "string",
"status": "string",
"title": "string",
"date": "string",
"severity": "string",
"chip_id": "string",
"qid": "string",
"resolution_status": "string",
"symptom": "string",
"root_cause": "string",
"resolution": "string",
"lesson_learned": [
"string"
],
"figure_paths": [
"string"
],
"thread_image_urls": [
"string"
],
"reviewed_by": "string",
"pr_url": "string",
"created_at": "string",
"updated_at": "string"
}
],
"total": 0,
"skip": 0,
"limit": 0
}

Samples​

cURL
curl -X GET \
'http://localhost/issue-knowledge' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/issue-knowledge', {headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/issue-knowledge';
$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/issue-knowledge'

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

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

Get a knowledge case​

GET
/issue-knowledge/{knowledge_id}

Get a single knowledge case by ID.

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Parameters​

Header Parameters

X-Project-Id

Path Parameters

knowledge_id*
Typestring
Required

Responses​

Successful Response
application/json
JSON
{
"id": "string",
"issue_id": "string",
"task_id": "string",
"task_name": "string",
"status": "string",
"title": "string",
"date": "string",
"severity": "string",
"chip_id": "string",
"qid": "string",
"resolution_status": "string",
"symptom": "string",
"root_cause": "string",
"resolution": "string",
"lesson_learned": [
"string"
],
"figure_paths": [
"string"
],
"thread_image_urls": [
"string"
],
"reviewed_by": "string",
"pr_url": "string",
"created_at": "string",
"updated_at": "string"
}

Samples​

cURL
curl -X GET \
'http://localhost/issue-knowledge/{knowledge_id}' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/issue-knowledge/{knowledge_id}', {headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/issue-knowledge/{knowledge_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/issue-knowledge/{knowledge_id}'

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

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

Delete a knowledge case​

DELETE
/issue-knowledge/{knowledge_id}

Delete a knowledge case.

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Parameters​

Header Parameters

X-Project-Id

Path Parameters

knowledge_id*
Typestring
Required

Responses​

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

Samples​

cURL
curl -X DELETE \
'http://localhost/issue-knowledge/{knowledge_id}' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/issue-knowledge/{knowledge_id}', {method:'DELETE',headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/issue-knowledge/{knowledge_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/issue-knowledge/{knowledge_id}'

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

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

Update a knowledge draft​

PATCH
/issue-knowledge/{knowledge_id}

Update a knowledge draft's content. Only drafts can be edited.

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Parameters​

Header Parameters

X-Project-Id

Path Parameters

knowledge_id*
Typestring
Required

Request Body​

JSON
{
"title": "string",
"severity": "string",
"symptom": "string",
"root_cause": "string",
"resolution": "string",
"lesson_learned": "string"
}

Responses​

Successful Response
application/json
JSON
{
"id": "string",
"issue_id": "string",
"task_id": "string",
"task_name": "string",
"status": "string",
"title": "string",
"date": "string",
"severity": "string",
"chip_id": "string",
"qid": "string",
"resolution_status": "string",
"symptom": "string",
"root_cause": "string",
"resolution": "string",
"lesson_learned": [
"string"
],
"figure_paths": [
"string"
],
"thread_image_urls": [
"string"
],
"reviewed_by": "string",
"pr_url": "string",
"created_at": "string",
"updated_at": "string"
}

Samples​

cURL
curl -X PATCH \
'http://localhost/issue-knowledge/{knowledge_id}' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/issue-knowledge/{knowledge_id}', {method:'PATCH',headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/issue-knowledge/{knowledge_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/issue-knowledge/{knowledge_id}'

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

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

Generate knowledge draft from issue​

POST
/issues/{issue_id}/extract-knowledge

Generate an AI knowledge draft from a closed issue thread.

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Parameters​

Header Parameters

X-Project-Id

Path Parameters

issue_id*
Typestring
Required

Responses​

Successful Response
application/json
JSON
{
"id": "string",
"issue_id": "string",
"task_id": "string",
"task_name": "string",
"status": "string",
"title": "string",
"date": "string",
"severity": "string",
"chip_id": "string",
"qid": "string",
"resolution_status": "string",
"symptom": "string",
"root_cause": "string",
"resolution": "string",
"lesson_learned": [
"string"
],
"figure_paths": [
"string"
],
"thread_image_urls": [
"string"
],
"reviewed_by": "string",
"pr_url": "string",
"created_at": "string",
"updated_at": "string"
}

Samples​

cURL
curl -X POST \
'http://localhost/issues/{issue_id}/extract-knowledge' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/issues/{issue_id}/extract-knowledge', {method:'POST',headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/issues/{issue_id}/extract-knowledge';
$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/issues/{issue_id}/extract-knowledge'

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

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

Approve a knowledge draft​

PATCH
/issue-knowledge/{knowledge_id}/approve

Approve a knowledge draft for inclusion in task knowledge.

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Parameters​

Header Parameters

X-Project-Id

Path Parameters

knowledge_id*
Typestring
Required

Responses​

Successful Response
application/json
JSON
{
"id": "string",
"issue_id": "string",
"task_id": "string",
"task_name": "string",
"status": "string",
"title": "string",
"date": "string",
"severity": "string",
"chip_id": "string",
"qid": "string",
"resolution_status": "string",
"symptom": "string",
"root_cause": "string",
"resolution": "string",
"lesson_learned": [
"string"
],
"figure_paths": [
"string"
],
"thread_image_urls": [
"string"
],
"reviewed_by": "string",
"pr_url": "string",
"created_at": "string",
"updated_at": "string"
}

Samples​

cURL
curl -X PATCH \
'http://localhost/issue-knowledge/{knowledge_id}/approve' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/issue-knowledge/{knowledge_id}/approve', {method:'PATCH',headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/issue-knowledge/{knowledge_id}/approve';
$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/issue-knowledge/{knowledge_id}/approve'

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

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

Reject a knowledge draft​

PATCH
/issue-knowledge/{knowledge_id}/reject

Reject a knowledge draft.

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Parameters​

Header Parameters

X-Project-Id

Path Parameters

knowledge_id*
Typestring
Required

Responses​

Successful Response
application/json
JSON
{
"id": "string",
"issue_id": "string",
"task_id": "string",
"task_name": "string",
"status": "string",
"title": "string",
"date": "string",
"severity": "string",
"chip_id": "string",
"qid": "string",
"resolution_status": "string",
"symptom": "string",
"root_cause": "string",
"resolution": "string",
"lesson_learned": [
"string"
],
"figure_paths": [
"string"
],
"thread_image_urls": [
"string"
],
"reviewed_by": "string",
"pr_url": "string",
"created_at": "string",
"updated_at": "string"
}

Samples​

cURL
curl -X PATCH \
'http://localhost/issue-knowledge/{knowledge_id}/reject' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/issue-knowledge/{knowledge_id}/reject', {method:'PATCH',headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/issue-knowledge/{knowledge_id}/reject';
$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/issue-knowledge/{knowledge_id}/reject'

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

response = requests.patch(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.

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.

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"
},
"default_run_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.

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.

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.

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.

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.

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

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

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.

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"
},
"default_run_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.

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.

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.

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.

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
metrics_service: Injected metrics service
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, 'average' for mean values

Typestring
Enumlatest, best, average

Responses​

Successful Response
application/json
JSON
{
"chip_id": "string",
"username": "string",
"qubit_count": 0,
"within_hours": "string",
"qubit_metrics": {
"additionalProperties": {
}
},
"coupling_metrics": {
"additionalProperties": {
}
}
}

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
metrics_service: Injected metrics service
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",
"name": "string",
"input_parameters": "string",
"output_parameters": "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
metrics_service: Injected metrics service
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",
"name": "string",
"input_parameters": "string",
"output_parameters": "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', 'best', or 'average'

Typestring
Enumlatest, best, average

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

provenance​

Get a parameter version by entity ID​

GET
/provenance/entities/{entity_id}

Get a specific parameter version by entity ID.

Parameters

ctx : ProjectContext
Project context with user and project information
service : ProvenanceService
Provenance service instance
entity_id : str
Entity identifier (format: parameter_name:qid:execution_id:task_id)

Returns

ParameterVersionResponse
Parameter version details

Raises

HTTPException
404 if entity not found

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Parameters​

Header Parameters

X-Project-Id

Path Parameters

entity_id*

Entity identifier

Typestring
Required

Responses​

Successful Response
application/json
JSON
{
"entity_id": "string",
"parameter_name": "string",
"qid": "string",
"value": "string",
"value_type": "string",
"unit": "string",
"error": 0,
"version": 0,
"valid_from": "string",
"valid_until": "string",
"execution_id": "string",
"task_id": "string",
"task_name": "string",
"project_id": "string",
"chip_id": "string"
}

Samples​

cURL
curl -X GET \
'http://localhost/provenance/entities/{entity_id}' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/provenance/entities/{entity_id}', {headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/provenance/entities/{entity_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/provenance/entities/{entity_id}'

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

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

Get lineage (ancestors) of a parameter version​

GET
/provenance/lineage/{entity_id}

Get the lineage (ancestors) of a parameter version.

Traverses wasDerivedFrom and wasGeneratedBy relations backward
to find all entities and activities that contributed to this entity.

Parameters

ctx : ProjectContext
Project context with user and project information
service : ProvenanceService
Provenance service instance
entity_id : str
Entity identifier to trace lineage from
max_depth : int
Maximum traversal depth (1-20)

Returns

LineageResponse
Lineage graph with nodes and edges

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Parameters​

Header Parameters

X-Project-Id

Path Parameters

entity_id*

Entity identifier

Typestring
Required

Query Parameters

max_depth

Maximum traversal depth

Typeinteger

Responses​

Successful Response
application/json
JSON
{
"origin": {
"node_type": "string",
"node_id": "string",
"depth": 0,
"entity": "string",
"activity": "string",
"latest_version": "string"
},
"nodes": [
{
"node_type": "string",
"node_id": "string",
"depth": 0,
"entity": "string",
"activity": "string",
"latest_version": "string"
}
],
"edges": [
{
"relation_type": "string",
"source_id": "string",
"target_id": "string"
}
],
"max_depth": 0
}

Samples​

cURL
curl -X GET \
'http://localhost/provenance/lineage/{entity_id}' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/provenance/lineage/{entity_id}', {headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/provenance/lineage/{entity_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/provenance/lineage/{entity_id}'

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

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

Get impact (descendants) of a parameter version​

GET
/provenance/impact/{entity_id}

Get the impact (descendants) of a parameter version.

Traverses wasDerivedFrom relations forward to find all entities
that were derived from this entity.

Parameters

ctx : ProjectContext
Project context with user and project information
service : ProvenanceService
Provenance service instance
entity_id : str
Entity identifier to trace impact from
max_depth : int
Maximum traversal depth (1-20)

Returns

ImpactResponse
Impact graph with affected nodes and edges

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Parameters​

Header Parameters

X-Project-Id

Path Parameters

entity_id*

Entity identifier

Typestring
Required

Query Parameters

max_depth

Maximum traversal depth

Typeinteger

Responses​

Successful Response
application/json
JSON
{
"origin": {
"node_type": "string",
"node_id": "string",
"depth": 0,
"entity": "string",
"activity": "string",
"latest_version": "string"
},
"nodes": [
{
"node_type": "string",
"node_id": "string",
"depth": 0,
"entity": "string",
"activity": "string",
"latest_version": "string"
}
],
"edges": [
{
"relation_type": "string",
"source_id": "string",
"target_id": "string"
}
],
"max_depth": 0
}

Samples​

cURL
curl -X GET \
'http://localhost/provenance/impact/{entity_id}' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/provenance/impact/{entity_id}', {headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/provenance/impact/{entity_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/provenance/impact/{entity_id}'

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

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

Compare parameter values between two executions​

GET
/provenance/compare

Compare parameter values between two executions.

Shows which parameters were added, removed, or changed between
two calibration executions.

Parameters

ctx : ProjectContext
Project context with user and project information
service : ProvenanceService
Provenance service instance
execution_id_before : str
First execution ID (before state)
execution_id_after : str
Second execution ID (after state)

Returns

ExecutionComparisonResponse
Comparison of parameter values

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Parameters​

Header Parameters

X-Project-Id

Query Parameters

execution_id_before*

First execution ID (before)

Typestring
Required
execution_id_after*

Second execution ID (after)

Typestring
Required

Responses​

Successful Response
application/json
JSON
{
"execution_id_before": "string",
"execution_id_after": "string",
"added_parameters": [
{
"parameter_name": "string",
"qid": "string",
"value_before": "string",
"value_after": "string",
"delta": "string",
"delta_percent": "string"
}
],
"removed_parameters": [
{
"parameter_name": "string",
"qid": "string",
"value_before": "string",
"value_after": "string",
"delta": "string",
"delta_percent": "string"
}
],
"changed_parameters": [
{
"parameter_name": "string",
"qid": "string",
"value_before": "string",
"value_after": "string",
"delta": "string",
"delta_percent": "string"
}
],
"unchanged_count": 0
}

Samples​

cURL
curl -X GET \
'http://localhost/provenance/compare' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/provenance/compare', {headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/provenance/compare';
$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/provenance/compare'

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

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

Get version history for a parameter​

GET
/provenance/history

Get version history for a parameter.

Returns all versions of a parameter for a specific qubit,
sorted by version number (newest first).

Parameters

ctx : ProjectContext
Project context with user and project information
service : ProvenanceService
Provenance service instance
parameter_name : str
Name of the parameter (e.g., "qubit_frequency")
qid : str
Qubit or coupling identifier (e.g., "Q0", "Q0-Q1")
limit : int
Maximum number of versions to return

Returns

ParameterHistoryResponse
List of parameter versions

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Parameters​

Header Parameters

X-Project-Id

Query Parameters

parameter_name*

Name of the parameter

Typestring
Required
qid*

Qubit or coupling identifier

Typestring
Required
limit

Maximum number of versions

Typeinteger

Responses​

Successful Response
application/json
JSON
{
"parameter_name": "string",
"qid": "string",
"versions": [
{
"entity_id": "string",
"parameter_name": "string",
"qid": "string",
"value": "string",
"value_type": "string",
"unit": "string",
"error": 0,
"version": 0,
"valid_from": "string",
"valid_until": "string",
"execution_id": "string",
"task_id": "string",
"task_name": "string",
"project_id": "string",
"chip_id": "string"
}
],
"total_versions": 0
}

Samples​

cURL
curl -X GET \
'http://localhost/provenance/history' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/provenance/history', {headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/provenance/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/provenance/history'

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

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

Get provenance statistics​

GET
/provenance/stats

Get provenance statistics for a project.

Returns counts and recent entities for provenance tracking.

Parameters

ctx : ProjectContext
Project context with user and project information
service : ProvenanceService
Provenance service instance

Returns

ProvenanceStatsResponse
Provenance statistics

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Parameters​

Header Parameters

X-Project-Id

Responses​

Successful Response
application/json
JSON
{
"total_entities": 0,
"total_activities": 0,
"total_relations": 0,
"relation_counts": {
"additionalProperties": 0
},
"recent_entities": [
{
"entity_id": "string",
"parameter_name": "string",
"qid": "string",
"value": "string",
"value_type": "string",
"unit": "string",
"error": 0,
"version": 0,
"valid_from": "string",
"valid_until": "string",
"execution_id": "string",
"task_id": "string",
"task_name": "string",
"project_id": "string",
"chip_id": "string"
}
]
}

Samples​

cURL
curl -X GET \
'http://localhost/provenance/stats' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/provenance/stats', {headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/provenance/stats';
$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/provenance/stats'

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

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

Get recent execution IDs​

GET
/provenance/executions

Get recent unique execution IDs.

Returns unique execution IDs sorted by most recent first.
Uses MongoDB aggregation for efficient retrieval.

Parameters

ctx : ProjectContext
Project context with user and project information
service : ProvenanceService
Provenance service instance
limit : int
Maximum number of execution IDs to return (1-50)

Returns

RecentExecutionsResponse
List of recent execution IDs

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Parameters​

Header Parameters

X-Project-Id

Query Parameters

limit

Maximum number of execution IDs to return

Typeinteger

Responses​

Successful Response
application/json
JSON
{
"executions": [
{
"execution_id": "string",
"valid_from": "string"
}
]
}

Samples​

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

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

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

Get recent parameter changes with delta​

GET
/provenance/changes

Get recent parameter changes with delta from previous versions.

Returns parameter changes that have a previous version, showing
the delta (difference) from the previous value.

Parameters

ctx : ProjectContext
Project context with user and project information
service : ProvenanceService
Provenance service instance
limit : int
Maximum number of changes to return (1-50)
within_hours : int
Time window in hours (1-168, default: 24)
parameter_names : list[str] | None
Filter by parameter names (e.g., from metrics.yaml config)

Returns

RecentChangesResponse
List of recent parameter changes with delta information

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Parameters​

Header Parameters

X-Project-Id

Query Parameters

limit

Maximum number of changes to return

Typeinteger
within_hours

Time window in hours

Typeinteger
parameter_names

Filter by parameter names (from metrics config)

Responses​

Successful Response
application/json
JSON
{
"changes": [
{
"entity_id": "string",
"parameter_name": "string",
"qid": "string",
"value": "string",
"previous_value": "string",
"unit": "string",
"delta": "string",
"delta_percent": "string",
"version": 0,
"valid_from": "string",
"task_name": "string",
"execution_id": "string",
"error": 0,
"previous_error": "string"
}
],
"total_count": 0
}

Samples​

cURL
curl -X GET \
'http://localhost/provenance/changes' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/provenance/changes', {headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/provenance/changes';
$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/provenance/changes'

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

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

Get degradation trends (consecutive worsening)​

GET
/provenance/degradation-trends

Get parameters with consecutive degradation across calibration versions.

Detects parameters where the value has been consistently worsening
(based on evaluation mode: maximize/minimize) over multiple versions.

Parameters

ctx : ProjectContext
Project context with user and project information
service : ProvenanceService
Provenance service instance
min_streak : int
Minimum consecutive worsening steps (3-20, default: 3)
limit : int
Maximum number of trends to return (1-100, default: 50)
parameter_names : list[str] | None
Filter by parameter names

Returns

DegradationTrendsResponse
Detected degradation trends sorted by severity

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Parameters​

Header Parameters

X-Project-Id

Query Parameters

min_streak

Minimum consecutive worsening steps

Typeinteger
limit

Maximum number of trends to return

Typeinteger
parameter_names

Filter by parameter names

Responses​

Successful Response
application/json
JSON
{
"trends": [
{
"parameter_name": "string",
"qid": "string",
"evaluation_mode": "string",
"streak_count": 0,
"total_delta": 0,
"total_delta_percent": 0,
"delta_per_step": 0,
"current_value": "string",
"current_entity_id": "string",
"unit": "string",
"values": [
0
],
"valid_from": "string"
}
],
"total_count": 0
}

Samples​

cURL
curl -X GET \
'http://localhost/provenance/degradation-trends' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/provenance/degradation-trends', {headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/provenance/degradation-trends';
$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/provenance/degradation-trends'

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

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

Get recalibration task recommendations​

GET
/provenance/recommendations/{entity_id}

Get recommended recalibration tasks based on parameter change impact.

When a calibration parameter changes (either through recalibration or
manual adjustment), this endpoint analyzes the provenance graph to
identify which downstream parameters are affected and recommends
which calibration tasks should be re-run.

The recommendations are prioritized based on dependency proximity:
tasks producing directly dependent parameters are ranked higher than
those producing transitively dependent parameters.

Parameters

ctx : ProjectContext
Project context with user and project information
service : ProvenanceService
Provenance service instance
entity_id : str
Entity identifier of the changed parameter
max_depth : int
Maximum traversal depth for impact analysis (1-20)

Returns

RecalibrationRecommendationResponse
Prioritized list of recommended recalibration tasks

Example

If qubit_frequency for Q0 changes:

  • Priority 1: CheckRabiOscillation (direct dependency)
  • Priority 2: CheckT1, CheckT2 (use frequency-dependent pulses)
  • Priority 3: CheckCrossResonance (uses derived gate parameters)

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Parameters​

Header Parameters

X-Project-Id

Path Parameters

entity_id*

Entity identifier of changed parameter

Typestring
Required

Query Parameters

max_depth

Maximum impact traversal depth

Typeinteger

Responses​

Successful Response
application/json
JSON
{
"source_entity_id": "string",
"source_parameter_name": "string",
"source_qid": "string",
"recommended_tasks": [
{
"task_name": "string",
"priority": 0,
"affected_parameters": [
"string"
],
"affected_qids": [
"string"
],
"reason": "string"
}
],
"total_affected_parameters": 0,
"max_depth_reached": 0
}

Samples​

cURL
curl -X GET \
'http://localhost/provenance/recommendations/{entity_id}' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/provenance/recommendations/{entity_id}', {headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/provenance/recommendations/{entity_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/provenance/recommendations/{entity_id}'

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

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

Get policy violations for current parameter versions​

GET
/provenance/policy/violations

Get policy violations evaluated on current (latest valid) parameter versions.

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Parameters​

Header Parameters

X-Project-Id

Query Parameters

severity

Filter by severity (warn)

limit

Maximum number of violations to return

Typeinteger
parameter_names

Filter by parameter names

Responses​

Successful Response
application/json
JSON
{
"violations": [
{
"entity_id": "string",
"parameter_name": "string",
"qid": "string",
"value": "string",
"unit": "string",
"error": 0,
"valid_from": "string",
"severity": "string",
"check_type": "string",
"message": "string",
"warn_threshold": "string",
"measured": "string"
}
],
"total_count": 0
}

Samples​

cURL
curl -X GET \
'http://localhost/provenance/policy/violations' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/provenance/policy/violations', {headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/provenance/policy/violations';
$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/provenance/policy/violations'

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

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

Get policy violations for current versions in impact set​

GET
/provenance/policy/impact/{entity_id}

Get policy violations for current versions within the impact graph of an entity.

Authorizations​

HTTPBearer
Type: HTTP (bearer)

Parameters​

Header Parameters

X-Project-Id

Path Parameters

entity_id*

Entity identifier

Typestring
Required

Query Parameters

max_depth

Maximum traversal depth

Typeinteger
severity

Filter by severity (warn)

limit

Maximum number of violations to return

Typeinteger

Responses​

Successful Response
application/json
JSON
{
"violations": [
{
"entity_id": "string",
"parameter_name": "string",
"qid": "string",
"value": "string",
"unit": "string",
"error": 0,
"valid_from": "string",
"severity": "string",
"check_type": "string",
"message": "string",
"warn_threshold": "string",
"measured": "string"
}
],
"total_count": 0
}

Samples​

cURL
curl -X GET \
'http://localhost/provenance/policy/impact/{entity_id}' \
 -H "Content-Type: application/json"
JavaScript
fetch('http://localhost/provenance/policy/impact/{entity_id}', {headers:{'Content-Type':'application/json'}})
  .then(response => response.json())
  .then(data => console.log(data));
PHP
<?php
$url = 'http://localhost/provenance/policy/impact/{entity_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/provenance/policy/impact/{entity_id}'

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