MENU navbar-image

Introduction

Pagination query params are as follows: page[size]=10&page[number]=1

This documentation aims to provide all the information you need to work with our API.

Authenticating requests

This API is authenticated by sending an Authorization header with the value "Bearer {OPENID_CONNECT_TOKEN}".

All authenticated endpoints are marked with a requires authentication badge in the documentation below.

Use OpenID Connect to retrieve a token. Instructions can be found here.

User

Me

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://base.stackflows.com/api/v2/user',
    [
        'headers' => [
            'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
        'query' => [
            'include'=> '"points, points_formatted, reputations"',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/user"
);

const params = {
    "include": ""points, points_formatted, reputations"",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "https://base.stackflows.com/api/v2/user?include=%22points%2C+points_formatted%2C+reputations%22" \
    --header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"

Example response (200):


{
    "data": {
        "name": "Kyle",
        "surname": "Schiller",
        "email": "dejuan15@example.org",
        "phone": "+1 (747) 478-7163",
        "email_verified_at": "1992-05-16T03:26:45.000000Z",
        "_key": null
    }
}
 

Request   

GET api/v2/user

Headers

Authorization      

Example: Bearer {OPENID_CONNECT_TOKEN}

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

Query Parameters

include   string  optional  

One or many of possible includes (reputations, badges, organizations, rank). Example: "points, points_formatted, reputations"

filter[organizations.name]   string  optional  

Example: ipsam

Update

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->put(
    'https://base.stackflows.com/api/v2/user',
    [
        'headers' => [
            'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
        'json' => [
            'name' => 'ratione',
            'surname' => 'possimus',
            'phone' => 'dolores',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/user"
);

const headers = {
    "Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

let body = {
    "name": "ratione",
    "surname": "possimus",
    "phone": "dolores"
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request PUT \
    "https://base.stackflows.com/api/v2/user" \
    --header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx" \
    --data "{
    \"name\": \"ratione\",
    \"surname\": \"possimus\",
    \"phone\": \"dolores\"
}"

Example response (200):


{
    "data": {
        "name": "Jude",
        "surname": "Langosh",
        "email": "jeanette98@example.net",
        "phone": "269-595-0116",
        "email_verified_at": "2006-06-09T07:53:00.000000Z",
        "_key": null
    }
}
 

Request   

PUT api/v2/user

Headers

Authorization      

Example: Bearer {OPENID_CONNECT_TOKEN}

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

Body Parameters

organization_ids   string[]  optional  
organization_unit_ids   string[]  optional  
name   string  optional  

Example: ratione

surname   string  optional  

Example: possimus

phone   string  optional  

Example: dolores

List Organizations

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://base.stackflows.com/api/v2/user/organizations',
    [
        'headers' => [
            'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/user/organizations"
);

const headers = {
    "Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "https://base.stackflows.com/api/v2/user/organizations" \
    --header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"

Example response (200):


{
    "data": [
        {
            "organization_id": "58633cf0-c16a-11ee-b850-9559b4333470",
            "name": {
                "en": "est"
            },
            "description": {
                "en": "Quick, now!' And Alice was not here before,' said the Duchess, 'chop off her head!' Those whom she sentenced were taken into custody by the carrier,' she thought; 'and how funny it'll seem to have."
            },
            "parent_id": "59583c90-c16a-11ee-9675-1d0cfd6336c5",
            "_key": null
        },
        {
            "organization_id": "595a1280-c16a-11ee-af04-bd8757318f25",
            "name": {
                "en": "atque"
            },
            "description": {
                "en": "White Rabbit put on his flappers, '--Mystery, ancient and modern, with Seaography: then Drawling--the Drawling-master was an immense length of neck, which seemed to Alice for some time after the."
            },
            "parent_id": "5a5c8740-c16a-11ee-bc8b-cb43b7f5c152",
            "_key": null
        }
    ]
}
 

Request   

GET api/v2/user/organizations

Headers

Authorization      

Example: Bearer {OPENID_CONNECT_TOKEN}

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

Create Organization

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://base.stackflows.com/api/v2/user/organizations',
    [
        'headers' => [
            'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
        'json' => [
            'name' => 'jzjy',
            'slug' => 'ztstc',
            'country_id' => 'cupiditate',
            'domains' => [
                'itaque',
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/user/organizations"
);

const headers = {
    "Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

let body = {
    "name": "jzjy",
    "slug": "ztstc",
    "country_id": "cupiditate",
    "domains": [
        "itaque"
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request POST \
    "https://base.stackflows.com/api/v2/user/organizations" \
    --header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx" \
    --data "{
    \"name\": \"jzjy\",
    \"slug\": \"ztstc\",
    \"country_id\": \"cupiditate\",
    \"domains\": [
        \"itaque\"
    ]
}"

Example response (200):


{
    "data": {
        "name": "Organization architecto",
        "country": "Guernsey",
        "company_code": "sb-975",
        "city": "North Daryl",
        "address": "8943 Greyson Crossing Suite 569\nLake Nikitaside, MI 38663-0512",
        "vat": "GB1076508932445",
        "_key": null
    }
}
 

Request   

POST api/v2/user/organizations

Headers

Authorization      

Example: Bearer {OPENID_CONNECT_TOKEN}

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

Body Parameters

name   string   

Must not be greater than 255 characters. Example: jzjy

slug   string   

Must not be greater than 255 characters. Example: ztstc

country_id   string   

Example: cupiditate

domains   string[]  optional  

View Organization

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://base.stackflows.com/api/v2/user/organizations/18832260-c7b3-11ed-a964-87702eeadd00',
    [
        'headers' => [
            'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
        'query' => [
            'include=members-count'=> '16',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/user/organizations/18832260-c7b3-11ed-a964-87702eeadd00"
);

const params = {
    "include=members-count": "16",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "https://base.stackflows.com/api/v2/user/organizations/18832260-c7b3-11ed-a964-87702eeadd00?include%3Dmembers-count=16" \
    --header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"

Example response (200):


{
    "data": {
        "organization_id": "5a687460-c16a-11ee-ba3e-9104171aa8e9",
        "name": {
            "en": "autem"
        },
        "description": {
            "en": "Alice, whose thoughts were still running on the ground near the house down!' said the Mock Turtle to sing \"Twinkle, twinkle, little bat! How I wonder what they said. The executioner's argument was."
        },
        "parent_id": "5b5fda90-c16a-11ee-99bf-093f76e866cd",
        "_key": null
    }
}
 

Request   

GET api/v2/user/organizations/{id}

Headers

Authorization      

Example: Bearer {OPENID_CONNECT_TOKEN}

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

URL Parameters

id   string   

The ID of the organization. Example: 18832260-c7b3-11ed-a964-87702eeadd00

organization   string   

The ID of an organization. Example: 3688e6c0-1a56-11ec-8366

Query Parameters

include=members-count   integer  optional  

Include members count Example: 16

Update Organization

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->put(
    'https://base.stackflows.com/api/v2/user/organizations/18832260-c7b3-11ed-a964-87702eeadd00',
    [
        'headers' => [
            'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
        'json' => [
            'name' => 'sunt',
            'company_code' => 'enim',
            'address' => 'mollitia',
            'city' => 'esse',
            'vat' => 'quia',
            'domains' => [
                'beatae',
            ],
            'slug' => 'eaque',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/user/organizations/18832260-c7b3-11ed-a964-87702eeadd00"
);

const headers = {
    "Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

let body = {
    "name": "sunt",
    "company_code": "enim",
    "address": "mollitia",
    "city": "esse",
    "vat": "quia",
    "domains": [
        "beatae"
    ],
    "slug": "eaque"
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request PUT \
    "https://base.stackflows.com/api/v2/user/organizations/18832260-c7b3-11ed-a964-87702eeadd00" \
    --header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx" \
    --data "{
    \"name\": \"sunt\",
    \"company_code\": \"enim\",
    \"address\": \"mollitia\",
    \"city\": \"esse\",
    \"vat\": \"quia\",
    \"domains\": [
        \"beatae\"
    ],
    \"slug\": \"eaque\"
}"

Example response (200):


{
    "data": {
        "organization_id": "5b677220-c16a-11ee-ad57-87bf15a2b503",
        "name": {
            "en": "asperiores"
        },
        "description": {
            "en": "Gryphon answered, very nearly getting up and saying, 'Thank you, it's a very decided tone: 'tell her something worth hearing. For some minutes the whole place around her became alive with the Queen."
        },
        "parent_id": "5c5d36d0-c16a-11ee-88fe-b375fd4b45e9",
        "_key": null
    }
}
 

Request   

PUT api/v2/user/organizations/{id}

PATCH api/v2/user/organizations/{id}

Headers

Authorization      

Example: Bearer {OPENID_CONNECT_TOKEN}

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

URL Parameters

id   string   

The ID of the organization. Example: 18832260-c7b3-11ed-a964-87702eeadd00

organization   string   

The ID of an organization. Example: 3688e6c0-1a56-11ec-8366

Body Parameters

name   string  optional  

Example: sunt

company_code   string  optional  

Example: enim

country_id   string  optional  
address   string  optional  

Example: mollitia

city   string  optional  

Example: esse

vat   string  optional  

Example: quia

domains   string[]  optional  
slug   string  optional  

Example: eaque

Exists by slug

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://base.stackflows.com/api/v2/user/organizations/18832260-c7b3-11ed-a964-87702eeadd00/exists',
    [
        'headers' => [
            'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/user/organizations/18832260-c7b3-11ed-a964-87702eeadd00/exists"
);

const headers = {
    "Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "https://base.stackflows.com/api/v2/user/organizations/18832260-c7b3-11ed-a964-87702eeadd00/exists" \
    --header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"

Example response (500):

Show headers
cache-control: no-cache, private
content-type: application/json
vary: Origin
 

{
    "message": "Server Error"
}
 

Request   

GET api/v2/user/organizations/{slug}/exists

Headers

Authorization      

Example: Bearer {OPENID_CONNECT_TOKEN}

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

URL Parameters

slug   string   

The slug of the organization. Example: 18832260-c7b3-11ed-a964-87702eeadd00

List Organization Users

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://base.stackflows.com/api/v2/user/organizations/18832260-c7b3-11ed-a964-87702eeadd00/users',
    [
        'headers' => [
            'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
        'query' => [
            'filter[similarly_ranked]'=> '1',
            'filter[active]'=> '1',
            'filter[search]'=> 'John',
            'include'=> 'organization_units',
            'sorts'=> 'rank,-reputation',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/user/organizations/18832260-c7b3-11ed-a964-87702eeadd00/users"
);

const params = {
    "filter[similarly_ranked]": "1",
    "filter[active]": "1",
    "filter[search]": "John",
    "include": "organization_units",
    "sorts": "rank,-reputation",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "https://base.stackflows.com/api/v2/user/organizations/18832260-c7b3-11ed-a964-87702eeadd00/users?filter%5Bsimilarly_ranked%5D=1&filter%5Bactive%5D=1&filter%5Bsearch%5D=John&include=organization_units&sorts=rank%2C-reputation" \
    --header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"

Example response (200):


{
    "data": [
        {
            "name": "Icie",
            "surname": "Monahan",
            "email": "alfonso73@example.org",
            "phone": "(540) 360-8025",
            "email_verified_at": "1974-11-01T11:07:18.000000Z",
            "_key": null
        },
        {
            "name": "Savannah",
            "surname": "Hickle",
            "email": "doyle.jerald@example.org",
            "phone": "(947) 296-1035",
            "email_verified_at": "1972-10-05T04:47:36.000000Z",
            "_key": null
        }
    ]
}
 

Request   

GET api/v2/user/organizations/{organization_id}/users

Headers

Authorization      

Example: Bearer {OPENID_CONNECT_TOKEN}

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

URL Parameters

organization_id   string   

The ID of the organization. Example: 18832260-c7b3-11ed-a964-87702eeadd00

Query Parameters

filter[similarly_ranked]   boolean  optional  

List only similarly ranked to a logged user. Example: true

filter[active]   boolean  optional  

List only active/inactive users. Example: true

filter[search]   string  optional  

List only user that contains specified keyword in their name. Example: John

include   string  optional  

List of includes separated by comma. Example: organization_units

sorts   string  optional  

List of possible sorts by comma. Example: rank,-reputation

Organization domain exists by name

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://base.stackflows.com/api/v2/user/organization-domains/318695e0-03a2-11ee-ad7c-115d06207d80/exists',
    [
        'headers' => [
            'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/user/organization-domains/318695e0-03a2-11ee-ad7c-115d06207d80/exists"
);

const headers = {
    "Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "https://base.stackflows.com/api/v2/user/organization-domains/318695e0-03a2-11ee-ad7c-115d06207d80/exists" \
    --header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"

Example response (500):

Show headers
cache-control: no-cache, private
content-type: application/json
vary: Origin
 

{
    "message": "Server Error"
}
 

Request   

GET api/v2/user/organization-domains/{domain}/exists

Headers

Authorization      

Example: Bearer {OPENID_CONNECT_TOKEN}

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

URL Parameters

domain   string   

Example: 318695e0-03a2-11ee-ad7c-115d06207d80

Open

World

List Countries

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://base.stackflows.com/api/v2/world/countries',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
        'query' => [
            'include'=> 'states,cities,timezones,currency',
            'filter[name]'=> 'Estonia',
            'filter[phone_code]'=> '440',
            'filter[region]'=> 'Europe',
            'filter[subregion]'=> 'Southern Europe',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/world/countries"
);

const params = {
    "include": "states,cities,timezones,currency",
    "filter[name]": "Estonia",
    "filter[phone_code]": "440",
    "filter[region]": "Europe",
    "filter[subregion]": "Southern Europe",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "https://base.stackflows.com/api/v2/world/countries?include=states%2Ccities%2Ctimezones%2Ccurrency&filter%5Bname%5D=Estonia&filter%5Bphone_code%5D=440&filter%5Bregion%5D=Europe&filter%5Bsubregion%5D=Southern+Europe" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"

Example response (200):


{
    "data": [
        {
            "iso2": "TL",
            "name": "Sao Tome and Principe",
            "status": 1,
            "phone_code": 903,
            "iso3": "LBY",
            "region": "ex",
            "subregion": "sed",
            "_key": null
        },
        {
            "iso2": "GW",
            "name": "Trinidad and Tobago",
            "status": 1,
            "phone_code": 396,
            "iso3": "NFK",
            "region": "dicta",
            "subregion": "similique",
            "_key": null
        }
    ]
}
 

Request   

GET api/v2/world/countries

Headers

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

Query Parameters

include   string  optional  

Possible includes. Example: states,cities,timezones,currency

filter[name]   string  optional  

Retrieve countries by name. Example: Estonia

filter[phone_code]   string  optional  

Retrieve countries by phone code. Example: 440

filter[region]   string  optional  

Retrieve countries by a region. Example: Europe

filter[subregion]   string  optional  

Retrieve countries by a region. Example: Southern Europe

View Country

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://base.stackflows.com/api/v2/world/countries/consectetur',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
        'query' => [
            'include'=> 'states,cities,timezones,currency',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/world/countries/consectetur"
);

const params = {
    "include": "states,cities,timezones,currency",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "https://base.stackflows.com/api/v2/world/countries/consectetur?include=states%2Ccities%2Ctimezones%2Ccurrency" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"

Example response (200):


{
    "data": {
        "iso2": "AM",
        "name": "American Samoa",
        "status": 1,
        "phone_code": 558,
        "iso3": "MOZ",
        "region": "voluptas",
        "subregion": "iste",
        "_key": null
    }
}
 

Request   

GET api/v2/world/countries/{id}

Headers

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

URL Parameters

id   string   

The ID of the country. Example: consectetur

Query Parameters

include   string  optional  

Possible includes. Example: states,cities,timezones,currency

List States

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://base.stackflows.com/api/v2/world/states',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
        'query' => [
            'include'=> 'country,cities',
            'filter[name]'=> 'Bamyan',
            'filter[country_code]'=> 'ES',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/world/states"
);

const params = {
    "include": "country,cities",
    "filter[name]": "Bamyan",
    "filter[country_code]": "ES",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "https://base.stackflows.com/api/v2/world/states?include=country%2Ccities&filter%5Bname%5D=Bamyan&filter%5Bcountry_code%5D=ES" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"

Example response (200):


{
    "data": [
        {
            "country_id": 2942,
            "name": "BSD",
            "country_code": "FK",
            "_key": null
        },
        {
            "country_id": 2943,
            "name": "ETB",
            "country_code": "AL",
            "_key": null
        }
    ]
}
 

Request   

GET api/v2/world/states

Headers

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

Query Parameters

include   string  optional  

Possible includes. Example: country,cities

filter[name]   string  optional  

Retrieve states by name. Example: Bamyan

filter[country_code]   string  optional  

Retrieve states by iso 2 country code. Example: ES

View State

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://base.stackflows.com/api/v2/world/states/eaque',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
        'query' => [
            'include'=> 'country,cities',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/world/states/eaque"
);

const params = {
    "include": "country,cities",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "https://base.stackflows.com/api/v2/world/states/eaque?include=country%2Ccities" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"

Example response (200):


{
    "data": {
        "country_id": 2944,
        "name": "MZN",
        "country_code": "MX",
        "_key": null
    }
}
 

Request   

GET api/v2/world/states/{id}

Headers

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

URL Parameters

id   string   

The ID of the state. Example: eaque

Query Parameters

include   string  optional  

Possible includes. Example: country,cities

List Cities

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://base.stackflows.com/api/v2/world/cities',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
        'query' => [
            'include'=> 'country,state',
            'filter[name]'=> 'Burrel',
            'filter[country_code]'=> 'ES',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/world/cities"
);

const params = {
    "include": "country,state",
    "filter[name]": "Burrel",
    "filter[country_code]": "ES",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "https://base.stackflows.com/api/v2/world/cities?include=country%2Cstate&filter%5Bname%5D=Burrel&filter%5Bcountry_code%5D=ES" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"

Example response (200):


{
    "data": [
        {
            "country_id": 2945,
            "state_id": 5502,
            "name": "RUB",
            "country_code": "GT",
            "_key": null
        },
        {
            "country_id": 2947,
            "state_id": 5503,
            "name": "ERN",
            "country_code": "HT",
            "_key": null
        }
    ]
}
 

Request   

GET api/v2/world/cities

Headers

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

Query Parameters

include   string  optional  

Possible includes. Example: country,state

filter[name]   string  optional  

Retrieve cities by name. Example: Burrel

filter[country_code]   string  optional  

Retrieve cities by iso 2 country code. Example: ES

View City

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://base.stackflows.com/api/v2/world/cities/aut',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
        'query' => [
            'include'=> 'country,state',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/world/cities/aut"
);

const params = {
    "include": "country,state",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "https://base.stackflows.com/api/v2/world/cities/aut?include=country%2Cstate" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"

Example response (200):


{
    "data": {
        "country_id": 2949,
        "state_id": 5504,
        "name": "LKR",
        "country_code": "BW",
        "_key": null
    }
}
 

Request   

GET api/v2/world/cities/{id}

Headers

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

URL Parameters

id   string   

The ID of the city. Example: aut

Query Parameters

include   string  optional  

Possible includes. Example: country,state

List Timezones

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://base.stackflows.com/api/v2/world/timezones',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
        'query' => [
            'filter[name]'=> 'Europe/Tirane',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/world/timezones"
);

const params = {
    "filter[name]": "Europe/Tirane",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "https://base.stackflows.com/api/v2/world/timezones?filter%5Bname%5D=Europe%2FTirane" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"

Example response (200):


{
    "data": [
        {
            "country_id": 2951,
            "name": "BBD",
            "_key": null
        },
        {
            "country_id": 2952,
            "name": "JMD",
            "_key": null
        }
    ]
}
 

Request   

GET api/v2/world/timezones

Headers

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

Query Parameters

filter[name]   string  optional  

Retrieve timezones by name. Example: Europe/Tirane

List Currencies

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://base.stackflows.com/api/v2/world/currencies',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
        'query' => [
            'filter[name]'=> 'Europe/Tirane',
            'filter[code]'=> 'Europe/Tirane',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/world/currencies"
);

const params = {
    "filter[name]": "Europe/Tirane",
    "filter[code]": "Europe/Tirane",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "https://base.stackflows.com/api/v2/world/currencies?filter%5Bname%5D=Europe%2FTirane&filter%5Bcode%5D=Europe%2FTirane" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"

Example response (200):


{
    "data": [
        {
            "country_id": 2953,
            "name": "quos",
            "code": "BIF",
            "precision": 2,
            "symbol": "€",
            "symbol_native": "€",
            "symbol_first": "1",
            "decimal_mark": ".",
            "thousands_separator": ",",
            "_key": null
        },
        {
            "country_id": 2954,
            "name": "officiis",
            "code": "SHP",
            "precision": 2,
            "symbol": "€",
            "symbol_native": "€",
            "symbol_first": "1",
            "decimal_mark": ".",
            "thousands_separator": ",",
            "_key": null
        }
    ]
}
 

Request   

GET api/v2/world/currencies

Headers

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

Query Parameters

filter[name]   string  optional  

Retrieve currencies by name. Example: Europe/Tirane

filter[code]   string  optional  

Retrieve currencies by code. Example: Europe/Tirane

List Languages

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://base.stackflows.com/api/v2/world/languages',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
        'query' => [
            'filter[code]'=> 'es',
            'filter[name]'=> 'Aymara',
            'filter[name_native]'=> 'aymar aru',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/world/languages"
);

const params = {
    "filter[code]": "es",
    "filter[name]": "Aymara",
    "filter[name_native]": "aymar aru",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "https://base.stackflows.com/api/v2/world/languages?filter%5Bcode%5D=es&filter%5Bname%5D=Aymara&filter%5Bname_native%5D=aymar+aru" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"

Example response (200):


{
    "data": [
        {
            "code": "yo",
            "name": "excepturi",
            "name_native": "laborum",
            "dir": "ltr",
            "_key": null
        },
        {
            "code": "ka",
            "name": "qui",
            "name_native": "non",
            "dir": "ltr",
            "_key": null
        }
    ]
}
 

Request   

GET api/v2/world/languages

Headers

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

Query Parameters

filter[code]   string  optional  

Retrieve languages by code. Example: es

filter[name]   string  optional  

Retrieve languages by name. Example: Aymara

filter[name_native]   string  optional  

Retrieve languages by a native name. Example: aymar aru

Public Business Process Models

View Business Model

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://base.stackflows.com/api/v2/public-business-process-models/nam',
    [
        'headers' => [
            'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
        'query' => [
            'include=category,diagrams'=> 'quae',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/public-business-process-models/nam"
);

const params = {
    "include=category,diagrams": "quae",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "https://base.stackflows.com/api/v2/public-business-process-models/nam?include%3Dcategory%2Cdiagrams=quae" \
    --header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"

Example response (200):


{
    "data": {
        "owner_id": "97b732b0-c169-11ee-aebe-edf182d16795",
        "organization_id": "983154f0-c169-11ee-a7f2-5794f7bb945b",
        "category_id": 390045,
        "business_process_id": 31705,
        "name": "maxime",
        "_lft": 1747651854,
        "_rgt": 1009143906,
        "summary": "Alice, 'a great girl like you,' (she might well say this), 'to go on till you come and join the dance. '\"What matters it how far we go?\" his scaly friend replied. \"There is another shore, you know.",
        "type": "process",
        "_key": null
    }
}
 

Request   

GET api/v2/public-business-process-models/{model}

Headers

Authorization      

Example: Bearer {OPENID_CONNECT_TOKEN}

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

URL Parameters

model   string   

Example: nam

Query Parameters

include=category,diagrams   string  optional  

Possible includes Example: quae

View Business Process Submission Form

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://base.stackflows.com/api/v2/public-business-process-models/01f68d00-40da-11ee-9df1-41abd31f433d/form',
    [
        'headers' => [
            'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/public-business-process-models/01f68d00-40da-11ee-9df1-41abd31f433d/form"
);

const headers = {
    "Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "https://base.stackflows.com/api/v2/public-business-process-models/01f68d00-40da-11ee-9df1-41abd31f433d/form" \
    --header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"

Example response (200):


{
    "data": [
        [],
        []
    ]
}
 

Example response (200):


{
  "data": {
    "some_string_property": {
      "attribute": {
        "reference": "some_string_property",
        "engine_reference": "someStringProperty",
        "type": "string",
        "label": "Some String Property",
      "value": "122",
    },
    "some_integer_property": {
      "attribute": {
        "reference": "some_integer_property",
        "engine_reference": "someIntegerProperty",
        "type": "integer",
        "label": "Some Integer Property",
      "value": 122,
    },
    "some_float_property": {
      "attribute": {
        "reference": "some_float_property",
        "engine_reference": "someFloatProperty",
        "type": "float",
        "label": "Some Float Property",
        "value": 122.0
    },
    "some_boolean_property": {
      "attribute": {
        "reference": "some_boolean_property",
        "engine_reference": "someBooleanProperty",
        "type": "boolean",
        "label": "Some Boolean Property",
        "value": true
    },
    "some_date_property": {
      "attribute": {
        "reference": "some_date_property",
        "engine_reference": "someDateProperty",
        "type": "date",
        "label": "Some Date Property",
        "value": "2035-01-01"
    },
    "some_date_time_property": {
      "attribute": {
        "reference": "some_date_time_property",
        "engine_reference": "someDateTimeProperty",
        "type": "date_time",
        "label": "Some Date Time Property",
        "value": "2035-01-01T00:00:00Z"
    },
  }
}
 

Request   

GET api/v2/public-business-process-models/{model_id}/form

Headers

Authorization      

Example: Bearer {OPENID_CONNECT_TOKEN}

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

URL Parameters

model_id   string   

The ID of the model. Example: 01f68d00-40da-11ee-9df1-41abd31f433d

Start Business Process

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://base.stackflows.com/api/v2/public-business-process-models/01f68d00-40da-11ee-9df1-41abd31f433d/start',
    [
        'headers' => [
            'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
        'json' => [
            'external_execution_reference' => 'quis',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/public-business-process-models/01f68d00-40da-11ee-9df1-41abd31f433d/start"
);

const headers = {
    "Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

let body = {
    "external_execution_reference": "quis"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request POST \
    "https://base.stackflows.com/api/v2/public-business-process-models/01f68d00-40da-11ee-9df1-41abd31f433d/start" \
    --header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx" \
    --data "{
    \"external_execution_reference\": \"quis\"
}"

Example response (200):


{
    "data": {
        "business_model_id": "9ba2a750-c169-11ee-961e-ddcc110492aa",
        "version": 500,
        "versions": [],
        "_key": null
    }
}
 

Request   

POST api/v2/public-business-process-models/{model_id}/start

Headers

Authorization      

Example: Bearer {OPENID_CONNECT_TOKEN}

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

URL Parameters

model_id   string   

The ID of the model. Example: 01f68d00-40da-11ee-9df1-41abd31f433d

Body Parameters

external_execution_reference   string  optional  

Example: quis

submission   string[]  optional  

Organization

Organization Units

List Organization Units

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://base.stackflows.com/api/v2/organization-units',
    [
        'headers' => [
            'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
        'query' => [
            'filter[root]=1'=> 'sint',
            'filter[trashed]=only'=> 'sint',
            'filter[search]=arb'=> 'rerum',
            'include=children'=> 'corporis',
            'include=organization'=> 'tempora',
            'include=business-models'=> 'ea',
            'include=members-count'=> '20',
            'include=models-count'=> '13',
            'include=business-models-count'=> '17',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/organization-units"
);

const params = {
    "filter[root]=1": "sint",
    "filter[trashed]=only": "sint",
    "filter[search]=arb": "rerum",
    "include=children": "corporis",
    "include=organization": "tempora",
    "include=business-models": "ea",
    "include=members-count": "20",
    "include=models-count": "13",
    "include=business-models-count": "17",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "https://base.stackflows.com/api/v2/organization-units?filter%5Broot%5D%3D1=sint&filter%5Btrashed%5D%3Donly=sint&filter%5Bsearch%5D%3Darb=rerum&include%3Dchildren=corporis&include%3Dorganization=tempora&include%3Dbusiness-models=ea&include%3Dmembers-count=20&include%3Dmodels-count=13&include%3Dbusiness-models-count=17" \
    --header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"

Example response (200):


{
    "data": [
        {
            "organization_id": "4918cfa0-c16a-11ee-b778-5bf1618c5a06",
            "name": {
                "en": "nulla"
            },
            "description": {
                "en": "Silence all round, if you could keep it to the Dormouse, after thinking a minute or two the Caterpillar angrily, rearing itself upright as it went. So she was as much as she could do to ask: perhaps."
            },
            "parent_id": "4a0c1ca0-c16a-11ee-b2db-31f820d6125a",
            "_key": null
        },
        {
            "organization_id": "4a0e2360-c16a-11ee-b5f4-f7e6db02471b",
            "name": {
                "en": "corporis"
            },
            "description": {
                "en": "Gryphon interrupted in a bit.' 'Perhaps it hasn't one,' Alice ventured to remark. 'Tut, tut, child!' said the cook. 'Treacle,' said a whiting to a mouse: she had a VERY unpleasant state of mind, she."
            },
            "parent_id": "4afb5650-c16a-11ee-a727-0d80ffcc86ea",
            "_key": null
        }
    ]
}
 

Request   

GET api/v2/organization-units

Headers

Authorization      

Example: Bearer {OPENID_CONNECT_TOKEN}

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

Query Parameters

filter[root]=1   string  optional  

Retrieve only root nodes Example: sint

filter[trashed]=only   string  optional  

Retrieve only trashed nodes Example: sint

filter[search]=arb   string  optional  

Retrieve only those organization units that contains model named with keyword Example: rerum

include=children   string  optional  

Include children Example: corporis

include=organization   string  optional  

Include organization Example: tempora

include=business-models   string  optional  

Include business models Example: ea

include=business-models.owner   string  optional  

Include business models owner Example: cum

include=business-models.latest-diagram.snapshot   string  optional  

Include business models latest diagram snapshot Example: sed

include=members-count   integer  optional  

Include members count Example: 20

include=models-count   integer  optional  

Include models count (deprecated) Example: 13

include=business-models-count   integer  optional  

Include business models count Example: 17

Create Organization Unit

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://base.stackflows.com/api/v2/organization-units',
    [
        'headers' => [
            'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
        'json' => [
            'name' => 'kjuluwdudgfuwsghbdbfenhapybgehdsemtzyfdrkxohmkyhsmqxr',
            'description' => 'Voluptatem nulla et quidem.',
            'parent_id' => 'adipisci',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/organization-units"
);

const headers = {
    "Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

let body = {
    "name": "kjuluwdudgfuwsghbdbfenhapybgehdsemtzyfdrkxohmkyhsmqxr",
    "description": "Voluptatem nulla et quidem.",
    "parent_id": "adipisci"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request POST \
    "https://base.stackflows.com/api/v2/organization-units" \
    --header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx" \
    --data "{
    \"name\": \"kjuluwdudgfuwsghbdbfenhapybgehdsemtzyfdrkxohmkyhsmqxr\",
    \"description\": \"Voluptatem nulla et quidem.\",
    \"parent_id\": \"adipisci\"
}"

Example response (200):


{
    "data": {
        "organization_id": "4b04e130-c16a-11ee-b8b3-2514889351d2",
        "name": {
            "en": "blanditiis"
        },
        "description": {
            "en": "Alice; 'I might as well say that \"I see what would happen next. The first witness was the only one who had been broken to pieces. 'Please, then,' said the last few minutes she heard the Rabbit."
        },
        "parent_id": "4bf66c60-c16a-11ee-bab2-256d98b7ded3",
        "_key": null
    }
}
 

Request   

POST api/v2/organization-units

Headers

Authorization      

Example: Bearer {OPENID_CONNECT_TOKEN}

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

Body Parameters

name   string   

Must be at least 3 characters. Example: kjuluwdudgfuwsghbdbfenhapybgehdsemtzyfdrkxohmkyhsmqxr

description   string  optional  

Example: Voluptatem nulla et quidem.

parent_id   string  optional  

Example: adipisci

View Organization Unit

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://base.stackflows.com/api/v2/organization-units/0243bf20-312c-11ee-88bb-8bf7d39fb7e1',
    [
        'headers' => [
            'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
        'query' => [
            'include=children'=> 'qui',
            'include=organization'=> 'maiores',
            'include=members-count'=> '12',
            'include=models-count'=> '15',
        ],
        'json' => [
            'user_ids' => [
                'nam',
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/organization-units/0243bf20-312c-11ee-88bb-8bf7d39fb7e1"
);

const params = {
    "include=children": "qui",
    "include=organization": "maiores",
    "include=members-count": "12",
    "include=models-count": "15",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

let body = {
    "user_ids": [
        "nam"
    ]
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request GET \
    --get "https://base.stackflows.com/api/v2/organization-units/0243bf20-312c-11ee-88bb-8bf7d39fb7e1?include%3Dchildren=qui&include%3Dorganization=maiores&include%3Dmembers-count=12&include%3Dmodels-count=15" \
    --header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx" \
    --data "{
    \"user_ids\": [
        \"nam\"
    ]
}"

Example response (200):


{
    "data": {
        "organization_id": "4bfe5690-c16a-11ee-aaf2-17da4c7e36bb",
        "name": {
            "en": "qui"
        },
        "description": {
            "en": "Alice looked at the great hall, with the Duchess, 'chop off her head!' about once in her life, and had just succeeded in bringing herself down to nine inches high. CHAPTER VI. Pig and Pepper For a."
        },
        "parent_id": "4cefa2a0-c16a-11ee-9240-27d28d65a931",
        "_key": null
    }
}
 

Request   

GET api/v2/organization-units/{id}

Headers

Authorization      

Example: Bearer {OPENID_CONNECT_TOKEN}

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

URL Parameters

id   string   

The ID of the organization unit. Example: 0243bf20-312c-11ee-88bb-8bf7d39fb7e1

Query Parameters

include=children   string  optional  

Include children Example: qui

include=organization   string  optional  

Include organization Example: maiores

include=members-count   integer  optional  

Include members count Example: 12

include=models-count   integer  optional  

Include models count Example: 15

Body Parameters

user_ids   string[]   

User IDs to override currently assigned ones.

Update Organization Unit

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->put(
    'https://base.stackflows.com/api/v2/organization-units/0243bf20-312c-11ee-88bb-8bf7d39fb7e1',
    [
        'headers' => [
            'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
        'json' => [
            'name' => 'uvwhiirugwwkotntweodhtcubjeztxhqnhppgejgthwetqkxbxajworhpgqbycxeyphmqnjtvkc',
            'description' => 'Placeat facere repellendus unde assumenda.',
            'user_ids' => [
                'veritatis',
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/organization-units/0243bf20-312c-11ee-88bb-8bf7d39fb7e1"
);

const headers = {
    "Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

let body = {
    "name": "uvwhiirugwwkotntweodhtcubjeztxhqnhppgejgthwetqkxbxajworhpgqbycxeyphmqnjtvkc",
    "description": "Placeat facere repellendus unde assumenda.",
    "user_ids": [
        "veritatis"
    ]
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request PUT \
    "https://base.stackflows.com/api/v2/organization-units/0243bf20-312c-11ee-88bb-8bf7d39fb7e1" \
    --header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx" \
    --data "{
    \"name\": \"uvwhiirugwwkotntweodhtcubjeztxhqnhppgejgthwetqkxbxajworhpgqbycxeyphmqnjtvkc\",
    \"description\": \"Placeat facere repellendus unde assumenda.\",
    \"user_ids\": [
        \"veritatis\"
    ]
}"

Example response (200):


{
    "data": {
        "organization_id": "4cf6fde0-c16a-11ee-9969-f7564ca739e9",
        "name": {
            "en": "error"
        },
        "description": {
            "en": "I'm mad. You're mad.' 'How do you know why it's called a whiting?' 'I never saw one, or heard of uglifying!' it exclaimed. 'You know what \"it\" means well enough, when I get SOMEWHERE,' Alice added."
        },
        "parent_id": "4df555a0-c16a-11ee-ae9f-970403924f2e",
        "_key": null
    }
}
 

Request   

PUT api/v2/organization-units/{id}

PATCH api/v2/organization-units/{id}

Headers

Authorization      

Example: Bearer {OPENID_CONNECT_TOKEN}

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

URL Parameters

id   string   

The ID of the organization unit. Example: 0243bf20-312c-11ee-88bb-8bf7d39fb7e1

Body Parameters

name   string  optional  

Must be at least 3 characters. Example: uvwhiirugwwkotntweodhtcubjeztxhqnhppgejgthwetqkxbxajworhpgqbycxeyphmqnjtvkc

description   string  optional  

Example: Placeat facere repellendus unde assumenda.

parent_id   string  optional  
user_ids   string[]  optional  

Delete Organization Unit

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'https://base.stackflows.com/api/v2/organization-units/0243bf20-312c-11ee-88bb-8bf7d39fb7e1',
    [
        'headers' => [
            'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/organization-units/0243bf20-312c-11ee-88bb-8bf7d39fb7e1"
);

const headers = {
    "Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
curl --request DELETE \
    "https://base.stackflows.com/api/v2/organization-units/0243bf20-312c-11ee-88bb-8bf7d39fb7e1" \
    --header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"

Example response (200):


{
    "data": {
        "organization_id": "4dfc7640-c16a-11ee-8b19-71b15f9dae1b",
        "name": {
            "en": "non"
        },
        "description": {
            "en": "Rabbit say to itself, half to herself, 'whenever I eat one of the thing yourself, some winter day, I will just explain to you to leave it behind?' She said the sage, as he came, 'Oh! the Duchess, as."
        },
        "parent_id": "4f23a8c0-c16a-11ee-ad20-9f52b743cf1d",
        "_key": null
    }
}
 

Request   

DELETE api/v2/organization-units/{id}

Headers

Authorization      

Example: Bearer {OPENID_CONNECT_TOKEN}

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

URL Parameters

id   string   

The ID of the organization unit. Example: 0243bf20-312c-11ee-88bb-8bf7d39fb7e1

Assign Users to Organization Unit

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->put(
    'https://base.stackflows.com/api/v2/organization-units/0243bf20-312c-11ee-88bb-8bf7d39fb7e1/assign',
    [
        'headers' => [
            'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
        'json' => [
            'ids' => [
                'ut',
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/organization-units/0243bf20-312c-11ee-88bb-8bf7d39fb7e1/assign"
);

const headers = {
    "Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

let body = {
    "ids": [
        "ut"
    ]
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request PUT \
    "https://base.stackflows.com/api/v2/organization-units/0243bf20-312c-11ee-88bb-8bf7d39fb7e1/assign" \
    --header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx" \
    --data "{
    \"ids\": [
        \"ut\"
    ]
}"

Example response (200):


{
    "data": {
        "organization_id": "4f2b51c0-c16a-11ee-abb8-0583f891a3a9",
        "name": {
            "en": "quia"
        },
        "description": {
            "en": "Canterbury, found it so yet,' said the Gryphon. 'Well, I never knew whether it was a little scream of laughter. 'Oh, hush!' the Rabbit say, 'A barrowful of WHAT?' thought Alice; 'but a grin without."
        },
        "parent_id": "502bf660-c16a-11ee-a756-857bfc2ed002",
        "_key": null
    }
}
 

Request   

PUT api/v2/organization-units/{organization_unit}/assign

Headers

Authorization      

Example: Bearer {OPENID_CONNECT_TOKEN}

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

URL Parameters

organization_unit   string   

Example: 0243bf20-312c-11ee-88bb-8bf7d39fb7e1

Body Parameters

ids   string[]  optional  

Unassign Users from Organization Unit

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->put(
    'https://base.stackflows.com/api/v2/organization-units/0243bf20-312c-11ee-88bb-8bf7d39fb7e1/unassign',
    [
        'headers' => [
            'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
        'json' => [
            'ids' => [
                'qui',
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/organization-units/0243bf20-312c-11ee-88bb-8bf7d39fb7e1/unassign"
);

const headers = {
    "Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

let body = {
    "ids": [
        "qui"
    ]
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request PUT \
    "https://base.stackflows.com/api/v2/organization-units/0243bf20-312c-11ee-88bb-8bf7d39fb7e1/unassign" \
    --header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx" \
    --data "{
    \"ids\": [
        \"qui\"
    ]
}"

Example response (200):


{
    "data": {
        "organization_id": "5033c940-c16a-11ee-a9fb-b93dbba5f041",
        "name": {
            "en": "nihil"
        },
        "description": {
            "en": "What would become of you? I gave her answer. 'They're done with a shiver. 'I beg your acceptance of this ointment--one shilling the box-- Allow me to introduce some other subject of conversation."
        },
        "parent_id": "512bba20-c16a-11ee-b600-69817a9e7f84",
        "_key": null
    }
}
 

Request   

PUT api/v2/organization-units/{organization_unit}/unassign

Headers

Authorization      

Example: Bearer {OPENID_CONNECT_TOKEN}

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

URL Parameters

organization_unit   string   

Example: 0243bf20-312c-11ee-88bb-8bf7d39fb7e1

Body Parameters

ids   string[]  optional  

Restore Organization Unit

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://base.stackflows.com/api/v2/organization-units/0243bf20-312c-11ee-88bb-8bf7d39fb7e1/restore',
    [
        'headers' => [
            'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/organization-units/0243bf20-312c-11ee-88bb-8bf7d39fb7e1/restore"
);

const headers = {
    "Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());
curl --request POST \
    "https://base.stackflows.com/api/v2/organization-units/0243bf20-312c-11ee-88bb-8bf7d39fb7e1/restore" \
    --header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"

Example response (200):


{
    "data": {
        "organization_id": "51376420-c16a-11ee-bba2-fb676d46db80",
        "name": {
            "en": "dicta"
        },
        "description": {
            "en": "Rome--no, THAT'S all wrong, I'm certain! I must have been was not going to shrink any further: she felt that it led into the book her sister on the ground as she could, and waited to see what was on."
        },
        "parent_id": "5237ba30-c16a-11ee-9b40-594d267a166b",
        "_key": null
    }
}
 

Request   

POST api/v2/organization-units/{organization_unit}/restore

Headers

Authorization      

Example: Bearer {OPENID_CONNECT_TOKEN}

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

URL Parameters

organization_unit   string   

Example: 0243bf20-312c-11ee-88bb-8bf7d39fb7e1

Billing

List Subscriptions

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://base.stackflows.com/api/v2/billing/subscriptions',
    [
        'headers' => [
            'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/billing/subscriptions"
);

const headers = {
    "Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "https://base.stackflows.com/api/v2/billing/subscriptions" \
    --header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"

Example response (200):


{
    "data": [
        {
            "id": "qui",
            "createdAt": null,
            "startAt": null,
            "currentPeriodEndAt": null,
            "latestInvoiceId": null,
            "status": "modi",
            "name": null
        },
        {
            "id": "minima",
            "createdAt": null,
            "startAt": null,
            "currentPeriodEndAt": null,
            "latestInvoiceId": null,
            "status": "et",
            "name": null
        }
    ]
}
 

Request   

GET api/v2/billing/subscriptions

Headers

Authorization      

Example: Bearer {OPENID_CONNECT_TOKEN}

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

List Payments

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://base.stackflows.com/api/v2/billing/payments',
    [
        'headers' => [
            'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/billing/payments"
);

const headers = {
    "Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "https://base.stackflows.com/api/v2/billing/payments" \
    --header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"

Example response (200):


{
    "data": [
        {
            "id": "deserunt",
            "amountPaid": null,
            "pdf": null,
            "paidAt": null,
            "status": "aspernatur",
            "subscriptionId": null,
            "total": 343428365
        },
        {
            "id": "a",
            "amountPaid": null,
            "pdf": null,
            "paidAt": null,
            "status": "alias",
            "subscriptionId": null,
            "total": 2644172
        }
    ]
}
 

Request   

GET api/v2/billing/payments

Headers

Authorization      

Example: Bearer {OPENID_CONNECT_TOKEN}

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

Installation

List Environments

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://base.stackflows.com/api/v2/environments',
    [
        'headers' => [
            'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/environments"
);

const headers = {
    "Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "https://base.stackflows.com/api/v2/environments" \
    --header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"

Example response (200):


{
    "data": [
        {
            "engine_id": "428a0500-c16a-11ee-88d2-9be6cf6dd0d2",
            "engine_reference": "ce087331-fd72-35bb-ba9f-1d0a8bcadb8d",
            "production": false,
            "name": "consequuntur",
            "auth_token": "8b880045-fc29-3925-be7f-9ad8dc40e3cb",
            "_key": null
        },
        {
            "engine_id": "430a5ef0-c16a-11ee-997b-0d2d901ade72",
            "engine_reference": "737610f9-7b15-3512-ab40-a97f66321b74",
            "production": true,
            "name": "optio",
            "auth_token": "eed93790-7379-3e85-ae77-30c3522d7ad9",
            "_key": null
        }
    ]
}
 

Request   

GET api/v2/environments

Headers

Authorization      

Example: Bearer {OPENID_CONNECT_TOKEN}

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

Create Environment

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://base.stackflows.com/api/v2/environments',
    [
        'headers' => [
            'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
        'json' => [
            'name' => 'libero',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/environments"
);

const headers = {
    "Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

let body = {
    "name": "libero"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request POST \
    "https://base.stackflows.com/api/v2/environments" \
    --header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx" \
    --data "{
    \"name\": \"libero\"
}"

Example response (200):


{
    "data": {
        "organization_id": "430fa290-c16a-11ee-ae6a-a9f5f65f76b7",
        "slug": "neque-enim-exercitationem-totam",
        "name": "voluptas",
        "description": "Mock Turtle's heavy sobs. Lastly, she pictured to herself 'It's the stupidest tea-party I ever saw one that size? Why, it fills the whole thing very absurd, but they were mine before. If I or she.",
        "_lft": 1849150049,
        "_rgt": 544918715,
        "parent_id": 394130,
        "prefix": ".",
        "_key": null
    }
}
 

Request   

POST api/v2/environments

Headers

Authorization      

Example: Bearer {OPENID_CONNECT_TOKEN}

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

Body Parameters

name   string   

Example: libero

Delete Environments

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'https://base.stackflows.com/api/v2/environments',
    [
        'headers' => [
            'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
        'json' => [
            'ids' => [
                'fugit',
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/environments"
);

const headers = {
    "Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

let body = {
    "ids": [
        "fugit"
    ]
};

fetch(url, {
    method: "DELETE",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request DELETE \
    "https://base.stackflows.com/api/v2/environments" \
    --header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx" \
    --data "{
    \"ids\": [
        \"fugit\"
    ]
}"

Example response (200):


{
    "data": [
        {
            "organization_id": "43fff260-c16a-11ee-8927-31934de3e50b",
            "slug": "et-sit-nisi-sed-repellat-quae-exercitationem",
            "name": "atque",
            "description": "The Gryphon sat up and ran off, thinking while she remembered that she might as well wait, as she leant against a buttercup to rest herself, and shouted out, 'You'd better not do that again!' which.",
            "_lft": 1419196541,
            "_rgt": 1809564431,
            "parent_id": 394155,
            "prefix": ".",
            "_key": null
        },
        {
            "organization_id": "44fed420-c16a-11ee-8821-9f5ee5b345c4",
            "slug": "voluptatem-quas-in-fugiat-adipisci-earum-optio-praesentium",
            "name": "cum",
            "description": "Alice said to herself; 'I should think it would be worth the trouble of getting her hands on her spectacles, and began by taking the little golden key, and unlocking the door opened inwards, and.",
            "_lft": 1812760603,
            "_rgt": 633582351,
            "parent_id": 394180,
            "prefix": ".",
            "_key": null
        }
    ]
}
 

Request   

DELETE api/v2/environments

Headers

Authorization      

Example: Bearer {OPENID_CONNECT_TOKEN}

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

Body Parameters

ids   string[]  optional  

IDs of records to be deleted.

List Engines

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://base.stackflows.com/api/v2/engines',
    [
        'headers' => [
            'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/engines"
);

const headers = {
    "Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "https://base.stackflows.com/api/v2/engines" \
    --header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"

Example response (200):


{
    "data": [
        {
            "name": "quidem",
            "bridge": "camunda",
            "_key": null
        },
        {
            "name": "sed",
            "bridge": "camunda",
            "_key": null
        }
    ]
}
 

Request   

GET api/v2/engines

Headers

Authorization      

Example: Bearer {OPENID_CONNECT_TOKEN}

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

Create Engine

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://base.stackflows.com/api/v2/engines',
    [
        'headers' => [
            'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
        'json' => [
            'name' => 'vknrwbuzjcslefba',
            'path' => 'lhcyrqbhjpowohpes',
            'auth' => 'ozal',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/engines"
);

const headers = {
    "Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

let body = {
    "name": "vknrwbuzjcslefba",
    "path": "lhcyrqbhjpowohpes",
    "auth": "ozal"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request POST \
    "https://base.stackflows.com/api/v2/engines" \
    --header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx" \
    --data "{
    \"name\": \"vknrwbuzjcslefba\",
    \"path\": \"lhcyrqbhjpowohpes\",
    \"auth\": \"ozal\"
}"

Example response (200):


{
    "data": {
        "name": "placeat",
        "bridge": "camunda",
        "_key": null
    }
}
 

Request   

POST api/v2/engines

Headers

Authorization      

Example: Bearer {OPENID_CONNECT_TOKEN}

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

Body Parameters

environment_id   string  optional  
name   string   

Must not be greater than 255 characters. Example: vknrwbuzjcslefba

path   string   

Must not be greater than 255 characters. Example: lhcyrqbhjpowohpes

auth   string   

Must not be greater than 255 characters. Example: ozal

View Engine

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://base.stackflows.com/api/v2/engines/unde',
    [
        'headers' => [
            'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/engines/unde"
);

const headers = {
    "Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "https://base.stackflows.com/api/v2/engines/unde" \
    --header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"

Example response (200):


{
    "data": {
        "name": "et",
        "bridge": "camunda",
        "_key": null
    }
}
 

Request   

GET api/v2/engines/{id}

Headers

Authorization      

Example: Bearer {OPENID_CONNECT_TOKEN}

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

URL Parameters

id   string   

The ID of the engine. Example: unde

Update Engine

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->put(
    'https://base.stackflows.com/api/v2/engines/minima',
    [
        'headers' => [
            'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
        'json' => [
            'name' => 'qryqfqqztzzcl',
            'path' => 'nkliukxyvirzqyiaq',
            'auth' => 'etc',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/engines/minima"
);

const headers = {
    "Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

let body = {
    "name": "qryqfqqztzzcl",
    "path": "nkliukxyvirzqyiaq",
    "auth": "etc"
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request PUT \
    "https://base.stackflows.com/api/v2/engines/minima" \
    --header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx" \
    --data "{
    \"name\": \"qryqfqqztzzcl\",
    \"path\": \"nkliukxyvirzqyiaq\",
    \"auth\": \"etc\"
}"

Example response (200):


{
    "data": {
        "name": "optio",
        "bridge": "camunda",
        "_key": null
    }
}
 

Request   

PUT api/v2/engines/{id}

PATCH api/v2/engines/{id}

Headers

Authorization      

Example: Bearer {OPENID_CONNECT_TOKEN}

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

URL Parameters

id   string   

The ID of the engine. Example: minima

engine   string   

ID of an engine Example: et

Body Parameters

environment_id   string  optional  
name   string  optional  

Must not be greater than 255 characters. Example: qryqfqqztzzcl

path   string  optional  

Must not be greater than 255 characters. Example: nkliukxyvirzqyiaq

auth   string  optional  

Must not be greater than 255 characters. Example: etc

Delete Engine

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'https://base.stackflows.com/api/v2/engines/consequatur',
    [
        'headers' => [
            'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/engines/consequatur"
);

const headers = {
    "Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
curl --request DELETE \
    "https://base.stackflows.com/api/v2/engines/consequatur" \
    --header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"

Example response (200):


{
    "data": {
        "name": "ut",
        "bridge": "camunda",
        "_key": null
    }
}
 

Request   

DELETE api/v2/engines/{id}

Headers

Authorization      

Example: Bearer {OPENID_CONNECT_TOKEN}

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

URL Parameters

id   string   

The ID of the engine. Example: consequatur

Classification

List Categories

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://base.stackflows.com/api/v2/categories',
    [
        'headers' => [
            'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
        'query' => [
            'filter[root]'=> '1',
            'filter[siblings]'=> '145',
            'filter[autocomplete]'=> 'tes',
            'filter[search]'=> 'tes',
            'include'=> 'children,business-models,business-models-count,business-models.comments-count,business-models.owner,business-models.latest-diagram',
            'filter[search-business-models]'=> 'Some model',
            'filter[organization-units][0]'=> 'optio',
            'sort'=> 'name,-created_at,-updated_at Sorting example',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/categories"
);

const params = {
    "filter[root]": "1",
    "filter[siblings]": "145",
    "filter[autocomplete]": "tes",
    "filter[search]": "tes",
    "include": "children,business-models,business-models-count,business-models.comments-count,business-models.owner,business-models.latest-diagram",
    "filter[search-business-models]": "Some model",
    "filter[organization-units][0]": "optio",
    "sort": "name,-created_at,-updated_at Sorting example",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "https://base.stackflows.com/api/v2/categories?filter%5Broot%5D=1&filter%5Bsiblings%5D=145&filter%5Bautocomplete%5D=tes&filter%5Bsearch%5D=tes&include=children%2Cbusiness-models%2Cbusiness-models-count%2Cbusiness-models.comments-count%2Cbusiness-models.owner%2Cbusiness-models.latest-diagram&filter%5Bsearch-business-models%5D=Some+model&filter%5Borganization-units%5D[]=optio&sort=name%2C-created_at%2C-updated_at+Sorting+example" \
    --header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"

Example response (200):


{
    "data": [
        {
            "organization_id": "f70267d0-c169-11ee-ae8b-6547b56b87d3",
            "slug": "expedita-expedita-libero-sunt-tempora-sapiente",
            "name": "et",
            "description": "And in she went. Once more she found that her neck would bend about easily in any direction, like a snout than a real nose; also its eyes by this time, and was just beginning to see the Mock Turtle.",
            "_lft": 649327519,
            "_rgt": 1891635682,
            "parent_id": 392322,
            "prefix": ".",
            "_key": null
        },
        {
            "organization_id": "f7e1c670-c169-11ee-8cb5-4f74a80fe282",
            "slug": "amet-consequatur-ut-iste-aperiam",
            "name": "est",
            "description": "Alice's first thought was that you had been anxiously looking across the garden, and marked, with one finger, as he fumbled over the verses to himself: '\"WE KNOW IT TO BE TRUE--\" that's the jury.",
            "_lft": 584296302,
            "_rgt": 887632511,
            "parent_id": 392347,
            "prefix": ".",
            "_key": null
        }
    ]
}
 

Request   

GET api/v2/categories

Headers

Authorization      

Example: Bearer {OPENID_CONNECT_TOKEN}

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

Query Parameters

filter[root]   boolean  optional  

Use combination with include=children for full tree list. Example: true

filter[siblings]   integer  optional  

ID of a category which siblings should be retrieved. Example: 145

filter[autocomplete]   string  optional  

Autocomplete. Example: tes

filter[search]   string  optional  

Search. Example: tes

fields[business-process.latest-diagram]   string  optional  

Include fields from the latest release record. Example: snapshot

include   string  optional  

Includes relations. Example: children,business-models,business-models-count,business-models.comments-count,business-models.owner,business-models.latest-diagram

filter[search-business-models]   string  optional  

Search categories that has models based on specified keyword. Example: Some model

filter[organization-units]   string[]  optional  

List of organization units ids to retrieve related items.

sort   string  optional  

Sort by specific field. Example: name,-created_at,-updated_at Sorting example

Create Category

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://base.stackflows.com/api/v2/categories',
    [
        'headers' => [
            'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
        'json' => [
            'name' => 'btvmhkmmzusjhzxohuytenlstqwwoghlozsujpgbhlrmgynakcrigmzrolcgosjvjsghcsdoblesda',
            'description' => 'Porro corrupti aut sint debitis sed.',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/categories"
);

const headers = {
    "Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

let body = {
    "name": "btvmhkmmzusjhzxohuytenlstqwwoghlozsujpgbhlrmgynakcrigmzrolcgosjvjsghcsdoblesda",
    "description": "Porro corrupti aut sint debitis sed."
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request POST \
    "https://base.stackflows.com/api/v2/categories" \
    --header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx" \
    --data "{
    \"name\": \"btvmhkmmzusjhzxohuytenlstqwwoghlozsujpgbhlrmgynakcrigmzrolcgosjvjsghcsdoblesda\",
    \"description\": \"Porro corrupti aut sint debitis sed.\"
}"

Example response (200):


{
    "data": {
        "organization_id": "f8df5930-c169-11ee-9399-e777e45e9f04",
        "slug": "sunt-placeat-ut-natus-omnis-vel-veniam-ipsa",
        "name": "mollitia",
        "description": "Duchess sneezed occasionally; and as Alice could not be denied, so she went on, 'What's your name, child?' 'My name is Alice, so please your Majesty,' said Alice desperately: 'he's perfectly.",
        "_lft": 476949212,
        "_rgt": 305780223,
        "parent_id": 392372,
        "prefix": ".",
        "_key": null
    }
}
 

Request   

POST api/v2/categories

Headers

Authorization      

Example: Bearer {OPENID_CONNECT_TOKEN}

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

Body Parameters

name   string   

Must be at least 3 characters. Example: btvmhkmmzusjhzxohuytenlstqwwoghlozsujpgbhlrmgynakcrigmzrolcgosjvjsghcsdoblesda

description   string  optional  

Example: Porro corrupti aut sint debitis sed.

parent_id   string  optional  

View Category

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://base.stackflows.com/api/v2/categories/59',
    [
        'headers' => [
            'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/categories/59"
);

const headers = {
    "Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "https://base.stackflows.com/api/v2/categories/59" \
    --header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"

Example response (200):


{
    "data": {
        "organization_id": "f9c12c40-c169-11ee-9b52-d94b0fbf56e2",
        "slug": "est-nisi-numquam-dolor-qui-sed-voluptatum-officia",
        "name": "nostrum",
        "description": "I don't care which happens!' She ate a little shaking among the people near the right size again; and the blades of grass, but she felt unhappy. 'It was the White Rabbit, 'and that's the queerest.",
        "_lft": 1172836414,
        "_rgt": 1462194827,
        "parent_id": 392397,
        "prefix": ".",
        "_key": null
    }
}
 

Request   

GET api/v2/categories/{id}

Headers

Authorization      

Example: Bearer {OPENID_CONNECT_TOKEN}

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

URL Parameters

id   integer   

The ID of the category. Example: 59

Update Category

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->put(
    'https://base.stackflows.com/api/v2/categories/59',
    [
        'headers' => [
            'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
        'json' => [
            'name' => 'lqndbjrbqibzghdsxufqiujjunjnscqrqnntbnnmzftovezyskrfjldsrljvekkloalmurodxkr',
            'description' => 'Ex excepturi quis quia iure explicabo suscipit.',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/categories/59"
);

const headers = {
    "Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

let body = {
    "name": "lqndbjrbqibzghdsxufqiujjunjnscqrqnntbnnmzftovezyskrfjldsrljvekkloalmurodxkr",
    "description": "Ex excepturi quis quia iure explicabo suscipit."
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request PUT \
    "https://base.stackflows.com/api/v2/categories/59" \
    --header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx" \
    --data "{
    \"name\": \"lqndbjrbqibzghdsxufqiujjunjnscqrqnntbnnmzftovezyskrfjldsrljvekkloalmurodxkr\",
    \"description\": \"Ex excepturi quis quia iure explicabo suscipit.\"
}"

Example response (200):


{
    "data": {
        "organization_id": "faa80100-c169-11ee-9ac6-43e91805d9e5",
        "slug": "odit-cupiditate-nostrum-nihil-enim-ratione",
        "name": "et",
        "description": "Bill,' she gave her one, they gave him two, You gave us three or more; They all made of solid glass; there was not easy to take out of their wits!' So she went on growing, and growing, and she could.",
        "_lft": 999058261,
        "_rgt": 1571223090,
        "parent_id": 392422,
        "prefix": ".",
        "_key": null
    }
}
 

Request   

PUT api/v2/categories/{id}

PATCH api/v2/categories/{id}

Headers

Authorization      

Example: Bearer {OPENID_CONNECT_TOKEN}

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

URL Parameters

id   integer   

The ID of the category. Example: 59

Body Parameters

name   string  optional  

Must be at least 3 characters. Example: lqndbjrbqibzghdsxufqiujjunjnscqrqnntbnnmzftovezyskrfjldsrljvekkloalmurodxkr

description   string  optional  

Example: Ex excepturi quis quia iure explicabo suscipit.

parent_id   string  optional  

Delete Category

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'https://base.stackflows.com/api/v2/categories/59',
    [
        'headers' => [
            'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/categories/59"
);

const headers = {
    "Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
curl --request DELETE \
    "https://base.stackflows.com/api/v2/categories/59" \
    --header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"

Example response (200):


{
    "data": {
        "organization_id": "fb91f960-c169-11ee-9d03-070edab07521",
        "slug": "et-ullam-quaerat-consequatur-dolorem-assumenda",
        "name": "totam",
        "description": "They were indeed a queer-looking party that assembled on the twelfth?' Alice went on, half to itself, 'Oh dear! Oh dear! I'd nearly forgotten to ask.' 'It turned into a line along the course, here.",
        "_lft": 1300978262,
        "_rgt": 473905996,
        "parent_id": 392447,
        "prefix": ".",
        "_key": null
    }
}
 

Request   

DELETE api/v2/categories/{id}

Headers

Authorization      

Example: Bearer {OPENID_CONNECT_TOKEN}

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

URL Parameters

id   integer   

The ID of the category. Example: 59

List Tags

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://base.stackflows.com/api/v2/tags',
    [
        'headers' => [
            'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/tags"
);

const headers = {
    "Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "https://base.stackflows.com/api/v2/tags" \
    --header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"

Example response (200):


{
    "data": [
        {
            "name": {
                "en": "occaecati"
            },
            "_key": null
        },
        {
            "name": {
                "en": "dolores"
            },
            "_key": null
        }
    ]
}
 

Request   

GET api/v2/tags

Headers

Authorization      

Example: Bearer {OPENID_CONNECT_TOKEN}

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

Create Tag

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://base.stackflows.com/api/v2/tags',
    [
        'headers' => [
            'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
        'json' => [
            'name' => 'sequi',
            'description' => 'Minima repellat alias quis vero at.',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/tags"
);

const headers = {
    "Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

let body = {
    "name": "sequi",
    "description": "Minima repellat alias quis vero at."
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request POST \
    "https://base.stackflows.com/api/v2/tags" \
    --header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx" \
    --data "{
    \"name\": \"sequi\",
    \"description\": \"Minima repellat alias quis vero at.\"
}"

Example response (200):


{
    "data": {
        "name": {
            "en": "nemo"
        },
        "_key": null
    }
}
 

Request   

POST api/v2/tags

Headers

Authorization      

Example: Bearer {OPENID_CONNECT_TOKEN}

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

Body Parameters

name   string   

Example: sequi

description   string  optional  

Example: Minima repellat alias quis vero at.

process_model_ids   object  optional  

View Tag

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://base.stackflows.com/api/v2/tags/15',
    [
        'headers' => [
            'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/tags/15"
);

const headers = {
    "Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "https://base.stackflows.com/api/v2/tags/15" \
    --header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"

Example response (200):


{
    "data": {
        "name": {
            "en": "fuga"
        },
        "_key": null
    }
}
 

Request   

GET api/v2/tags/{id}

Headers

Authorization      

Example: Bearer {OPENID_CONNECT_TOKEN}

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

URL Parameters

id   integer   

The ID of the tag. Example: 15

Update Tag

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->put(
    'https://base.stackflows.com/api/v2/tags/15',
    [
        'headers' => [
            'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
        'json' => [
            'name' => 'rerum',
            'description' => 'Minus quaerat nemo dolorum ut.',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/tags/15"
);

const headers = {
    "Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

let body = {
    "name": "rerum",
    "description": "Minus quaerat nemo dolorum ut."
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request PUT \
    "https://base.stackflows.com/api/v2/tags/15" \
    --header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx" \
    --data "{
    \"name\": \"rerum\",
    \"description\": \"Minus quaerat nemo dolorum ut.\"
}"

Example response (200):


{
    "data": {
        "name": {
            "en": "voluptas"
        },
        "_key": null
    }
}
 

Request   

PUT api/v2/tags/{id}

PATCH api/v2/tags/{id}

Headers

Authorization      

Example: Bearer {OPENID_CONNECT_TOKEN}

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

URL Parameters

id   integer   

The ID of the tag. Example: 15

Body Parameters

name   string   

Example: rerum

description   string  optional  

Example: Minus quaerat nemo dolorum ut.

process_model_ids   object  optional  

Delete Tag

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'https://base.stackflows.com/api/v2/tags/15',
    [
        'headers' => [
            'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/tags/15"
);

const headers = {
    "Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
curl --request DELETE \
    "https://base.stackflows.com/api/v2/tags/15" \
    --header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"

Example response (200):


{
    "data": {
        "name": {
            "en": "sequi"
        },
        "_key": null
    }
}
 

Request   

DELETE api/v2/tags/{id}

Headers

Authorization      

Example: Bearer {OPENID_CONNECT_TOKEN}

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

URL Parameters

id   integer   

The ID of the tag. Example: 15

Collaboration

View Share

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://base.stackflows.com/api/v2/decrypt/00fe9330-9cfa-11ed-ad91-97af7d471a7e',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/decrypt/00fe9330-9cfa-11ed-ad91-97af7d471a7e"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "https://base.stackflows.com/api/v2/decrypt/00fe9330-9cfa-11ed-ad91-97af7d471a7e" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"

Example response (200):


{
    "data": {
        "owner_id": "fc80bd10-c169-11ee-b427-fb19d4c94ba8",
        "organization_id": "fcef5880-c169-11ee-843f-3b1520c56310",
        "category_id": 392497,
        "business_process_id": 32140,
        "name": "fugit",
        "_lft": 1933048385,
        "_rgt": 624469727,
        "summary": "King said, turning to Alice, she went nearer to watch them, and considered a little, half expecting to see what would be the use of a well--' 'What did they live at the top of its voice. 'Back to.",
        "type": "process",
        "_key": null
    }
}
 

Request   

GET api/v2/decrypt/{share_id}

Headers

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

URL Parameters

share_id   string   

The ID of the share. Example: 00fe9330-9cfa-11ed-ad91-97af7d471a7e

View Member Invitation

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://base.stackflows.com/api/v2/invitations/0002f8e0-a090-11ed-85cb-c7881bdeb8dd',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/invitations/0002f8e0-a090-11ed-85cb-c7881bdeb8dd"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "https://base.stackflows.com/api/v2/invitations/0002f8e0-a090-11ed-85cb-c7881bdeb8dd" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"

Example response (200):


{
    "data": {
        "organization_id": "fe635380-c169-11ee-acc2-b162fc812209",
        "email": "nmetz@example.org",
        "type": {},
        "context": null,
        "user_id": "fedd1760-c169-11ee-afc9-a53d3589ae2f",
        "expired_at": "2005-03-27T02:36:54.000000Z",
        "active": false,
        "_key": null
    }
}
 

Request   

GET api/v2/invitations/{id}

Headers

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

URL Parameters

id   string   

The ID of the invitation. Example: 0002f8e0-a090-11ed-85cb-c7881bdeb8dd

Delete Member Invitation

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'https://base.stackflows.com/api/v2/invitations/0002f8e0-a090-11ed-85cb-c7881bdeb8dd',
    [
        'headers' => [
            'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/invitations/0002f8e0-a090-11ed-85cb-c7881bdeb8dd"
);

const headers = {
    "Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
curl --request DELETE \
    "https://base.stackflows.com/api/v2/invitations/0002f8e0-a090-11ed-85cb-c7881bdeb8dd" \
    --header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"

Example response (200):


{
    "data": {
        "organization_id": "ff515040-c169-11ee-b34c-cb2d2019ebe9",
        "email": "dexter15@example.net",
        "type": {},
        "context": null,
        "user_id": "ffc4c4a0-c169-11ee-bcf1-9f51f3055c75",
        "expired_at": "2020-01-26T11:40:28.000000Z",
        "active": false,
        "_key": null
    }
}
 

Request   

DELETE api/v2/invitations/{invitation_id}

Headers

Authorization      

Example: Bearer {OPENID_CONNECT_TOKEN}

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

URL Parameters

invitation_id   string   

The ID of the invitation. Example: 0002f8e0-a090-11ed-85cb-c7881bdeb8dd

Accept Member Invitation

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://base.stackflows.com/api/v2/invitations/0002f8e0-a090-11ed-85cb-c7881bdeb8dd/accept',
    [
        'headers' => [
            'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/invitations/0002f8e0-a090-11ed-85cb-c7881bdeb8dd/accept"
);

const headers = {
    "Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());
curl --request POST \
    "https://base.stackflows.com/api/v2/invitations/0002f8e0-a090-11ed-85cb-c7881bdeb8dd/accept" \
    --header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"

Example response (200):


{
    "data": {
        "organization_id": "003b5d90-c16a-11ee-a85c-4dac33f377c6",
        "email": "clemens41@example.org",
        "type": {},
        "context": null,
        "user_id": "00b68680-c16a-11ee-a8ec-83ea5ccd92ea",
        "expired_at": "1970-10-04T15:20:35.000000Z",
        "active": false,
        "_key": null
    }
}
 

Request   

POST api/v2/invitations/{invitation_id}/accept

Headers

Authorization      

Example: Bearer {OPENID_CONNECT_TOKEN}

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

URL Parameters

invitation_id   string   

The ID of the invitation. Example: 0002f8e0-a090-11ed-85cb-c7881bdeb8dd

Delete Share

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'https://base.stackflows.com/api/v2/unshare/00fe9330-9cfa-11ed-ad91-97af7d471a7e',
    [
        'headers' => [
            'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/unshare/00fe9330-9cfa-11ed-ad91-97af7d471a7e"
);

const headers = {
    "Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
curl --request DELETE \
    "https://base.stackflows.com/api/v2/unshare/00fe9330-9cfa-11ed-ad91-97af7d471a7e" \
    --header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"

Example response (200):


{
    "data": {
        "owner_id": "013cdb60-c16a-11ee-ba95-7ba41190bd47",
        "organization_id": "01ac6b60-c16a-11ee-8729-ffa2d46e196d",
        "category_id": 392619,
        "business_process_id": 32161,
        "name": "est",
        "_lft": 99258749,
        "_rgt": 712647196,
        "summary": "It sounded an excellent opportunity for showing off her head!' Alice glanced rather anxiously at the great puzzle!' And she thought at first was in the last few minutes that she was saying, and the.",
        "type": "process",
        "_key": null
    }
}
 

Request   

DELETE api/v2/unshare/{share_id}

Headers

Authorization      

Example: Bearer {OPENID_CONNECT_TOKEN}

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

URL Parameters

share_id   string   

The ID of the share. Example: 00fe9330-9cfa-11ed-ad91-97af7d471a7e

List Invitations

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://base.stackflows.com/api/v2/invitations',
    [
        'headers' => [
            'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
        'query' => [
            'filter[active]'=> '1',
            'filter[accepted]'=> '1',
            'filter[expired]'=> '1',
            'filter[search]'=> 'lorem',
            'sort'=> '-created_at',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/invitations"
);

const params = {
    "filter[active]": "1",
    "filter[accepted]": "1",
    "filter[expired]": "1",
    "filter[search]": "lorem",
    "sort": "-created_at",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "https://base.stackflows.com/api/v2/invitations?filter%5Bactive%5D=1&filter%5Baccepted%5D=1&filter%5Bexpired%5D=1&filter%5Bsearch%5D=lorem&sort=-created_at" \
    --header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"

Example response (200):


{
    "data": [
        {
            "organization_id": "030061c0-c16a-11ee-9969-b3c97b3beac9",
            "email": "unader@example.net",
            "type": {},
            "context": null,
            "user_id": "0375a8b0-c16a-11ee-8ad9-d73952e1d846",
            "expired_at": "2016-03-01T09:58:01.000000Z",
            "active": false,
            "_key": null
        },
        {
            "organization_id": "03e5fb90-c16a-11ee-ac9a-c1e54f4a1a0c",
            "email": "mraz.garret@example.org",
            "type": {},
            "context": null,
            "user_id": "045fdeb0-c16a-11ee-9e8e-fd06879a8692",
            "expired_at": "1994-05-15T09:13:33.000000Z",
            "active": false,
            "_key": null
        }
    ]
}
 

Request   

GET api/v2/invitations

Headers

Authorization      

Example: Bearer {OPENID_CONNECT_TOKEN}

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

Query Parameters

filter[active]   boolean  optional  

List only active tasks. Example: true

filter[accepted]   boolean  optional  

List only accepted tasks. Example: true

filter[expired]   boolean  optional  

List only expired tasks. Example: true

filter[search]   string  optional  

List invitations by keyword. Example: lorem

sort   string  optional  

Sort order. Example: -created_at

Invite Members

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://base.stackflows.com/api/v2/invitations',
    [
        'headers' => [
            'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
        'json' => [
            'emails' => [
                'jose57@example.com',
            ],
            'type' => 'generic',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/invitations"
);

const headers = {
    "Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

let body = {
    "emails": [
        "jose57@example.com"
    ],
    "type": "generic"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request POST \
    "https://base.stackflows.com/api/v2/invitations" \
    --header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx" \
    --data "{
    \"emails\": [
        \"jose57@example.com\"
    ],
    \"type\": \"generic\"
}"

Example response (200):


{
    "data": [
        {
            "organization_id": "04da6be0-c16a-11ee-9d50-afbe76725396",
            "email": "dare.kris@example.com",
            "type": {},
            "context": null,
            "user_id": "0555fbb0-c16a-11ee-ae3f-6b208a1b2442",
            "expired_at": "2009-09-25T10:44:04.000000Z",
            "active": false,
            "_key": null
        },
        {
            "organization_id": "05d6a550-c16a-11ee-9f9b-713704c7de7e",
            "email": "gardner.beer@example.com",
            "type": {},
            "context": null,
            "user_id": "065b0ff0-c16a-11ee-81a3-3dfd646e76ce",
            "expired_at": "2010-04-27T08:34:39.000000Z",
            "active": false,
            "_key": null
        }
    ]
}
 

Request   

POST api/v2/invitations

Headers

Authorization      

Example: Bearer {OPENID_CONNECT_TOKEN}

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

Body Parameters

emails   string[]   

Must be a valid email address.

type   string  optional  

Must be one of generic. Example: generic

context   object  optional  
parent_id   string  optional  

Business Models

List Business Models

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://base.stackflows.com/api/v2/business-models',
    [
        'headers' => [
            'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
        'query' => [
            'include'=> 'owner,company,category,tags,comments-count,tags-count,diagrams',
            'filter[with-any-tags]'=> 'test-tag,another-test-tag',
            'filter[without-any-tags]'=> '1',
            'filter[autocomplete]'=> 'tes',
            'filter[search]'=> 'tes',
            'filter[categories]'=> '1,2',
            'filter[type]'=> 'eos',
            'filter[uncategorized]'=> '1',
            'filter[subscribable]'=> '1',
            'filter[manual]'=> '1',
            'filter[organization-units][0]'=> 'assumenda',
            'filter[without-any-organization-units]'=> '1',
            'filter[production]'=> '1',
            'sort'=> 'name,-created_at,-updated_at',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/business-models"
);

const params = {
    "include": "owner,company,category,tags,comments-count,tags-count,diagrams",
    "filter[with-any-tags]": "test-tag,another-test-tag",
    "filter[without-any-tags]": "1",
    "filter[autocomplete]": "tes",
    "filter[search]": "tes",
    "filter[categories]": "1,2",
    "filter[type]": "eos",
    "filter[uncategorized]": "1",
    "filter[subscribable]": "1",
    "filter[manual]": "1",
    "filter[organization-units][0]": "assumenda",
    "filter[without-any-organization-units]": "1",
    "filter[production]": "1",
    "sort": "name,-created_at,-updated_at",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "https://base.stackflows.com/api/v2/business-models?include=owner%2Ccompany%2Ccategory%2Ctags%2Ccomments-count%2Ctags-count%2Cdiagrams&filter%5Bwith-any-tags%5D=test-tag%2Canother-test-tag&filter%5Bwithout-any-tags%5D=1&filter%5Bautocomplete%5D=tes&filter%5Bsearch%5D=tes&filter%5Bcategories%5D=1%2C2&filter%5Btype%5D=eos&filter%5Buncategorized%5D=1&filter%5Bsubscribable%5D=1&filter%5Bmanual%5D=1&filter%5Borganization-units%5D[]=assumenda&filter%5Bwithout-any-organization-units%5D=1&filter%5Bproduction%5D=1&sort=name%2C-created_at%2C-updated_at" \
    --header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"

Example response (200):


{
    "data": [
        {
            "owner_id": "9bbca9e0-c169-11ee-8a7f-d1724d7e6846",
            "organization_id": "9c370920-c169-11ee-8bf4-4fb13c07d927",
            "category_id": 390145,
            "business_process_id": 31723,
            "name": "accusamus",
            "_lft": 1113828305,
            "_rgt": 1828288328,
            "summary": "All on a three-legged stool in the schoolroom, and though this was not quite like the three gardeners, oblong and flat, with their heads down! I am now? That'll be a queer thing, to be almost out of.",
            "type": "process",
            "_key": null
        },
        {
            "owner_id": "9d9e34f0-c169-11ee-bcf8-f981a728b7d8",
            "organization_id": "9e136100-c169-11ee-b78c-3b10d661b0e2",
            "category_id": 390195,
            "business_process_id": 31732,
            "name": "possimus",
            "_lft": 1514326361,
            "_rgt": 1278883080,
            "summary": "Alice. 'Reeling and Writhing, of course, I meant,' the King said to herself, 'whenever I eat or drink under the sea--' ('I haven't,' said Alice)--'and perhaps you haven't found it made Alice quite.",
            "type": "process",
            "_key": null
        }
    ]
}
 

Request   

GET api/v2/business-models

Headers

Authorization      

Example: Bearer {OPENID_CONNECT_TOKEN}

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

Query Parameters

include   string  optional  

Possible includes. Example: owner,company,category,tags,comments-count,tags-count,diagrams

filter[with-any-tags]   string  optional  

Will return models that has any of specified tags. Example: test-tag,another-test-tag

filter[without-any-tags]   boolean  optional  

Will return list of all models that has no tags at all. Example: true

filter[autocomplete]   string  optional  

Retrieve list that has "tes" at the start of their name. Example: tes

filter[search]   string  optional  

Retrieve list that has "tes" in their name. Example: tes

filter[categories]   string  optional  

Filter by specific categories. Example: 1,2

filter[type]   string  optional  

Filter by specific type. Example process,decision Example: eos

filter[uncategorized]   boolean  optional  

List only uncategorized process models. Example: true

filter[subscribable]   boolean  optional  

List only subscribable process models. Example: true

filter[manual]   boolean  optional  

List manually triggered models. Example: true

filter[organization-units]   string[]  optional  

List of organization units ids to retrieve related items.

filter[without-any-organization-units]   boolean  optional  

If true business models without any organization units will be listed. Example: true

filter[production]   boolean  optional  

List only production ready process models. Example: true

sort   string  optional  

Sorting by specified criteria. Example: name,-created_at,-updated_at

Create Business Model

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://base.stackflows.com/api/v2/business-models',
    [
        'headers' => [
            'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
        'json' => [
            'name' => 'jfscfjp',
            'type' => 'process',
            'summary' => 'deleniti',
            'organization_unit_ids' => [
                'omnis',
            ],
            'tag_values' => [
                'quae',
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/business-models"
);

const headers = {
    "Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

let body = {
    "name": "jfscfjp",
    "type": "process",
    "summary": "deleniti",
    "organization_unit_ids": [
        "omnis"
    ],
    "tag_values": [
        "quae"
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request POST \
    "https://base.stackflows.com/api/v2/business-models" \
    --header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx" \
    --data "{
    \"name\": \"jfscfjp\",
    \"type\": \"process\",
    \"summary\": \"deleniti\",
    \"organization_unit_ids\": [
        \"omnis\"
    ],
    \"tag_values\": [
        \"quae\"
    ]
}"

Example response (200):


{
    "data": {
        "owner_id": "9fa59920-c169-11ee-99bd-bb702690efb8",
        "organization_id": "a0122b00-c169-11ee-89bb-1354f994fff7",
        "category_id": 390245,
        "business_process_id": 31741,
        "name": "commodi",
        "_lft": 983784227,
        "_rgt": 1463907613,
        "summary": "Alice was rather doubtful whether she ought not to be patted on the OUTSIDE.' He unfolded the paper as he spoke, and the Queen in a moment: she looked back once or twice, and shook itself. Then it.",
        "type": "process",
        "_key": null
    }
}
 

Request   

POST api/v2/business-models

Headers

Authorization      

Example: Bearer {OPENID_CONNECT_TOKEN}

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

Body Parameters

name   string   

Must be at least 3 characters. Example: jfscfjp

type   string   

Must be one of process or decision. Example: process

summary   string  optional  

Example: deleniti

category_id   string  optional  
organization_unit_ids   string[]  optional  
tag_values   string[]  optional  

View Business Model

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://base.stackflows.com/api/v2/business-models/eveniet',
    [
        'headers' => [
            'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
        'query' => [
            'include=owner,organization,category,tags,comments-count,tags-count,diagrams'=> 'iure',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/business-models/eveniet"
);

const params = {
    "include=owner,organization,category,tags,comments-count,tags-count,diagrams": "iure",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "https://base.stackflows.com/api/v2/business-models/eveniet?include%3Downer%2Corganization%2Ccategory%2Ctags%2Ccomments-count%2Ctags-count%2Cdiagrams=iure" \
    --header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"

Example response (200):


{
    "data": {
        "owner_id": "a176b440-c169-11ee-98f1-f7dbcb3c4c94",
        "organization_id": "a1ddfd70-c169-11ee-b28d-13386829da78",
        "category_id": 390295,
        "business_process_id": 31750,
        "name": "tempora",
        "_lft": 646616388,
        "_rgt": 274610784,
        "summary": "Alice thought), and it said in a hurry. 'No, I'll look first,' she said, 'and see whether it's marked \"poison\" or not'; for she felt that she tipped over the wig, (look at the top of his head. But.",
        "type": "process",
        "_key": null
    }
}
 

Request   

GET api/v2/business-models/{id}

Headers

Authorization      

Example: Bearer {OPENID_CONNECT_TOKEN}

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

URL Parameters

id   string   

The ID of the business model. Example: eveniet

Query Parameters

include=owner,organization,category,tags,comments-count,tags-count,diagrams   string  optional  

Possible includes Example: iure

Update Business Model

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->put(
    'https://base.stackflows.com/api/v2/business-models/01f68d00-40da-11ee-9df1-41abd31f433d',
    [
        'headers' => [
            'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
        'json' => [
            'name' => 'khprffvobtewmltlmwuaeaaxtxzamskfzqxjkqhdzkxybshgizpngyuzfesheivfukwhswxjoslkufmwtaevocotxi',
            'type' => 'process',
            'summary' => 'amet',
            'public' => true,
            'organization_unit_ids' => [
                'eveniet',
            ],
            'tag_values' => [
                'repellat',
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/business-models/01f68d00-40da-11ee-9df1-41abd31f433d"
);

const headers = {
    "Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

let body = {
    "name": "khprffvobtewmltlmwuaeaaxtxzamskfzqxjkqhdzkxybshgizpngyuzfesheivfukwhswxjoslkufmwtaevocotxi",
    "type": "process",
    "summary": "amet",
    "public": true,
    "organization_unit_ids": [
        "eveniet"
    ],
    "tag_values": [
        "repellat"
    ]
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request PUT \
    "https://base.stackflows.com/api/v2/business-models/01f68d00-40da-11ee-9df1-41abd31f433d" \
    --header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx" \
    --data "{
    \"name\": \"khprffvobtewmltlmwuaeaaxtxzamskfzqxjkqhdzkxybshgizpngyuzfesheivfukwhswxjoslkufmwtaevocotxi\",
    \"type\": \"process\",
    \"summary\": \"amet\",
    \"public\": true,
    \"organization_unit_ids\": [
        \"eveniet\"
    ],
    \"tag_values\": [
        \"repellat\"
    ]
}"

Example response (200):


{
    "data": {
        "owner_id": "a3443d60-c169-11ee-89d9-edecb82b07dd",
        "organization_id": "a3b38770-c169-11ee-ab5a-1d5fcc29367c",
        "category_id": 390345,
        "business_process_id": 31759,
        "name": "officiis",
        "_lft": 2071252869,
        "_rgt": 1233027753,
        "summary": "I'm here! Digging for apples, indeed!' said the Hatter: 'but you could only hear whispers now and then nodded. 'It's no use denying it. I suppose I ought to be sure; but I THINK I can find it.' And.",
        "type": "process",
        "_key": null
    }
}
 

Request   

PUT api/v2/business-models/{id}

PATCH api/v2/business-models/{id}

Headers

Authorization      

Example: Bearer {OPENID_CONNECT_TOKEN}

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

URL Parameters

id   string   

The ID of the business model. Example: 01f68d00-40da-11ee-9df1-41abd31f433d

Body Parameters

name   string  optional  

Must be at least 3 characters. Example: khprffvobtewmltlmwuaeaaxtxzamskfzqxjkqhdzkxybshgizpngyuzfesheivfukwhswxjoslkufmwtaevocotxi

type   string  optional  

Must be one of process or decision. Example: process

summary   string  optional  

Example: amet

public   boolean  optional  

Example: true

category_id   string  optional  
organization_unit_ids   string[]  optional  
tag_values   string[]  optional  

Delete Business Model

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'https://base.stackflows.com/api/v2/business-models/01f68d00-40da-11ee-9df1-41abd31f433d',
    [
        'headers' => [
            'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/business-models/01f68d00-40da-11ee-9df1-41abd31f433d"
);

const headers = {
    "Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
curl --request DELETE \
    "https://base.stackflows.com/api/v2/business-models/01f68d00-40da-11ee-9df1-41abd31f433d" \
    --header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"

Example response (200):


{
    "data": {
        "owner_id": "a51ac820-c169-11ee-b397-318279772c48",
        "organization_id": "a588d290-c169-11ee-9ccc-c70271c037d4",
        "category_id": 390395,
        "business_process_id": 31768,
        "name": "iure",
        "_lft": 1356956380,
        "_rgt": 2015250325,
        "summary": "Alice more boldly: 'you know you're growing too.' 'Yes, but I hadn't quite finished my tea when I sleep\" is the same solemn tone, 'For the Duchess. 'Everything's got a moral, if only you can find.",
        "type": "process",
        "_key": null
    }
}
 

Request   

DELETE api/v2/business-models/{id}

Headers

Authorization      

Example: Bearer {OPENID_CONNECT_TOKEN}

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

URL Parameters

id   string   

The ID of the business model. Example: 01f68d00-40da-11ee-9df1-41abd31f433d

Delete Business Models

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'https://base.stackflows.com/api/v2/business-models',
    [
        'headers' => [
            'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
        'json' => [
            'ids' => [
                'ut',
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/business-models"
);

const headers = {
    "Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

let body = {
    "ids": [
        "ut"
    ]
};

fetch(url, {
    method: "DELETE",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request DELETE \
    "https://base.stackflows.com/api/v2/business-models" \
    --header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx" \
    --data "{
    \"ids\": [
        \"ut\"
    ]
}"

Example response (200):


{
    "data": {
        "owner_id": "a6f0bd30-c169-11ee-bbd6-f92e01384bbf",
        "organization_id": "a76441f0-c169-11ee-9503-134ea59dc35c",
        "category_id": 390445,
        "business_process_id": 31777,
        "name": "repellat",
        "_lft": 1706764788,
        "_rgt": 455685209,
        "summary": "YOU, and no more to do with this creature when I was thinking I should understand that better,' Alice said very humbly; 'I won't interrupt again. I dare say you never tasted an egg!' 'I HAVE tasted.",
        "type": "process",
        "_key": null
    }
}
 

Request   

DELETE api/v2/business-models

Headers

Authorization      

Example: Bearer {OPENID_CONNECT_TOKEN}

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

Body Parameters

ids   string[]  optional  

IDs of records to be deleted.

List Business Model Diagrams

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://base.stackflows.com/api/v2/business-models/natus/revisions',
    [
        'headers' => [
            'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/business-models/natus/revisions"
);

const headers = {
    "Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "https://base.stackflows.com/api/v2/business-models/natus/revisions" \
    --header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"

Example response (200):


{
    "data": [
        {
            "business_model_id": "aa9d8990-c169-11ee-88c9-477465b7156e",
            "version": 155,
            "versions": [],
            "_key": null
        },
        {
            "business_model_id": "ac820f50-c169-11ee-aafc-5fd0d519a24f",
            "version": 333,
            "versions": [],
            "_key": null
        }
    ]
}
 

Request   

GET api/v2/business-models/{business_model}/revisions

Headers

Authorization      

Example: Bearer {OPENID_CONNECT_TOKEN}

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

URL Parameters

business_model   string   

Example: natus

Submit Business Model Diagram

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://base.stackflows.com/api/v2/business-models/et/revisions',
    [
        'headers' => [
            'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
            'Content-Type' => 'multipart/form-data',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
        'multipart' => [
            [
                'name' => 'xml',
                'contents' => 'et'
            ],
            [
                'name' => 'next_version',
                'contents' => '4577.4609922'
            ],
            [
                'name' => 'prev_version',
                'contents' => '33.02561'
            ],
            [
                'name' => 'snapshot',
                'contents' => fopen('/tmp/phpCIKFnn', 'r')
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/business-models/et/revisions"
);

const headers = {
    "Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
    "Content-Type": "multipart/form-data",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

const body = new FormData();
body.append('xml', 'et');
body.append('next_version', '4577.4609922');
body.append('prev_version', '33.02561');
body.append('snapshot', document.querySelector('input[name="snapshot"]').files[0]);

fetch(url, {
    method: "POST",
    headers,
    body,
}).then(response => response.json());
curl --request POST \
    "https://base.stackflows.com/api/v2/business-models/et/revisions" \
    --header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
    --header "Content-Type: multipart/form-data" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx" \
    --form "xml=et" \
    --form "next_version=4577.4609922" \
    --form "prev_version=33.02561" \
    --form "snapshot=@/tmp/phpCIKFnn" 

Example response (200):


{
    "data": {
        "business_model_id": "ae6d2210-c169-11ee-9aec-5b64d41b76c7",
        "version": 262,
        "versions": [],
        "_key": null
    }
}
 

Request   

POST api/v2/business-models/{business_model}/revisions

Headers

Authorization      

Example: Bearer {OPENID_CONNECT_TOKEN}

Content-Type      

Example: multipart/form-data

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

URL Parameters

business_model   string   

Example: et

Body Parameters

xml   string   

An xml of a diagram. Example: et

snapshot   file  optional  

A snapshot image of a diagram Example: /tmp/phpCIKFnn

next_version   number  optional  

Example: 4577.4609922

prev_version   number  optional  

Example: 33.02561

View Business Model Diagram Revision

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://base.stackflows.com/api/v2/business-models/dolorem/revisions/nihil',
    [
        'headers' => [
            'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/business-models/dolorem/revisions/nihil"
);

const headers = {
    "Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "https://base.stackflows.com/api/v2/business-models/dolorem/revisions/nihil" \
    --header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"

Example response (200):


{
    "data": {
        "business_model_id": "b07e06b0-c169-11ee-a57e-01cabccac725",
        "version": 189,
        "versions": [],
        "_key": null
    }
}
 

Request   

GET api/v2/business-models/{business_model}/revisions/{revision}

Headers

Authorization      

Example: Bearer {OPENID_CONNECT_TOKEN}

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

URL Parameters

business_model   string   

Example: dolorem

revision   string   

The revision. Example: nihil

Tag Business Model

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://base.stackflows.com/api/v2/business-models/eveniet/tag',
    [
        'headers' => [
            'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
        'json' => [
            'tags' => [
                'perferendis',
            ],
            'type' => 'et',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/business-models/eveniet/tag"
);

const headers = {
    "Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

let body = {
    "tags": [
        "perferendis"
    ],
    "type": "et"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request POST \
    "https://base.stackflows.com/api/v2/business-models/eveniet/tag" \
    --header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx" \
    --data "{
    \"tags\": [
        \"perferendis\"
    ],
    \"type\": \"et\"
}"

Example response (200):


{
    "data": {
        "name": {
            "en": "sequi"
        },
        "_key": null
    }
}
 

Request   

POST api/v2/business-models/{business_model}/tag

Headers

Authorization      

Example: Bearer {OPENID_CONNECT_TOKEN}

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

URL Parameters

business_model   string   

Example: eveniet

Body Parameters

tags   string[]  optional  

List of tags, like [adsgasd, asdgasdg, asdgasdg]

type   string  optional  

Type of tag to work with, only one type is allowed at a single request Example: et

Share Business Model

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://base.stackflows.com/api/v2/business-models/sequi/share',
    [
        'headers' => [
            'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
        'json' => [
            'is_public' => false,
            'expire_date' => '2107-11-25',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/business-models/sequi/share"
);

const headers = {
    "Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

let body = {
    "is_public": false,
    "expire_date": "2107-11-25"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request POST \
    "https://base.stackflows.com/api/v2/business-models/sequi/share" \
    --header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx" \
    --data "{
    \"is_public\": false,
    \"expire_date\": \"2107-11-25\"
}"

Example response (200):


{
    "data": {
        "owner_id": "b09d1100-c169-11ee-88ac-1d7a47c3606f",
        "organization_id": "b11cbf20-c169-11ee-9028-35ad6c2638ea",
        "category_id": 390695,
        "business_process_id": 31822,
        "name": "non",
        "_lft": 27779355,
        "_rgt": 1243061108,
        "summary": "The other side of WHAT? The other guests had taken his watch out of the court. (As that is rather a hard word, I will tell you how it was certainly not becoming. 'And that's the queerest thing about.",
        "type": "process",
        "_key": null
    }
}
 

Request   

POST api/v2/business-models/{business_model}/share

Headers

Authorization      

Example: Bearer {OPENID_CONNECT_TOKEN}

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

URL Parameters

business_model   string   

Example: sequi

Body Parameters

is_public   boolean   

Example: false

expire_date   string  optional  

Must be a valid date. Must be a date after today. Example: 2107-11-25

List Business Model Comments

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://base.stackflows.com/api/v2/business-models/eligendi/comments',
    [
        'headers' => [
            'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
        'query' => [
            'include'=> 'commenter',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/business-models/eligendi/comments"
);

const params = {
    "include": "commenter",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "https://base.stackflows.com/api/v2/business-models/eligendi/comments?include=commenter" \
    --header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"

Example response (200):


{
    "data": [
        {
            "parent_id": 2707,
            "commentable_id": "b77ae9c0-c169-11ee-886b-9f22a847cc2f",
            "commenter_id": "b7873d30-c169-11ee-9075-0114c66b325f",
            "commentable_type": "App\\Models\\BusinessBaseModel",
            "comment": "Cheshire cat,' said the Duchess. An invitation from the change: and Alice could not stand, and she had nibbled some more bread-and-butter--' 'But what am I to do?' said Alice. 'Of course you know.",
            "status": 1,
            "_key": null
        },
        {
            "parent_id": 2708,
            "commentable_id": "bdeafac0-c169-11ee-bda5-25f53a592f4a",
            "commenter_id": "bdf78d90-c169-11ee-8dfc-fd5d4762d1d7",
            "commentable_type": "App\\Models\\BusinessBaseModel",
            "comment": "Mock Turtle. 'Very much indeed,' said Alice. 'Exactly so,' said the Hatter instead!' CHAPTER VII. A Mad Tea-Party There was no time she'd have everybody executed, all round. 'But she must have got.",
            "status": 0,
            "_key": null
        }
    ]
}
 

Request   

GET api/v2/business-models/{business_model}/comments

Headers

Authorization      

Example: Bearer {OPENID_CONNECT_TOKEN}

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

URL Parameters

business_model   string   

Example: eligendi

Query Parameters

include   string  optional  

Specify a list of includes. Example: commenter

List Business Model Diagrams

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://base.stackflows.com/api/v2/business-model-diagrams',
    [
        'headers' => [
            'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/business-model-diagrams"
);

const headers = {
    "Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "https://base.stackflows.com/api/v2/business-model-diagrams" \
    --header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"

Example response (200):


{
    "data": [
        {
            "business_model_id": "c128fe60-c169-11ee-929a-21450a9745f2",
            "version": 957,
            "versions": [],
            "_key": null
        },
        {
            "business_model_id": "c3655ae0-c169-11ee-86f2-53517ee903f8",
            "version": 672,
            "versions": [],
            "_key": null
        }
    ]
}
 

Request   

GET api/v2/business-model-diagrams

Headers

Authorization      

Example: Bearer {OPENID_CONNECT_TOKEN}

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

Create Business Model Diagram

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://base.stackflows.com/api/v2/business-model-diagrams',
    [
        'headers' => [
            'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
            'Content-Type' => 'multipart/form-data',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
        'multipart' => [
            [
                'name' => 'xml',
                'contents' => 'iste'
            ],
            [
                'name' => 'next_version',
                'contents' => '134.6862'
            ],
            [
                'name' => 'prev_version',
                'contents' => '469.183957679'
            ],
            [
                'name' => 'business_model_id',
                'contents' => 'qui'
            ],
            [
                'name' => 'snapshot',
                'contents' => fopen('/tmp/phpKMLAnM', 'r')
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/business-model-diagrams"
);

const headers = {
    "Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
    "Content-Type": "multipart/form-data",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

const body = new FormData();
body.append('xml', 'iste');
body.append('next_version', '134.6862');
body.append('prev_version', '469.183957679');
body.append('business_model_id', 'qui');
body.append('snapshot', document.querySelector('input[name="snapshot"]').files[0]);

fetch(url, {
    method: "POST",
    headers,
    body,
}).then(response => response.json());
curl --request POST \
    "https://base.stackflows.com/api/v2/business-model-diagrams" \
    --header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
    --header "Content-Type: multipart/form-data" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx" \
    --form "xml=iste" \
    --form "next_version=134.6862" \
    --form "prev_version=469.183957679" \
    --form "business_model_id=qui" \
    --form "snapshot=@/tmp/phpKMLAnM" 

Example response (200):


{
    "data": {
        "business_model_id": "c57ac380-c169-11ee-8086-03e3a9d5dc11",
        "version": 603,
        "versions": [],
        "_key": null
    }
}
 

Request   

POST api/v2/business-model-diagrams

Headers

Authorization      

Example: Bearer {OPENID_CONNECT_TOKEN}

Content-Type      

Example: multipart/form-data

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

Body Parameters

xml   string   

Example: iste

next_version   number  optional  

Example: 134.6862

prev_version   number  optional  

Example: 469.183957679

snapshot   file  optional  

of the process diagram Example: /tmp/phpKMLAnM

business_model_id   string   

Example: qui

View Business Model Diagram

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://base.stackflows.com/api/v2/business-model-diagrams/ratione',
    [
        'headers' => [
            'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/business-model-diagrams/ratione"
);

const headers = {
    "Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "https://base.stackflows.com/api/v2/business-model-diagrams/ratione" \
    --header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"

Example response (200):


{
    "data": {
        "business_model_id": "c77d5270-c169-11ee-b4cf-c57441862bd9",
        "version": 435,
        "versions": [],
        "_key": null
    }
}
 

Request   

GET api/v2/business-model-diagrams/{id}

Headers

Authorization      

Example: Bearer {OPENID_CONNECT_TOKEN}

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

URL Parameters

id   string   

The ID of the business model diagram. Example: ratione

Query Parameters

include=snapshots,publications,publications.statistics   string  optional  

Possible includes Example: qui

Delete Business Model Diagram

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'https://base.stackflows.com/api/v2/business-model-diagrams/00305390-3793-11ee-afbb-cf67e78d05cc',
    [
        'headers' => [
            'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/business-model-diagrams/00305390-3793-11ee-afbb-cf67e78d05cc"
);

const headers = {
    "Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
curl --request DELETE \
    "https://base.stackflows.com/api/v2/business-model-diagrams/00305390-3793-11ee-afbb-cf67e78d05cc" \
    --header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"

Example response (200):


{
    "data": {
        "business_model_id": "c9a2cca0-c169-11ee-99e5-31f34b785e34",
        "version": 248,
        "versions": [],
        "_key": null
    }
}
 

Request   

DELETE api/v2/business-model-diagrams/{id}

Headers

Authorization      

Example: Bearer {OPENID_CONNECT_TOKEN}

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

URL Parameters

id   string   

The ID of the business model diagram. Example: 00305390-3793-11ee-afbb-cf67e78d05cc

Publish Business Model Diagram

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://base.stackflows.com/api/v2/business-model-diagrams/quibusdam/publish',
    [
        'headers' => [
            'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/business-model-diagrams/quibusdam/publish"
);

const headers = {
    "Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());
curl --request POST \
    "https://base.stackflows.com/api/v2/business-model-diagrams/quibusdam/publish" \
    --header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx" \

Example response (200):


{
    "data": {
        "business_model_id": "cbb65130-c169-11ee-b849-7b9b838b9fda",
        "version": 612,
        "versions": [],
        "_key": null
    }
}
 

Request   

POST api/v2/business-model-diagrams/{business_model_diagram}/publish

Headers

Authorization      

Example: Bearer {OPENID_CONNECT_TOKEN}

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

URL Parameters

business_model_diagram   string   

Example: quibusdam

Body Parameters

environment_ids   string[]  optional  

Download Business Model Diagram Snapshot

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://base.stackflows.com/api/v2/business-model-diagrams/error/snapshots/4',
    [
        'headers' => [
            'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/business-model-diagrams/error/snapshots/4"
);

const headers = {
    "Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "https://base.stackflows.com/api/v2/business-model-diagrams/error/snapshots/4" \
    --header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"

Example response (200):


{
    "data": [
        {
            "business_model_id": "cdc73db0-c169-11ee-b156-7da5e2e3cafa",
            "version": 988,
            "versions": [],
            "_key": null
        },
        {
            "business_model_id": "cfe515c0-c169-11ee-a777-0dfcf8ea5960",
            "version": 923,
            "versions": [],
            "_key": null
        }
    ]
}
 

Request   

GET api/v2/business-model-diagrams/{business_model_diagram}/snapshots/{snapshot_id}

Headers

Authorization      

Example: Bearer {OPENID_CONNECT_TOKEN}

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

URL Parameters

business_model_diagram   string   

Example: error

snapshot_id   integer   

The ID of the snapshot. Example: 4

List Business Model Diagram Comments

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://base.stackflows.com/api/v2/business-model-diagrams/quisquam/comments',
    [
        'headers' => [
            'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
        'query' => [
            'include'=> 'commenter',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/business-model-diagrams/quisquam/comments"
);

const params = {
    "include": "commenter",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "https://base.stackflows.com/api/v2/business-model-diagrams/quisquam/comments?include=commenter" \
    --header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"

Example response (200):


{
    "data": [
        {
            "parent_id": 2709,
            "commentable_id": "d4c70100-c169-11ee-8ede-a30d630583da",
            "commenter_id": "d4d411b0-c169-11ee-88cb-151af6494e07",
            "commentable_type": "App\\Models\\BusinessBaseModel",
            "comment": "Dinah stop in the world she was as much right,' said the Hatter, it woke up again with a growl, And concluded the banquet--] 'What IS the same tone, exactly as if she had never before seen a good.",
            "status": 0,
            "_key": null
        },
        {
            "parent_id": 2710,
            "commentable_id": "da1a6380-c169-11ee-a43f-fbfd13c6699a",
            "commenter_id": "da26a2b0-c169-11ee-914c-1398f534d3ca",
            "commentable_type": "App\\Models\\BusinessBaseModel",
            "comment": "I will just explain to you how the game was in a trembling voice, '--and I hadn't mentioned Dinah!' she said to herself, and shouted out, 'You'd better not talk!' said Five. 'I heard every word you.",
            "status": 0,
            "_key": null
        }
    ]
}
 

Request   

GET api/v2/business-model-diagrams/{business_model_diagram_id}/comments

Headers

Authorization      

Example: Bearer {OPENID_CONNECT_TOKEN}

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

URL Parameters

business_model_diagram_id   string   

The ID of the business model diagram. Example: quisquam

Query Parameters

include   string  optional  

Specify a list of includes. Example: commenter

Create Business Model Diagram Comment

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://base.stackflows.com/api/v2/business-model-diagrams/explicabo/comments',
    [
        'headers' => [
            'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
        'json' => [
            'comment' => 'aut',
            'parent' => 15,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/business-model-diagrams/explicabo/comments"
);

const headers = {
    "Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

let body = {
    "comment": "aut",
    "parent": 15
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request POST \
    "https://base.stackflows.com/api/v2/business-model-diagrams/explicabo/comments" \
    --header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx" \
    --data "{
    \"comment\": \"aut\",
    \"parent\": 15
}"

Example response (200):


{
    "data": {
        "parent_id": 2711,
        "commentable_id": "df417560-c169-11ee-89ab-17f33e30cb14",
        "commenter_id": "df4d9730-c169-11ee-9f64-41c3d23c3d56",
        "commentable_type": "App\\Models\\BusinessBaseModel",
        "comment": "As she said to Alice, and she tried the roots of trees, and I've tried hedges,' the Pigeon in a helpless sort of people live about here?' 'In THAT direction,' the Cat said, waving its right ear and.",
        "status": 0,
        "_key": null
    }
}
 

Request   

POST api/v2/business-model-diagrams/{business_model_diagram_id}/comments

Headers

Authorization      

Example: Bearer {OPENID_CONNECT_TOKEN}

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

URL Parameters

business_model_diagram_id   string   

The ID of the business model diagram. Example: explicabo

diagram   string   

The ID of a diagram. Example: 3688e6c0-1a56-11ec-8366

Body Parameters

comment   string   

Example: aut

parent   integer  optional  

Example: 15

Delete Business Model Diagram Comment

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'https://base.stackflows.com/api/v2/business-model-diagrams/doloremque/comments/1',
    [
        'headers' => [
            'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/business-model-diagrams/doloremque/comments/1"
);

const headers = {
    "Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
curl --request DELETE \
    "https://base.stackflows.com/api/v2/business-model-diagrams/doloremque/comments/1" \
    --header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"

Example response (200):


{
    "data": {
        "parent_id": 2712,
        "commentable_id": "e4a0f250-c169-11ee-b04b-67cbf76a04c3",
        "commenter_id": "e4ad4400-c169-11ee-b0bf-f9f208607f61",
        "commentable_type": "App\\Models\\BusinessBaseModel",
        "comment": "Knave of Hearts, who only bowed and smiled in reply. 'Please come back again, and the other bit. Her chin was pressed so closely against her foot, that there was nothing on it were white, but there.",
        "status": 0,
        "_key": null
    }
}
 

Request   

DELETE api/v2/business-model-diagrams/{business_model_diagram_id}/comments/{id}

Headers

Authorization      

Example: Bearer {OPENID_CONNECT_TOKEN}

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

URL Parameters

business_model_diagram_id   string   

The ID of the business model diagram. Example: doloremque

id   integer   

The ID of the comment. Example: 1

diagram   string   

The ID of a diagram. Example: 3688e6c0-1a56-11ec-8366

comment   string   

The ID of a comment. Example: 3688e6c0-1a56-11ec-8366

List Business Model Publications

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://base.stackflows.com/api/v2/business-model-publications',
    [
        'headers' => [
            'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
        'query' => [
            'include'=> 'diagram,diagram.model',
            'filter[business-model-diagram]'=> '5445fd-2454554-fddffd-5445',
            'filter[manual]'=> '1',
            'filter[eligible]'=> '1',
            'filter[production]'=> '1',
            'filter[type]'=> 'process',
            'filter[latest]'=> '1',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/business-model-publications"
);

const params = {
    "include": "diagram,diagram.model",
    "filter[business-model-diagram]": "5445fd-2454554-fddffd-5445",
    "filter[manual]": "1",
    "filter[eligible]": "1",
    "filter[production]": "1",
    "filter[type]": "process",
    "filter[latest]": "1",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "https://base.stackflows.com/api/v2/business-model-publications?include=diagram%2Cdiagram.model&filter%5Bbusiness-model-diagram%5D=5445fd-2454554-fddffd-5445&filter%5Bmanual%5D=1&filter%5Beligible%5D=1&filter%5Bproduction%5D=1&filter%5Btype%5D=process&filter%5Blatest%5D=1" \
    --header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"

Example response (200):


{
    "data": [
        {
            "business_model_diagram_id": "e7401a70-c169-11ee-9a43-8b857adc6f50",
            "engine_deployment_reference": "f8c03421-9d4e-3d6f-ad35-bb48babb7ca9",
            "engine_diagram_reference": "124004ce-e3fe-3f87-9b50-eb6ef85574b2",
            "engine_model_reference": "Process_AccusamusEtFuga.",
            "_key": null
        },
        {
            "business_model_diagram_id": "e932d020-c169-11ee-8add-87e8d0c71c66",
            "engine_deployment_reference": "447e9ef5-b191-31ee-b898-7d1966726d98",
            "engine_diagram_reference": "6f493c78-18df-385f-8856-ed9350e2e905",
            "engine_model_reference": "Process_AccusantiumEaque.",
            "_key": null
        }
    ]
}
 

Request   

GET api/v2/business-model-publications

Headers

Authorization      

Example: Bearer {OPENID_CONNECT_TOKEN}

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

Query Parameters

include   string  optional  

Possible includes. Example: diagram,diagram.model

filter[business-model-diagram]   string  optional  

Filter by diagram id. Example: 5445fd-2454554-fddffd-5445

filter[manual]   boolean  optional  

List manually triggered process publications. Example: true

filter[eligible]   boolean  optional  

List only eligible records. Example: true

filter[production]   boolean  optional  

List only production ready process publications. Example: true

filter[type]   string  optional  

List publications by model type (process, decision). Example: process

filter[latest]   boolean  optional  

List only latest publications. Example: true

View Business Model Publication

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://base.stackflows.com/api/v2/business-model-publications/et',
    [
        'headers' => [
            'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/business-model-publications/et"
);

const headers = {
    "Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "https://base.stackflows.com/api/v2/business-model-publications/et" \
    --header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"

Example response (200):


{
    "data": {
        "business_model_diagram_id": "eb1e4050-c169-11ee-b83d-9764a0d7b8fe",
        "engine_deployment_reference": "b60df4e8-3e15-3e25-b318-ecd5a01e2683",
        "engine_diagram_reference": "2b2c0ee0-d46b-3fa9-869f-7c04e246e3d0",
        "engine_model_reference": "Process_PerspiciatisNisi.",
        "_key": null
    }
}
 

Request   

GET api/v2/business-model-publications/{id}

Headers

Authorization      

Example: Bearer {OPENID_CONNECT_TOKEN}

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

URL Parameters

id   string   

The ID of the business model publication. Example: et

List Business Model Exceptions

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://base.stackflows.com/api/v2/business-model-exceptions',
    [
        'headers' => [
            'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/business-model-exceptions"
);

const headers = {
    "Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "https://base.stackflows.com/api/v2/business-model-exceptions" \
    --header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"

Example response (200):


{
    "data": [
        {
            "organization_id": "eb27deb0-c169-11ee-b701-c748e1ca410f",
            "source": {
                "en": "delectus"
            },
            "solution": {
                "en": "nostrum"
            },
            "consequences": {
                "en": "commodi"
            },
            "incidence": "high",
            "impact": "low",
            "causative_organization_unit_id": "ebff43e0-c169-11ee-b864-73e3af0879f8",
            "responsible_organization_unit_id": "ec793e60-c169-11ee-82ae-9d69de25c8de",
            "incidence_options": [
                "very_low",
                "low",
                "medium",
                "high",
                "very_high"
            ],
            "impact_options": [
                "none",
                "low",
                "medium",
                "high"
            ],
            "_key": null
        },
        {
            "organization_id": "ec7a7740-c169-11ee-8947-67456e798a50",
            "source": {
                "en": "minus"
            },
            "solution": {
                "en": "aut"
            },
            "consequences": {
                "en": "fugiat"
            },
            "incidence": "low",
            "impact": "low",
            "causative_organization_unit_id": "ed6849e0-c169-11ee-8de7-117493b65c73",
            "responsible_organization_unit_id": "edde6cb0-c169-11ee-b4fc-39973728344d",
            "incidence_options": [
                "very_low",
                "low",
                "medium",
                "high",
                "very_high"
            ],
            "impact_options": [
                "none",
                "low",
                "medium",
                "high"
            ],
            "_key": null
        }
    ]
}
 

Request   

GET api/v2/business-model-exceptions

Headers

Authorization      

Example: Bearer {OPENID_CONNECT_TOKEN}

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

View Business Model Exception

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://base.stackflows.com/api/v2/business-model-exceptions/fugiat',
    [
        'headers' => [
            'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/business-model-exceptions/fugiat"
);

const headers = {
    "Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "https://base.stackflows.com/api/v2/business-model-exceptions/fugiat" \
    --header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"

Example response (200):


{
    "data": {
        "organization_id": "edeac420-c169-11ee-8d65-71e508b380b0",
        "source": {
            "en": "placeat"
        },
        "solution": {
            "en": "et"
        },
        "consequences": {
            "en": "impedit"
        },
        "incidence": "very_high",
        "impact": "medium",
        "causative_organization_unit_id": "eecbedd0-c169-11ee-9018-bf3009f7d1ed",
        "responsible_organization_unit_id": "ef4d5e00-c169-11ee-b8cc-99e6884964fe",
        "incidence_options": [
            "very_low",
            "low",
            "medium",
            "high",
            "very_high"
        ],
        "impact_options": [
            "none",
            "low",
            "medium",
            "high"
        ],
        "_key": null
    }
}
 

Request   

GET api/v2/business-model-exceptions/{id}

Headers

Authorization      

Example: Bearer {OPENID_CONNECT_TOKEN}

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

URL Parameters

id   string   

The ID of the business model exception. Example: fugiat

Business Process Models

List Business Process Model Publications

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://base.stackflows.com/api/v2/business-process-model-publications',
    [
        'headers' => [
            'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
        'query' => [
            'append'=> 'statistics,outliers',
            'include'=> 'diagram,diagram.model',
            'filter[business-model-diagram]'=> '5445fd-2454554-fddffd-5445',
            'filter[manual]'=> '1',
            'filter[production]'=> '1',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/business-process-model-publications"
);

const params = {
    "append": "statistics,outliers",
    "include": "diagram,diagram.model",
    "filter[business-model-diagram]": "5445fd-2454554-fddffd-5445",
    "filter[manual]": "1",
    "filter[production]": "1",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "https://base.stackflows.com/api/v2/business-process-model-publications?append=statistics%2Coutliers&include=diagram%2Cdiagram.model&filter%5Bbusiness-model-diagram%5D=5445fd-2454554-fddffd-5445&filter%5Bmanual%5D=1&filter%5Bproduction%5D=1" \
    --header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"

Example response (200):


{
    "data": [
        {
            "business_model_diagram_id": "f13363a0-c169-11ee-a104-9f41a69cfc79",
            "engine_deployment_reference": "fc0ea076-458b-3a4c-91c5-f826580ba456",
            "engine_diagram_reference": "8044fe79-f1b7-3705-99df-f8523a753bed",
            "engine_model_reference": "Process_AtqueEtPariatur.",
            "_key": null
        },
        {
            "business_model_diagram_id": "f32ffb00-c169-11ee-ac62-67698d5569c1",
            "engine_deployment_reference": "6c8e2511-0675-39f1-b705-9a592b9656a9",
            "engine_diagram_reference": "ee874a31-c372-385e-878a-b5b74dd17ffe",
            "engine_model_reference": "Process_ExercitationemEt.",
            "_key": null
        }
    ]
}
 

Request   

GET api/v2/business-process-model-publications

Headers

Authorization      

Example: Bearer {OPENID_CONNECT_TOKEN}

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

Query Parameters

append   string  optional  

Possible appends. Example: statistics,outliers

include   string  optional  

Possible includes. Example: diagram,diagram.model

filter[business-model-diagram]   string  optional  

Filter by diagram id. Example: 5445fd-2454554-fddffd-5445

filter[manual]   boolean  optional  

List manually triggered process publications. Example: true

filter[production]   boolean  optional  

List only production ready process publications. Example: true

View Business Process Model Publication

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://base.stackflows.com/api/v2/business-process-model-publications/corrupti',
    [
        'headers' => [
            'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
        'query' => [
            'append'=> 'statistics,outliers',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/business-process-model-publications/corrupti"
);

const params = {
    "append": "statistics,outliers",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "https://base.stackflows.com/api/v2/business-process-model-publications/corrupti?append=statistics%2Coutliers" \
    --header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"

Example response (200):


{
    "data": {
        "business_model_diagram_id": "f517cec0-c169-11ee-9e86-cf9d5a9f5817",
        "engine_deployment_reference": "983f4b6b-dc0b-3a5c-b67a-cb76e0674b07",
        "engine_diagram_reference": "efd0c455-4e3a-3304-b180-cb93f80b5f29",
        "engine_model_reference": "Process_EaQuiDoloribus.",
        "_key": null
    }
}
 

Request   

GET api/v2/business-process-model-publications/{publication}

Headers

Authorization      

Example: Bearer {OPENID_CONNECT_TOKEN}

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

URL Parameters

publication   string   

Example: corrupti

Query Parameters

append   string  optional  

Possible appends. Example: statistics,outliers

View Business Process Submission Form

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://base.stackflows.com/api/v2/business-process-model-publications/consequuntur/form',
    [
        'headers' => [
            'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/business-process-model-publications/consequuntur/form"
);

const headers = {
    "Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "https://base.stackflows.com/api/v2/business-process-model-publications/consequuntur/form" \
    --header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"

Example response (200):


{
    "data": [
        [],
        []
    ]
}
 

Example response (200):


{
  "data": {
    "some_string_property": {
      "attribute": {
        "reference": "some_string_property",
        "engine_reference": "someStringProperty",
        "type": "string",
        "label": "Some String Property",
      "value": "122",
    },
    "some_integer_property": {
      "attribute": {
        "reference": "some_integer_property",
        "engine_reference": "someIntegerProperty",
        "type": "integer",
        "label": "Some Integer Property",
      "value": 122,
    },
    "some_float_property": {
      "attribute": {
        "reference": "some_float_property",
        "engine_reference": "someFloatProperty",
        "type": "float",
        "label": "Some Float Property",
        "value": 122.0
    },
    "some_boolean_property": {
      "attribute": {
        "reference": "some_boolean_property",
        "engine_reference": "someBooleanProperty",
        "type": "boolean",
        "label": "Some Boolean Property",
        "value": true
    },
    "some_date_property": {
      "attribute": {
        "reference": "some_date_property",
        "engine_reference": "someDateProperty",
        "type": "date",
        "label": "Some Date Property",
        "value": "2035-01-01"
    },
    "some_date_time_property": {
      "attribute": {
        "reference": "some_date_time_property",
        "engine_reference": "someDateTimeProperty",
        "type": "date_time",
        "label": "Some Date Time Property",
        "value": "2035-01-01T00:00:00Z"
    },
  }
}
 

Request   

GET api/v2/business-process-model-publications/{publication_id}/form

Headers

Authorization      

Example: Bearer {OPENID_CONNECT_TOKEN}

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

URL Parameters

publication_id   string   

The ID of the publication. Example: consequuntur

Start Business Process

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://base.stackflows.com/api/v2/business-process-model-publications/accusamus/start',
    [
        'headers' => [
            'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
        'json' => [
            'submission' => [
                'temporibus',
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/business-process-model-publications/accusamus/start"
);

const headers = {
    "Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

let body = {
    "submission": [
        "temporibus"
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request POST \
    "https://base.stackflows.com/api/v2/business-process-model-publications/accusamus/start" \
    --header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx" \
    --data "{
    \"submission\": [
        \"temporibus\"
    ]
}"

Example response (200):


{
    "data": {
        "business_model_id": "f6f91fc0-c169-11ee-984a-f95e601f27d5",
        "version": 640,
        "versions": [],
        "_key": null
    }
}
 

Request   

POST api/v2/business-process-model-publications/{publication_id}/start

Headers

Authorization      

Example: Bearer {OPENID_CONNECT_TOKEN}

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

URL Parameters

publication_id   string   

The ID of the publication. Example: accusamus

Body Parameters

submission   string[]   

Connectors

List Connector Profiles

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://base.stackflows.com/api/v2/connectors/profiles',
    [
        'headers' => [
            'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
        'query' => [
            'filter[trashed]'=> 'with,only',
            'sort'=> '-created_at',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/connectors/profiles"
);

const params = {
    "filter[trashed]": "with,only",
    "sort": "-created_at",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "https://base.stackflows.com/api/v2/connectors/profiles?filter%5Btrashed%5D=with%2Conly&sort=-created_at" \
    --header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"

Example response (200):


{
    "data": [
        {
            "organization_id": "06f2a780-c16a-11ee-80fa-7bf3a00f6e62",
            "label": "modi",
            "name": "make",
            "version": "v2",
            "config": [],
            "actions": [
                {
                    "name": "exec_scenario",
                    "externalName": "exec_scenario"
                }
            ],
            "_key": null
        },
        {
            "organization_id": "077cea50-c16a-11ee-98c7-b3d54b37c521",
            "label": "omnis",
            "name": "make",
            "version": "v2",
            "config": [],
            "actions": [
                {
                    "name": "exec_scenario",
                    "externalName": "exec_scenario"
                }
            ],
            "_key": null
        }
    ]
}
 

Request   

GET api/v2/connectors/profiles

Headers

Authorization      

Example: Bearer {OPENID_CONNECT_TOKEN}

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

Query Parameters

filter[trashed]   string  optional  

List only trashed profiles. Example: with,only

sort   string  optional  

Sort order. Example: -created_at

Create Connector Profile

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://base.stackflows.com/api/v2/connectors/profiles',
    [
        'headers' => [
            'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
        'json' => [
            'label' => 'aut',
            'name' => 'officia',
            'version' => 'suscipit',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/connectors/profiles"
);

const headers = {
    "Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

let body = {
    "label": "aut",
    "name": "officia",
    "version": "suscipit"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request POST \
    "https://base.stackflows.com/api/v2/connectors/profiles" \
    --header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx" \
    --data "{
    \"label\": \"aut\",
    \"name\": \"officia\",
    \"version\": \"suscipit\"
}"

Example response (200):


{
    "data": {
        "organization_id": "07f8c8c0-c16a-11ee-b1bc-e390eff833ed",
        "label": "expedita",
        "name": "make",
        "version": "v2",
        "config": [],
        "actions": [
            {
                "name": "exec_scenario",
                "externalName": "exec_scenario"
            }
        ],
        "_key": null
    }
}
 

Request   

POST api/v2/connectors/profiles

Headers

Authorization      

Example: Bearer {OPENID_CONNECT_TOKEN}

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

Body Parameters

label   string   

Example: aut

name   string   

Example: officia

version   string  optional  

Example: suscipit

config   object  optional  

View Connector Profile

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://base.stackflows.com/api/v2/connectors/profiles/numquam',
    [
        'headers' => [
            'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/connectors/profiles/numquam"
);

const headers = {
    "Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "https://base.stackflows.com/api/v2/connectors/profiles/numquam" \
    --header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"

Example response (200):


{
    "data": {
        "organization_id": "08740e40-c16a-11ee-b8b2-9fa5421baebe",
        "label": "cupiditate",
        "name": "make",
        "version": "v2",
        "config": [],
        "actions": [
            {
                "name": "exec_scenario",
                "externalName": "exec_scenario"
            }
        ],
        "_key": null
    }
}
 

Request   

GET api/v2/connectors/profiles/{id}

Headers

Authorization      

Example: Bearer {OPENID_CONNECT_TOKEN}

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

URL Parameters

id   string   

The ID of the profile. Example: numquam

Update Connector Profile

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->put(
    'https://base.stackflows.com/api/v2/connectors/profiles/ut',
    [
        'headers' => [
            'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
        'json' => [
            'label' => 'qui',
            'name' => 'magni',
            'version' => 'molestiae',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/connectors/profiles/ut"
);

const headers = {
    "Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

let body = {
    "label": "qui",
    "name": "magni",
    "version": "molestiae"
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request PUT \
    "https://base.stackflows.com/api/v2/connectors/profiles/ut" \
    --header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx" \
    --data "{
    \"label\": \"qui\",
    \"name\": \"magni\",
    \"version\": \"molestiae\"
}"

Example response (200):


{
    "data": {
        "organization_id": "08e995a0-c16a-11ee-b6b2-df8601fc7d59",
        "label": "deserunt",
        "name": "make",
        "version": "v2",
        "config": [],
        "actions": [
            {
                "name": "exec_scenario",
                "externalName": "exec_scenario"
            }
        ],
        "_key": null
    }
}
 

Request   

PUT api/v2/connectors/profiles/{id}

PATCH api/v2/connectors/profiles/{id}

Headers

Authorization      

Example: Bearer {OPENID_CONNECT_TOKEN}

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

URL Parameters

id   string   

The ID of the profile. Example: ut

Body Parameters

label   string  optional  

Example: qui

name   string  optional  

Example: magni

version   string  optional  

Example: molestiae

config   object  optional  

Delete Connector Profile

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'https://base.stackflows.com/api/v2/connectors/profiles/sint',
    [
        'headers' => [
            'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/connectors/profiles/sint"
);

const headers = {
    "Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
curl --request DELETE \
    "https://base.stackflows.com/api/v2/connectors/profiles/sint" \
    --header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"

Example response (200):


{
    "data": {
        "organization_id": "095818e0-c16a-11ee-945b-ef23c33bc23b",
        "label": "nemo",
        "name": "make",
        "version": "v2",
        "config": [],
        "actions": [
            {
                "name": "exec_scenario",
                "externalName": "exec_scenario"
            }
        ],
        "_key": null
    }
}
 

Request   

DELETE api/v2/connectors/profiles/{id}

Headers

Authorization      

Example: Bearer {OPENID_CONNECT_TOKEN}

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

URL Parameters

id   string   

The ID of the profile. Example: sint

Restore Connector Profile

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://base.stackflows.com/api/v2/connectors/profiles/facilis/restore',
    [
        'headers' => [
            'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/connectors/profiles/facilis/restore"
);

const headers = {
    "Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());
curl --request POST \
    "https://base.stackflows.com/api/v2/connectors/profiles/facilis/restore" \
    --header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"

Example response (200):


{
    "data": {
        "organization_id": "09d26dc0-c16a-11ee-94e7-29af20dff3ec",
        "label": "est",
        "name": "make",
        "version": "v2",
        "config": [],
        "actions": [
            {
                "name": "exec_scenario",
                "externalName": "exec_scenario"
            }
        ],
        "_key": null
    }
}
 

Request   

POST api/v2/connectors/profiles/{profile_id}/restore

Headers

Authorization      

Example: Bearer {OPENID_CONNECT_TOKEN}

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

URL Parameters

profile_id   string   

The ID of the profile. Example: facilis

List Connector Profile Action Config Fields

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://base.stackflows.com/api/v2/connectors/profiles/et/action/alias/config-fields',
    [
        'headers' => [
            'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/connectors/profiles/et/action/alias/config-fields"
);

const headers = {
    "Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "https://base.stackflows.com/api/v2/connectors/profiles/et/action/alias/config-fields" \
    --header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"

Example response (403):

Show headers
cache-control: no-cache, private
content-type: application/json
vary: Origin
 

{
    "message": "Tenant header is missing or is invalid"
}
 

Request   

GET api/v2/connectors/profiles/{profile_id}/action/{action}/config-fields

Headers

Authorization      

Example: Bearer {OPENID_CONNECT_TOKEN}

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

URL Parameters

profile_id   string   

The ID of the profile. Example: et

action   string   

The action. Example: alias

List Connector Applications

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://base.stackflows.com/api/v2/connectors/applications',
    [
        'headers' => [
            'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
        'query' => [
            'filter[connector_profile_id]'=> 'lorem',
            'filter[business_model_id]'=> 'lorem',
            'filter[service_task_topic]'=> 'lorem',
            'filter[action_reference]'=> 'lorem',
            'filter[search]'=> 'lorem',
            'sort'=> '-created_at',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/connectors/applications"
);

const params = {
    "filter[connector_profile_id]": "lorem",
    "filter[business_model_id]": "lorem",
    "filter[service_task_topic]": "lorem",
    "filter[action_reference]": "lorem",
    "filter[search]": "lorem",
    "sort": "-created_at",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "https://base.stackflows.com/api/v2/connectors/applications?filter%5Bconnector_profile_id%5D=lorem&filter%5Bbusiness_model_id%5D=lorem&filter%5Bservice_task_topic%5D=lorem&filter%5Baction_reference%5D=lorem&filter%5Bsearch%5D=lorem&sort=-created_at" \
    --header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"

Example response (200):


{
    "data": [
        {
            "connector_profile_id": "0acc1770-c16a-11ee-a0f6-a1e088e22f28",
            "business_model_id": "0cd50ef0-c16a-11ee-96b8-69730d3fb04b",
            "business_model_diagram_id": "0f01c930-c16a-11ee-bb26-051938d6b6ba",
            "service_task_topic": "DICTA_VOLUPTATEM_DOLOR",
            "action": "in",
            "_key": null
        },
        {
            "connector_profile_id": "0f900d50-c16a-11ee-b028-9bf9b00bf3c1",
            "business_model_id": "11f4ee80-c16a-11ee-839d-e5c19a06ccbb",
            "business_model_diagram_id": "14890370-c16a-11ee-961e-d7f60c7f0dcd",
            "service_task_topic": "ET_SIT_DUCIMUS",
            "action": "eligendi",
            "_key": null
        }
    ]
}
 

Request   

GET api/v2/connectors/applications

Headers

Authorization      

Example: Bearer {OPENID_CONNECT_TOKEN}

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

Query Parameters

filter[connector_profile_id]   string  optional  

List applications for a specific profile. Example: lorem

filter[business_model_id]   string  optional  

List applications for a specific model. Example: lorem

filter[service_task_topic]   string  optional  

List applications for a specific service task topic. Example: lorem

filter[action_reference]   string  optional  

List applications for a specific action. Example: lorem

filter[search]   string  optional  

List applications by a specific keyword. Example: lorem

sort   string  optional  

Sort order. Example: -created_at

Create Connector Application

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://base.stackflows.com/api/v2/connectors/applications',
    [
        'headers' => [
            'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
        'json' => [
            'connector_profile_id' => 'iste',
            'business_model_id' => 'eaque',
            'service_task_topic' => 'necessitatibus',
            'action_reference' => 'illum',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/connectors/applications"
);

const headers = {
    "Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

let body = {
    "connector_profile_id": "iste",
    "business_model_id": "eaque",
    "service_task_topic": "necessitatibus",
    "action_reference": "illum"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request POST \
    "https://base.stackflows.com/api/v2/connectors/applications" \
    --header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx" \
    --data "{
    \"connector_profile_id\": \"iste\",
    \"business_model_id\": \"eaque\",
    \"service_task_topic\": \"necessitatibus\",
    \"action_reference\": \"illum\"
}"

Example response (200):


{
    "data": {
        "connector_profile_id": "152b4ab0-c16a-11ee-8576-35825fce162b",
        "business_model_id": "1745e8f0-c16a-11ee-9306-2d2e60622c03",
        "business_model_diagram_id": "197a80d0-c16a-11ee-9e76-476f52c2d4ad",
        "service_task_topic": "ELIGENDI_AUT_ARCHITECTO",
        "action": "ea",
        "_key": null
    }
}
 

Request   

POST api/v2/connectors/applications

Headers

Authorization      

Example: Bearer {OPENID_CONNECT_TOKEN}

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

Body Parameters

connector_profile_id   string   

Example: iste

business_model_id   string   

Example: eaque

service_task_topic   string   

Example: necessitatibus

action_reference   string  optional  

Example: illum

action_config   object  optional  

View Connector Application

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://base.stackflows.com/api/v2/connectors/applications/ex',
    [
        'headers' => [
            'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/connectors/applications/ex"
);

const headers = {
    "Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "https://base.stackflows.com/api/v2/connectors/applications/ex" \
    --header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"

Example response (200):


{
    "data": {
        "connector_profile_id": "1a062940-c16a-11ee-a6c5-ab745d990ce1",
        "business_model_id": "1c26b350-c16a-11ee-a30a-431d62bff9d2",
        "business_model_diagram_id": "1e4ba940-c16a-11ee-832f-cff2e9fe0aea",
        "service_task_topic": "SUSCIPIT_AUT_APERIAM",
        "action": "debitis",
        "_key": null
    }
}
 

Request   

GET api/v2/connectors/applications/{id}

Headers

Authorization      

Example: Bearer {OPENID_CONNECT_TOKEN}

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

URL Parameters

id   string   

The ID of the application. Example: ex

Update Connector Application

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->put(
    'https://base.stackflows.com/api/v2/connectors/applications/aut',
    [
        'headers' => [
            'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
        'json' => [
            'service_task_topic' => 'error',
            'action_reference' => 'nemo',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/connectors/applications/aut"
);

const headers = {
    "Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

let body = {
    "service_task_topic": "error",
    "action_reference": "nemo"
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request PUT \
    "https://base.stackflows.com/api/v2/connectors/applications/aut" \
    --header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx" \
    --data "{
    \"service_task_topic\": \"error\",
    \"action_reference\": \"nemo\"
}"

Example response (200):


{
    "data": {
        "connector_profile_id": "1ed6bf30-c16a-11ee-af0d-a939ead82544",
        "business_model_id": "20de2820-c16a-11ee-871d-1b4650486879",
        "business_model_diagram_id": "2306dcb0-c16a-11ee-bf1f-55c2467b4b52",
        "service_task_topic": "DOLOREMQUE_QUASI_NESCIUNT",
        "action": "reiciendis",
        "_key": null
    }
}
 

Request   

PUT api/v2/connectors/applications/{id}

PATCH api/v2/connectors/applications/{id}

Headers

Authorization      

Example: Bearer {OPENID_CONNECT_TOKEN}

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

URL Parameters

id   string   

The ID of the application. Example: aut

Body Parameters

connector_profile_id   string  optional  
business_model_id   string  optional  
service_task_topic   string  optional  

Example: error

action_reference   string  optional  

Example: nemo

action_config   object  optional  

Delete Connector Application

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'https://base.stackflows.com/api/v2/connectors/applications/quis',
    [
        'headers' => [
            'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/connectors/applications/quis"
);

const headers = {
    "Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
curl --request DELETE \
    "https://base.stackflows.com/api/v2/connectors/applications/quis" \
    --header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"

Example response (200):


{
    "data": {
        "connector_profile_id": "23904ef0-c16a-11ee-9c6c-8fd82d8a5e40",
        "business_model_id": "25a08410-c16a-11ee-9851-b9f97bcd826a",
        "business_model_diagram_id": "27cadbf0-c16a-11ee-8efb-ff3dfc3ef026",
        "service_task_topic": "ENIM_ADIPISCI_HIC",
        "action": "dolore",
        "_key": null
    }
}
 

Request   

DELETE api/v2/connectors/applications/{id}

Headers

Authorization      

Example: Bearer {OPENID_CONNECT_TOKEN}

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

URL Parameters

id   string   

The ID of the application. Example: quis

List Connector Definitions

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://base.stackflows.com/api/v2/connectors/definitions',
    [
        'headers' => [
            'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/connectors/definitions"
);

const headers = {
    "Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "https://base.stackflows.com/api/v2/connectors/definitions" \
    --header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"

Example response (403):

Show headers
cache-control: no-cache, private
content-type: application/json
vary: Origin
 

{
    "message": "Tenant header is missing or is invalid"
}
 

Request   

GET api/v2/connectors/definitions

Headers

Authorization      

Example: Bearer {OPENID_CONNECT_TOKEN}

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

Users

Assign Organization Units

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://base.stackflows.com/api/v2/users/0212d300-8534-11ed-828a-9d6be7cc0d7a/assign-organization-units',
    [
        'headers' => [
            'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
        'json' => [
            'ids' => [
                'atque',
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/users/0212d300-8534-11ed-828a-9d6be7cc0d7a/assign-organization-units"
);

const headers = {
    "Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

let body = {
    "ids": [
        "atque"
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request POST \
    "https://base.stackflows.com/api/v2/users/0212d300-8534-11ed-828a-9d6be7cc0d7a/assign-organization-units" \
    --header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx" \
    --data "{
    \"ids\": [
        \"atque\"
    ]
}"

Request   

POST api/v2/users/{user_id}/assign-organization-units

Headers

Authorization      

Example: Bearer {OPENID_CONNECT_TOKEN}

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

URL Parameters

user_id   string   

The ID of the user. Example: 0212d300-8534-11ed-828a-9d6be7cc0d7a

Body Parameters

ids   string[]  optional  

Update

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->put(
    'https://base.stackflows.com/api/v2/users/0212d300-8534-11ed-828a-9d6be7cc0d7a',
    [
        'headers' => [
            'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
        'json' => [
            'name' => 'in',
            'surname' => 'assumenda',
            'phone' => 'optio',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/users/0212d300-8534-11ed-828a-9d6be7cc0d7a"
);

const headers = {
    "Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

let body = {
    "name": "in",
    "surname": "assumenda",
    "phone": "optio"
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request PUT \
    "https://base.stackflows.com/api/v2/users/0212d300-8534-11ed-828a-9d6be7cc0d7a" \
    --header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx" \
    --data "{
    \"name\": \"in\",
    \"surname\": \"assumenda\",
    \"phone\": \"optio\"
}"

Example response (200):


{
    "data": {
        "name": "Korey",
        "surname": "Jacobs",
        "email": "eloy18@example.org",
        "phone": "+17656704425",
        "email_verified_at": "1987-04-04T19:13:47.000000Z",
        "_key": null
    }
}
 

Request   

PUT api/v2/users/{id}

Headers

Authorization      

Example: Bearer {OPENID_CONNECT_TOKEN}

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

URL Parameters

id   string   

The ID of the user. Example: 0212d300-8534-11ed-828a-9d6be7cc0d7a

Body Parameters

organization_ids   string[]  optional  
organization_unit_ids   string[]  optional  
name   string  optional  

Example: in

surname   string  optional  

Example: assumenda

phone   string  optional  

Example: optio

Delete User

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'https://base.stackflows.com/api/v2/users/0212d300-8534-11ed-828a-9d6be7cc0d7a',
    [
        'headers' => [
            'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/users/0212d300-8534-11ed-828a-9d6be7cc0d7a"
);

const headers = {
    "Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
curl --request DELETE \
    "https://base.stackflows.com/api/v2/users/0212d300-8534-11ed-828a-9d6be7cc0d7a" \
    --header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"

Example response (200):


{
    "data": {
        "name": "Mercedes",
        "surname": "Kessler",
        "email": "russell.wisoky@example.org",
        "phone": "+1-938-309-0025",
        "email_verified_at": "1977-01-22T06:46:49.000000Z",
        "_key": null
    }
}
 

Request   

DELETE api/v2/users/{id}

Headers

Authorization      

Example: Bearer {OPENID_CONNECT_TOKEN}

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

URL Parameters

id   string   

The ID of the user. Example: 0212d300-8534-11ed-828a-9d6be7cc0d7a

Restore User

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://base.stackflows.com/api/v2/users/0212d300-8534-11ed-828a-9d6be7cc0d7a/restore',
    [
        'headers' => [
            'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/users/0212d300-8534-11ed-828a-9d6be7cc0d7a/restore"
);

const headers = {
    "Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());
curl --request POST \
    "https://base.stackflows.com/api/v2/users/0212d300-8534-11ed-828a-9d6be7cc0d7a/restore" \
    --header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"

Example response (200):


{
    "data": {
        "name": "Myah",
        "surname": "Denesik",
        "email": "nbeier@example.org",
        "phone": "(904) 698-4669",
        "email_verified_at": "2021-03-17T01:46:35.000000Z",
        "_key": null
    }
}
 

Request   

POST api/v2/users/{user_id}/restore

Headers

Authorization      

Example: Bearer {OPENID_CONNECT_TOKEN}

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

URL Parameters

user_id   string   

The ID of the user. Example: 0212d300-8534-11ed-828a-9d6be7cc0d7a

Forms

List Forms

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://base.stackflows.com/api/v2/forms',
    [
        'headers' => [
            'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/forms"
);

const headers = {
    "Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "https://base.stackflows.com/api/v2/forms" \
    --header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"

Example response (200):


{
    "data": [
        {
            "organization_id": "524a7f90-c16a-11ee-96d8-8fe5e97a59f2",
            "name": "velit",
            "layout": [],
            "fields": [],
            "_key": null
        },
        {
            "organization_id": "52c4a820-c16a-11ee-b5c1-bfac784f1e8c",
            "name": "itaque",
            "layout": [],
            "fields": [],
            "_key": null
        }
    ]
}
 

Request   

GET api/v2/forms

Headers

Authorization      

Example: Bearer {OPENID_CONNECT_TOKEN}

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

Create Form

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://base.stackflows.com/api/v2/forms',
    [
        'headers' => [
            'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
        'json' => [
            'name' => 'consequatur',
            'layout' => [],
            'fields' => [],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/forms"
);

const headers = {
    "Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

let body = {
    "name": "consequatur",
    "layout": [],
    "fields": []
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request POST \
    "https://base.stackflows.com/api/v2/forms" \
    --header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx" \
    --data "{
    \"name\": \"consequatur\",
    \"layout\": [],
    \"fields\": []
}"

Example response (200):


{
    "data": {
        "organization_id": "534443d0-c16a-11ee-900b-775f14e56538",
        "name": "nesciunt",
        "layout": [],
        "fields": [],
        "_key": null
    }
}
 

Request   

POST api/v2/forms

Headers

Authorization      

Example: Bearer {OPENID_CONNECT_TOKEN}

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

Body Parameters

name   string   

Example: consequatur

layout   object   
fields   object   

View Form

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://base.stackflows.com/api/v2/forms/1a36dcf0-2c60-11ee-9f3c-a70088ee661c',
    [
        'headers' => [
            'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/forms/1a36dcf0-2c60-11ee-9f3c-a70088ee661c"
);

const headers = {
    "Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "https://base.stackflows.com/api/v2/forms/1a36dcf0-2c60-11ee-9f3c-a70088ee661c" \
    --header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"

Example response (200):


{
    "data": {
        "organization_id": "53c28270-c16a-11ee-a3fd-eb2b1afe8ac2",
        "name": "qui",
        "layout": [],
        "fields": [],
        "_key": null
    }
}
 

Request   

GET api/v2/forms/{id}

Headers

Authorization      

Example: Bearer {OPENID_CONNECT_TOKEN}

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

URL Parameters

id   string   

The ID of the form. Example: 1a36dcf0-2c60-11ee-9f3c-a70088ee661c

Update Form

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->put(
    'https://base.stackflows.com/api/v2/forms/1a36dcf0-2c60-11ee-9f3c-a70088ee661c',
    [
        'headers' => [
            'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
        'json' => [
            'name' => 'magnam',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/forms/1a36dcf0-2c60-11ee-9f3c-a70088ee661c"
);

const headers = {
    "Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

let body = {
    "name": "magnam"
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request PUT \
    "https://base.stackflows.com/api/v2/forms/1a36dcf0-2c60-11ee-9f3c-a70088ee661c" \
    --header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx" \
    --data "{
    \"name\": \"magnam\"
}"

Example response (200):


{
    "data": {
        "organization_id": "543f8560-c16a-11ee-9c6f-adb6e3fe5a2b",
        "name": "atque",
        "layout": [],
        "fields": [],
        "_key": null
    }
}
 

Request   

PUT api/v2/forms/{id}

PATCH api/v2/forms/{id}

Headers

Authorization      

Example: Bearer {OPENID_CONNECT_TOKEN}

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

URL Parameters

id   string   

The ID of the form. Example: 1a36dcf0-2c60-11ee-9f3c-a70088ee661c

Body Parameters

name   string  optional  

Example: magnam

layout   object  optional  
fields   object  optional  

Delete Form

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'https://base.stackflows.com/api/v2/forms/1a36dcf0-2c60-11ee-9f3c-a70088ee661c',
    [
        'headers' => [
            'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/forms/1a36dcf0-2c60-11ee-9f3c-a70088ee661c"
);

const headers = {
    "Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
curl --request DELETE \
    "https://base.stackflows.com/api/v2/forms/1a36dcf0-2c60-11ee-9f3c-a70088ee661c" \
    --header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"

Example response (200):


{
    "data": {
        "organization_id": "54bcfc00-c16a-11ee-b8ca-47cec0f0338a",
        "name": "nihil",
        "layout": [],
        "fields": [],
        "_key": null
    }
}
 

Request   

DELETE api/v2/forms/{id}

Headers

Authorization      

Example: Bearer {OPENID_CONNECT_TOKEN}

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

URL Parameters

id   string   

The ID of the form. Example: 1a36dcf0-2c60-11ee-9f3c-a70088ee661c

Tasks

List Tasks

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://base.stackflows.com/api/v2/tasks',
    [
        'headers' => [
            'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
        'query' => [
            'include'=> 'reservations,eligible_users,eligible_organization_units',
            'filter[name]'=> 'baba',
            'filter[eligible]'=> '1',
            'filter[active]'=> '1',
            'filter[due]'=> '1',
            'filter[due-today]'=> '1',
            'filter[process_instance]'=> '54fffd-445fd-fds55',
            'filter[engine_definition]'=> 'Activity_1n0qsrj',
            'filter[eligible_by_organization_units]'=> 'test1,test2',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/tasks"
);

const params = {
    "include": "reservations,eligible_users,eligible_organization_units",
    "filter[name]": "baba",
    "filter[eligible]": "1",
    "filter[active]": "1",
    "filter[due]": "1",
    "filter[due-today]": "1",
    "filter[process_instance]": "54fffd-445fd-fds55",
    "filter[engine_definition]": "Activity_1n0qsrj",
    "filter[eligible_by_organization_units]": "test1,test2",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "https://base.stackflows.com/api/v2/tasks?include=reservations%2Celigible_users%2Celigible_organization_units&filter%5Bname%5D=baba&filter%5Beligible%5D=1&filter%5Bactive%5D=1&filter%5Bdue%5D=1&filter%5Bdue-today%5D=1&filter%5Bprocess_instance%5D=54fffd-445fd-fds55&filter%5Bengine_definition%5D=Activity_1n0qsrj&filter%5Beligible_by_organization_units%5D=test1%2Ctest2" \
    --header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"

Example response (200):


{
    "data": [
        {
            "bounty": 10,
            "environment_id": "55b2cb40-c16a-11ee-85c8-6188b740fb6a",
            "engine_reference": "d0d13f41-23f6-3e77-8d44-628f4ca53113",
            "name": "Eos optio qui laudantium amet enim. Recusandae eaque quos quo est eligendi in unde eum. Porro harum qui dicta distinctio qui ipsa molestias dicta.",
            "description": "Caterpillar; and it was over at last, more calmly, though still sobbing a little before she had plenty of time as she spoke. (The unfortunate little Bill had left off writing on his spectacles and.",
            "fields": [],
            "fields_values": null,
            "follow_up_at": "2009-07-02T12:52:34.000000Z",
            "due_at": "2011-05-05T20:54:57.000000Z",
            "current_user_active_reservation": null,
            "_key": null
        },
        {
            "bounty": 10,
            "environment_id": "5645de80-c16a-11ee-be3c-45ef5e541318",
            "engine_reference": "31a79990-dadf-3f3f-8e34-c906cd6b1cba",
            "name": "Tempore quis saepe non dolor. Sapiente assumenda id velit similique. Eius molestiae maiores animi rerum earum qui. Qui omnis cum dolorem.",
            "description": "Duchess: 'what a clear way you go,' said the King; and the great question is, what did the Dormouse began in a low trembling voice, '--and I hadn't to bring tears into her eyes--and still as she.",
            "fields": [],
            "fields_values": null,
            "follow_up_at": "1982-03-22T14:11:26.000000Z",
            "due_at": "1995-03-21T17:35:28.000000Z",
            "current_user_active_reservation": null,
            "_key": null
        }
    ]
}
 

Request   

GET api/v2/tasks

Headers

Authorization      

Example: Bearer {OPENID_CONNECT_TOKEN}

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

Query Parameters

include   string  optional  

List of includes separated by comma. Example: reservations,eligible_users,eligible_organization_units

filter[name]   string  optional  

List only those tasks that contains specified string in their name. Example: baba

filter[eligible]   boolean  optional  

List only eligible tasks for current user. Example: true

filter[active]   boolean  optional  

List only active tasks. Example: true

filter[due]   boolean  optional  

List only due tasks. Example: true

filter[due-today]   boolean  optional  

List only tasks that will bocome due today. Example: true

filter[process_instance]   string  optional  

List only specific process instance tasks. Example: 54fffd-445fd-fds55

filter[engine_definition]   string  optional  

List tasks by engine task definition. Example: Activity_1n0qsrj

filter[eligible_by_organization_units]   string  optional  

List only eligible tasks for specified organization units by reference. Example: test1,test2

View Task

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://base.stackflows.com/api/v2/tasks/rerum',
    [
        'headers' => [
            'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
        'query' => [
            'include'=> 'reservations,eligible_users,eligible_organization_units',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/tasks/rerum"
);

const params = {
    "include": "reservations,eligible_users,eligible_organization_units",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "https://base.stackflows.com/api/v2/tasks/rerum?include=reservations%2Celigible_users%2Celigible_organization_units" \
    --header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"

Example response (200):


{
    "data": {
        "bounty": 10,
        "environment_id": "56c5e330-c16a-11ee-9d46-71677ae06f6f",
        "engine_reference": "cef7ef41-2be4-3508-a540-0d747280127d",
        "name": "Consequatur quae et minus corrupti asperiores. Vel dolor hic itaque ut nesciunt alias.",
        "description": "I think I could, if I shall never get to the beginning again?' Alice ventured to say. 'What is his sorrow?' she asked the Gryphon, and the other two were using it as to bring tears into her eyes.",
        "fields": [],
        "fields_values": null,
        "follow_up_at": "1987-07-25T03:27:25.000000Z",
        "due_at": "1995-05-18T22:26:49.000000Z",
        "current_user_active_reservation": null,
        "_key": null
    }
}
 

Request   

GET api/v2/tasks/{id}

Headers

Authorization      

Example: Bearer {OPENID_CONNECT_TOKEN}

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

URL Parameters

id   string   

The ID of the task. Example: rerum

Query Parameters

include   string  optional  

List of includes separated by comma. Example: reservations,eligible_users,eligible_organization_units

Reserve Task

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://base.stackflows.com/api/v2/tasks/autem/reservation',
    [
        'headers' => [
            'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/tasks/autem/reservation"
);

const headers = {
    "Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());
curl --request POST \
    "https://base.stackflows.com/api/v2/tasks/autem/reservation" \
    --header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"

Example response (200):


{
    "data": {
        "bounty": 10,
        "environment_id": "57403c80-c16a-11ee-b660-637ee87982d1",
        "engine_reference": "d2377ac2-7d15-3314-ae72-cf2fef2adebe",
        "name": "Quia quidem in dolores labore eveniet. Est nam nisi officiis et. Velit officiis voluptates ipsa soluta non cumque quo aut. Autem similique nulla odio incidunt hic delectus.",
        "description": "KNOW IT TO BE TRUE--\" that's the jury, of course--\"I GAVE HER ONE, THEY GAVE HIM TWO--\" why, that must be what he did with the strange creatures of her head struck against the roof of the hall: in.",
        "fields": [],
        "fields_values": null,
        "follow_up_at": "2010-07-27T11:10:26.000000Z",
        "due_at": "2001-10-20T04:11:10.000000Z",
        "current_user_active_reservation": null,
        "_key": null
    }
}
 

Request   

POST api/v2/tasks/{task_id}/reservation

Headers

Authorization      

Example: Bearer {OPENID_CONNECT_TOKEN}

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

URL Parameters

task_id   string   

The ID of the task. Example: autem

Unreserve Task

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'https://base.stackflows.com/api/v2/tasks/voluptas/reservation',
    [
        'headers' => [
            'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/tasks/voluptas/reservation"
);

const headers = {
    "Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
curl --request DELETE \
    "https://base.stackflows.com/api/v2/tasks/voluptas/reservation" \
    --header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"

Example response (200):


{
    "data": {
        "bounty": 10,
        "environment_id": "57bf4770-c16a-11ee-b6ed-7da24f033e14",
        "engine_reference": "1e3f45a5-4080-3ff6-b627-298f854fce13",
        "name": "Dolore fugit natus minima eum. Ea aut expedita ut est velit architecto aut. Consequuntur quia libero occaecati non dolores.",
        "description": "She had quite forgotten the Duchess sang the second time round, she found she had caught the baby violently up and walking off to the Mock Turtle. 'She can't explain it,' said the cook. The King.",
        "fields": [],
        "fields_values": null,
        "follow_up_at": "1977-10-26T20:38:33.000000Z",
        "due_at": "1983-08-16T00:06:03.000000Z",
        "current_user_active_reservation": null,
        "_key": null
    }
}
 

Request   

DELETE api/v2/tasks/{task_id}/reservation

Headers

Authorization      

Example: Bearer {OPENID_CONNECT_TOKEN}

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

URL Parameters

task_id   string   

The ID of the task. Example: voluptas

Complete Task

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://base.stackflows.com/api/v2/tasks/consectetur/complete',
    [
        'headers' => [
            'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/tasks/consectetur/complete"
);

const headers = {
    "Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());
curl --request POST \
    "https://base.stackflows.com/api/v2/tasks/consectetur/complete" \
    --header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx" \

Example response (200):


{
    "data": {
        "bounty": 10,
        "environment_id": "583d3ae0-c16a-11ee-9d30-7116a303fad7",
        "engine_reference": "a9e10d62-3465-3cae-9ad5-c6ce35bf437e",
        "name": "Ducimus nam non rem quia iure illo minus. Unde perferendis aut aliquam est facilis nihil excepturi. Odit ut placeat ipsa assumenda incidunt.",
        "description": "The master was an old Turtle--we used to say it over) '--yes, that's about the games now.' CHAPTER X. The Lobster Quadrille is!' 'No, indeed,' said Alice. 'Why?' 'IT DOES THE BOOTS AND SHOES.' the.",
        "fields": [],
        "fields_values": null,
        "follow_up_at": "1996-11-04T08:33:43.000000Z",
        "due_at": "1982-07-28T13:31:02.000000Z",
        "current_user_active_reservation": null,
        "_key": null
    }
}
 

Request   

POST api/v2/tasks/{task_id}/complete

Headers

Authorization      

Example: Bearer {OPENID_CONNECT_TOKEN}

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

URL Parameters

task_id   string   

The ID of the task. Example: consectetur

Body Parameters

submission   string[]  optional  

Analyses

List Analyses

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://base.stackflows.com/api/v2/analyses',
    [
        'headers' => [
            'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
        'json' => [
            'references' => [
                'neque',
            ],
            'time_range_start' => '2024-02-02T01:28:18',
            'time_range_end' => '2024-02-02T01:28:18',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/analyses"
);

const headers = {
    "Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

let body = {
    "references": [
        "neque"
    ],
    "time_range_start": "2024-02-02T01:28:18",
    "time_range_end": "2024-02-02T01:28:18"
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request GET \
    --get "https://base.stackflows.com/api/v2/analyses" \
    --header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx" \
    --data "{
    \"references\": [
        \"neque\"
    ],
    \"time_range_start\": \"2024-02-02T01:28:18\",
    \"time_range_end\": \"2024-02-02T01:28:18\"
}"

Example response (403):

Show headers
cache-control: no-cache, private
content-type: application/json
vary: Origin
 

{
    "message": "Tenant header is missing or is invalid"
}
 

Request   

GET api/v2/analyses

Headers

Authorization      

Example: Bearer {OPENID_CONNECT_TOKEN}

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

Body Parameters

references   string[]   
time_range_start   string  optional  

Must be a valid date. Example: 2024-02-02T01:28:18

time_range_end   string  optional  

Must be a valid date. Example: 2024-02-02T01:28:18

List Analyses

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://base.stackflows.com/api/v2/summaries',
    [
        'headers' => [
            'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
        'json' => [
            'references' => [
                'sint',
            ],
            'time_range_start' => '2024-02-02T01:28:18',
            'time_range_end' => '2024-02-02T01:28:18',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/summaries"
);

const headers = {
    "Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

let body = {
    "references": [
        "sint"
    ],
    "time_range_start": "2024-02-02T01:28:18",
    "time_range_end": "2024-02-02T01:28:18"
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request GET \
    --get "https://base.stackflows.com/api/v2/summaries" \
    --header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx" \
    --data "{
    \"references\": [
        \"sint\"
    ],
    \"time_range_start\": \"2024-02-02T01:28:18\",
    \"time_range_end\": \"2024-02-02T01:28:18\"
}"

Example response (403):

Show headers
cache-control: no-cache, private
content-type: application/json
vary: Origin
 

{
    "message": "Tenant header is missing or is invalid"
}
 

Request   

GET api/v2/summaries

Headers

Authorization      

Example: Bearer {OPENID_CONNECT_TOKEN}

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

Body Parameters

references   string[]   
time_range_start   string  optional  

Must be a valid date. Example: 2024-02-02T01:28:18

time_range_end   string  optional  

Must be a valid date. Example: 2024-02-02T01:28:18

Environment

Business Process Instances

List Business Process Instances

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://base.stackflows.com/api/v2/environment/blanditiis/business-process-instances',
    [
        'headers' => [
            'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
        'json' => [
            'activities' => [
                'ad',
            ],
            'active_only' => true,
            'sort_by' => 'repellat',
            'sort_order' => 'desc',
            'page' => [
                'number' => 18,
                'size' => 10,
            ],
            'publication_engine_diagram_reference' => 'quasi',
            'publication_engine_model_reference' => 'aperiam',
            'publication_engine_deployment_reference' => 'quod',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/environment/blanditiis/business-process-instances"
);

const headers = {
    "Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

let body = {
    "activities": [
        "ad"
    ],
    "active_only": true,
    "sort_by": "repellat",
    "sort_order": "desc",
    "page": {
        "number": 18,
        "size": 10
    },
    "publication_engine_diagram_reference": "quasi",
    "publication_engine_model_reference": "aperiam",
    "publication_engine_deployment_reference": "quod"
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request GET \
    --get "https://base.stackflows.com/api/v2/environment/blanditiis/business-process-instances" \
    --header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx" \
    --data "{
    \"activities\": [
        \"ad\"
    ],
    \"active_only\": true,
    \"sort_by\": \"repellat\",
    \"sort_order\": \"desc\",
    \"page\": {
        \"number\": 18,
        \"size\": 10
    },
    \"publication_engine_diagram_reference\": \"quasi\",
    \"publication_engine_model_reference\": \"aperiam\",
    \"publication_engine_deployment_reference\": \"quod\"
}"

Example response (200):


{
    "data": [
        {
            "reference": "dolore",
            "startedAt": {
                "date": "1983-08-25 10:48:27.000000",
                "timezone_type": 3,
                "timezone": "UTC"
            },
            "endedAt": {
                "date": "1977-01-22 04:24:06.000000",
                "timezone_type": 3,
                "timezone": "UTC"
            },
            "publication": {
                "business_model_diagram_id": "29fc0530-c16a-11ee-90e2-91782c57d6b1",
                "engine_deployment_reference": "df571db3-345a-3a68-a930-928a6c49fb4c",
                "engine_diagram_reference": "6ba38f9d-8a24-38e9-a211-517721965701",
                "engine_model_reference": "Process_QuiaEstEt."
            },
            "context": "id",
            "attributes": []
        },
        {
            "reference": "dolorem",
            "startedAt": {
                "date": "2022-12-29 08:12:33.000000",
                "timezone_type": 3,
                "timezone": "UTC"
            },
            "endedAt": {
                "date": "1982-07-13 23:17:53.000000",
                "timezone_type": 3,
                "timezone": "UTC"
            },
            "publication": {
                "business_model_diagram_id": "2c5de320-c16a-11ee-ba40-ff11e98e5c68",
                "engine_deployment_reference": "25ee6683-62cb-3e34-915e-4d74ab40ed88",
                "engine_diagram_reference": "fa250f11-cc89-3cc1-ada4-cb2af4170b11",
                "engine_model_reference": "Process_QuidemUllam."
            },
            "context": "quis",
            "attributes": []
        }
    ]
}
 

Request   

GET api/v2/environment/{environment_id}/business-process-instances

Headers

Authorization      

Example: Bearer {OPENID_CONNECT_TOKEN}

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

URL Parameters

environment_id   string   

The ID of the environment. Example: blanditiis

Body Parameters

activities   string[]  optional  
active_only   boolean  optional  

Example: true

sort_by   string  optional  

Example: repellat

sort_order   string  optional  

Must be one of asc or desc. Example: desc

page   object  optional  
number   integer  optional  

Example: 18

size   integer  optional  

Example: 10

publication_engine_diagram_reference   string  optional  

Example: quasi

publication_engine_model_reference   string  optional  

Example: aperiam

publication_engine_deployment_reference   string  optional  

Example: quod

View Business Process Instance

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://base.stackflows.com/api/v2/environment/et/business-process-instances/quo',
    [
        'headers' => [
            'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/environment/et/business-process-instances/quo"
);

const headers = {
    "Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "https://base.stackflows.com/api/v2/environment/et/business-process-instances/quo" \
    --header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"

Example response (200):


{
    "data": {
        "reference": "quia",
        "startedAt": {
            "date": "2003-02-04 03:32:16.000000",
            "timezone_type": 3,
            "timezone": "UTC"
        },
        "endedAt": {
            "date": "1985-07-15 07:51:36.000000",
            "timezone_type": 3,
            "timezone": "UTC"
        },
        "publication": {
            "business_model_diagram_id": "2e855640-c16a-11ee-a9a7-17e1472d2087",
            "engine_deployment_reference": "cd197594-d1c6-3d2b-b12d-6c3a28c5071a",
            "engine_diagram_reference": "b02f9117-f1a6-3291-8601-464068f94a7d",
            "engine_model_reference": "Process_MagniMinima."
        },
        "context": "harum",
        "attributes": []
    }
}
 

Request   

GET api/v2/environment/{environment_id}/business-process-instances/{id}

Headers

Authorization      

Example: Bearer {OPENID_CONNECT_TOKEN}

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

URL Parameters

environment_id   string   

The ID of the environment. Example: et

id   string   

The ID of the business process instance. Example: quo

Business Activity Instances

List Business Activity Instances

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://base.stackflows.com/api/v2/environment/dignissimos/business-activity-instances',
    [
        'headers' => [
            'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
        'json' => [
            'activity_reference' => 'architecto',
            'processed' => false,
            'sort_by' => 'est',
            'sort_order' => 'desc',
            'page' => [
                'number' => 2,
                'size' => 12,
            ],
            'diagram_engine_reference' => 'sed',
            'process_instance_reference' => 'eaque',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/environment/dignissimos/business-activity-instances"
);

const headers = {
    "Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

let body = {
    "activity_reference": "architecto",
    "processed": false,
    "sort_by": "est",
    "sort_order": "desc",
    "page": {
        "number": 2,
        "size": 12
    },
    "diagram_engine_reference": "sed",
    "process_instance_reference": "eaque"
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request GET \
    --get "https://base.stackflows.com/api/v2/environment/dignissimos/business-activity-instances" \
    --header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx" \
    --data "{
    \"activity_reference\": \"architecto\",
    \"processed\": false,
    \"sort_by\": \"est\",
    \"sort_order\": \"desc\",
    \"page\": {
        \"number\": 2,
        \"size\": 12
    },
    \"diagram_engine_reference\": \"sed\",
    \"process_instance_reference\": \"eaque\"
}"

Example response (200):


{
    "data": [
        {
            "reference": "omnis",
            "name": "sit",
            "type": "tempora",
            "startedAt": {
                "date": "2014-09-03 20:36:20.000000",
                "timezone_type": 3,
                "timezone": "UTC"
            },
            "endedAt": {
                "date": "1984-01-14 03:32:47.000000",
                "timezone_type": 3,
                "timezone": "UTC"
            },
            "processInstance": {
                "reference": "recusandae",
                "startedAt": {
                    "date": "1977-10-01 04:39:37.000000",
                    "timezone_type": 3,
                    "timezone": "UTC"
                },
                "endedAt": {
                    "date": "1988-02-01 13:29:56.000000",
                    "timezone_type": 3,
                    "timezone": "UTC"
                },
                "publication": {
                    "business_model_diagram_id": "30a58c60-c16a-11ee-a96e-f55da3976208",
                    "engine_deployment_reference": "9f8b38da-90be-3da2-b09e-a938b083d77b",
                    "engine_diagram_reference": "ac8d9f0e-a138-34fb-a8ce-66aeb92c28bb",
                    "engine_model_reference": "Process_Voluptatibus."
                },
                "context": "voluptas",
                "attributes": []
            }
        },
        {
            "reference": "nihil",
            "name": "doloribus",
            "type": "non",
            "startedAt": {
                "date": "1985-10-14 07:55:12.000000",
                "timezone_type": 3,
                "timezone": "UTC"
            },
            "endedAt": {
                "date": "1977-01-14 22:33:53.000000",
                "timezone_type": 3,
                "timezone": "UTC"
            },
            "processInstance": {
                "reference": "temporibus",
                "startedAt": {
                    "date": "1975-09-20 04:37:38.000000",
                    "timezone_type": 3,
                    "timezone": "UTC"
                },
                "endedAt": {
                    "date": "1991-02-19 05:54:21.000000",
                    "timezone_type": 3,
                    "timezone": "UTC"
                },
                "publication": {
                    "business_model_diagram_id": "32b760a0-c16a-11ee-8828-f98cfb91142f",
                    "engine_deployment_reference": "c2ca05cf-0ae4-32f1-be2b-82bde5227aba",
                    "engine_diagram_reference": "b2e221b0-fbd8-3fc5-b1df-0a35ef6a1886",
                    "engine_model_reference": "Process_UtExplicabo."
                },
                "context": "repudiandae",
                "attributes": []
            }
        }
    ]
}
 

Request   

GET api/v2/environment/{environment_id}/business-activity-instances

Headers

Authorization      

Example: Bearer {OPENID_CONNECT_TOKEN}

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

URL Parameters

environment_id   string   

The ID of the environment. Example: dignissimos

Body Parameters

activity_reference   string  optional  

Example: architecto

processed   boolean  optional  

Example: false

sort_by   string  optional  

Example: est

sort_order   string  optional  

Must be one of asc or desc. Example: desc

page   object  optional  
number   integer  optional  

Example: 2

size   integer  optional  

Example: 12

diagram_engine_reference   string  optional  

Example: sed

process_instance_reference   string  optional  

Example: eaque

View Business Activity Instance

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://base.stackflows.com/api/v2/environment/aut/business-activity-instances/pariatur',
    [
        'headers' => [
            'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/environment/aut/business-activity-instances/pariatur"
);

const headers = {
    "Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "https://base.stackflows.com/api/v2/environment/aut/business-activity-instances/pariatur" \
    --header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"

Example response (200):


{
    "data": {
        "reference": "consequatur",
        "name": "est",
        "type": "nesciunt",
        "startedAt": {
            "date": "1992-01-01 14:33:02.000000",
            "timezone_type": 3,
            "timezone": "UTC"
        },
        "endedAt": {
            "date": "1997-04-21 04:45:38.000000",
            "timezone_type": 3,
            "timezone": "UTC"
        },
        "processInstance": {
            "reference": "est",
            "startedAt": {
                "date": "2018-05-10 08:38:56.000000",
                "timezone_type": 3,
                "timezone": "UTC"
            },
            "endedAt": {
                "date": "2009-08-02 11:44:39.000000",
                "timezone_type": 3,
                "timezone": "UTC"
            },
            "publication": {
                "business_model_diagram_id": "34d21950-c16a-11ee-8377-999830aa47f9",
                "engine_deployment_reference": "d9678a42-f15e-3ba2-8ec5-b4ba26cdc9b2",
                "engine_diagram_reference": "c85d2fa4-8743-35a5-93e3-5f5f91209e82",
                "engine_model_reference": "Process_AutemIpsam."
            },
            "context": "hic",
            "attributes": []
        }
    }
}
 

Request   

GET api/v2/environment/{environment_id}/business-activity-instances/{id}

Headers

Authorization      

Example: Bearer {OPENID_CONNECT_TOKEN}

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

URL Parameters

environment_id   string   

The ID of the environment. Example: aut

id   string   

The ID of the business activity instance. Example: pariatur

Events

POST api/v2/environment/{environment_id}/events/{reference}/send-message

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://base.stackflows.com/api/v2/environment/est/events/ipsam/send-message',
    [
        'headers' => [
            'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/environment/est/events/ipsam/send-message"
);

const headers = {
    "Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());
curl --request POST \
    "https://base.stackflows.com/api/v2/environment/est/events/ipsam/send-message" \
    --header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"

Request   

POST api/v2/environment/{environment_id}/events/{reference}/send-message

Headers

Authorization      

Example: Bearer {OPENID_CONNECT_TOKEN}

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

URL Parameters

environment_id   string   

The ID of the environment. Example: est

reference   string   

Example: ipsam

POST api/v2/environment/{environment_id}/events/{reference}/send-signal

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://base.stackflows.com/api/v2/environment/eveniet/events/molestiae/send-signal',
    [
        'headers' => [
            'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/environment/eveniet/events/molestiae/send-signal"
);

const headers = {
    "Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());
curl --request POST \
    "https://base.stackflows.com/api/v2/environment/eveniet/events/molestiae/send-signal" \
    --header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"

Request   

POST api/v2/environment/{environment_id}/events/{reference}/send-signal

Headers

Authorization      

Example: Bearer {OPENID_CONNECT_TOKEN}

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

URL Parameters

environment_id   string   

The ID of the environment. Example: eveniet

reference   string   

Example: molestiae

Service Tasks

List Service Tasks

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://base.stackflows.com/api/v2/environment/consequatur/service-tasks',
    [
        'headers' => [
            'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
        'json' => [
            'topic' => 'consequatur',
            'activities' => [
                'aspernatur',
            ],
            'active_only' => true,
            'sort_by' => 'et',
            'sort_order' => 'asc',
            'page' => [
                'number' => 1,
                'size' => 13,
            ],
            'process_instance_references' => [
                'fuga',
            ],
            'publication_engine_diagram_reference' => 'delectus',
            'publication_engine_model_reference' => 'omnis',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/environment/consequatur/service-tasks"
);

const headers = {
    "Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

let body = {
    "topic": "consequatur",
    "activities": [
        "aspernatur"
    ],
    "active_only": true,
    "sort_by": "et",
    "sort_order": "asc",
    "page": {
        "number": 1,
        "size": 13
    },
    "process_instance_references": [
        "fuga"
    ],
    "publication_engine_diagram_reference": "delectus",
    "publication_engine_model_reference": "omnis"
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request GET \
    --get "https://base.stackflows.com/api/v2/environment/consequatur/service-tasks" \
    --header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx" \
    --data "{
    \"topic\": \"consequatur\",
    \"activities\": [
        \"aspernatur\"
    ],
    \"active_only\": true,
    \"sort_by\": \"et\",
    \"sort_order\": \"asc\",
    \"page\": {
        \"number\": 1,
        \"size\": 13
    },
    \"process_instance_references\": [
        \"fuga\"
    ],
    \"publication_engine_diagram_reference\": \"delectus\",
    \"publication_engine_model_reference\": \"omnis\"
}"

Example response (200):


{
    "data": [
        {
            "reference": "id",
            "topic": "excepturi",
            "suspended": false,
            "priority": 798803917,
            "environment": {
                "engine_id": "3556b160-c16a-11ee-8cf9-2963f09ea677",
                "engine_reference": "3c09208e-1715-3f13-912d-e239d814c530",
                "production": false,
                "name": "unde",
                "auth_token": "f9596ca7-d3ba-3905-b5ac-9ce1225ef7b3"
            },
            "activity": {
                "name": "exercitationem",
                "reference": "quasi"
            },
            "instance": {
                "reference": "voluptatem",
                "startedAt": {
                    "date": "2019-02-04 20:12:47.000000",
                    "timezone_type": 3,
                    "timezone": "UTC"
                },
                "endedAt": {
                    "date": "1970-12-30 19:13:04.000000",
                    "timezone_type": 3,
                    "timezone": "UTC"
                },
                "publication": {
                    "business_model_diagram_id": "377987f0-c16a-11ee-b554-e5007547dd07",
                    "engine_deployment_reference": "3ef496e4-6d0a-3769-8942-0890d001dbb8",
                    "engine_diagram_reference": "af2c34b5-0e0c-3158-9b91-0248d87e0b44",
                    "engine_model_reference": "Process_IustoAccusantium."
                },
                "context": "quaerat",
                "attributes": []
            },
            "attributes": []
        },
        {
            "reference": "natus",
            "topic": "optio",
            "suspended": false,
            "priority": 39931,
            "environment": {
                "engine_id": "38042fd0-c16a-11ee-bad3-2badfb06e9b5",
                "engine_reference": "2da6f49c-4a3c-3659-8897-8cd5b49e015f",
                "production": false,
                "name": "voluptas",
                "auth_token": "a53bea65-eaea-3056-8ba9-7d37cc6de826"
            },
            "activity": {
                "name": "atque",
                "reference": "veniam"
            },
            "instance": {
                "reference": "officiis",
                "startedAt": {
                    "date": "2014-05-16 15:47:27.000000",
                    "timezone_type": 3,
                    "timezone": "UTC"
                },
                "endedAt": {
                    "date": "1979-03-04 11:32:36.000000",
                    "timezone_type": 3,
                    "timezone": "UTC"
                },
                "publication": {
                    "business_model_diagram_id": "3a49a1f0-c16a-11ee-9f3d-273e0a8c0aab",
                    "engine_deployment_reference": "285b6d43-891e-3570-8980-8492a477fd70",
                    "engine_diagram_reference": "f4ac9010-4b90-317e-8899-1f2336d9e805",
                    "engine_model_reference": "Process_EosBeataeEt."
                },
                "context": "voluptas",
                "attributes": []
            },
            "attributes": []
        }
    ]
}
 

Request   

GET api/v2/environment/{environment_id}/service-tasks

Headers

Authorization      

Example: Bearer {OPENID_CONNECT_TOKEN}

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

URL Parameters

environment_id   string   

The ID of the environment. Example: consequatur

Body Parameters

topic   string  optional  

Example: consequatur

activities   string[]  optional  
active_only   boolean  optional  

Example: true

sort_by   string  optional  

Example: et

sort_order   string  optional  

Must be one of asc or desc. Example: asc

page   object  optional  
number   integer  optional  

Example: 1

size   integer  optional  

Example: 13

process_instance_references   string[]  optional  
publication_engine_diagram_reference   string  optional  

Example: delectus

publication_engine_model_reference   string  optional  

Example: omnis

Lock a Service Task

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://base.stackflows.com/api/v2/environment/quibusdam/service-tasks/voluptate/lock',
    [
        'headers' => [
            'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/environment/quibusdam/service-tasks/voluptate/lock"
);

const headers = {
    "Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());
curl --request POST \
    "https://base.stackflows.com/api/v2/environment/quibusdam/service-tasks/voluptate/lock" \
    --header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"

Example response (200):


{
    "data": {
        "reference": "vel",
        "topic": "maiores",
        "suspended": true,
        "priority": 780403949,
        "environment": {
            "engine_id": "3ad664d0-c16a-11ee-922e-8fcf7dd4f5e1",
            "engine_reference": "e6ceeb91-3ef3-3b32-975b-f4dae1925848",
            "production": false,
            "name": "sed",
            "auth_token": "a9fcd589-b742-3fee-8642-50ef7f98de24"
        },
        "activity": {
            "name": "illo",
            "reference": "ipsa"
        },
        "instance": {
            "reference": "voluptatibus",
            "startedAt": {
                "date": "1972-08-11 08:50:05.000000",
                "timezone_type": 3,
                "timezone": "UTC"
            },
            "endedAt": {
                "date": "1990-03-06 19:12:23.000000",
                "timezone_type": 3,
                "timezone": "UTC"
            },
            "publication": {
                "business_model_diagram_id": "3ce4fec0-c16a-11ee-a917-8b1f5de2a494",
                "engine_deployment_reference": "1b1e7d01-e556-3103-9b05-187f0b104f79",
                "engine_diagram_reference": "281efa80-0a3a-30cf-abdf-943dc4df0de8",
                "engine_model_reference": "Process_VoluptasQuisAut."
            },
            "context": "quis",
            "attributes": []
        },
        "attributes": []
    }
}
 

Request   

POST api/v2/environment/{environment_id}/service-tasks/{reference}/lock

Headers

Authorization      

Example: Bearer {OPENID_CONNECT_TOKEN}

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

URL Parameters

environment_id   string   

The ID of the environment. Example: quibusdam

reference   string   

Example: voluptate

Unlock a Service Task

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://base.stackflows.com/api/v2/environment/officiis/service-tasks/possimus/unlock',
    [
        'headers' => [
            'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/environment/officiis/service-tasks/possimus/unlock"
);

const headers = {
    "Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());
curl --request POST \
    "https://base.stackflows.com/api/v2/environment/officiis/service-tasks/possimus/unlock" \
    --header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"

Example response (200):


{
    "data": {
        "reference": "tenetur",
        "topic": "similique",
        "suspended": false,
        "priority": 8951637,
        "environment": {
            "engine_id": "3d669010-c16a-11ee-b779-3b1391a7d995",
            "engine_reference": "5acc470c-3704-3232-b5d9-58ef5255ee9f",
            "production": false,
            "name": "qui",
            "auth_token": "bd96175d-17f4-33a0-a146-3d54d052a95b"
        },
        "activity": {
            "name": "harum",
            "reference": "delectus"
        },
        "instance": {
            "reference": "maiores",
            "startedAt": {
                "date": "1975-10-25 20:43:52.000000",
                "timezone_type": 3,
                "timezone": "UTC"
            },
            "endedAt": {
                "date": "1970-07-24 08:30:43.000000",
                "timezone_type": 3,
                "timezone": "UTC"
            },
            "publication": {
                "business_model_diagram_id": "3f745aa0-c16a-11ee-a490-f3baaec8ffe7",
                "engine_deployment_reference": "e6170143-8d1c-364e-84e6-455ae2ad9c63",
                "engine_diagram_reference": "4136fad8-8351-3101-b8b8-0e6252b9c7d5",
                "engine_model_reference": "Process_VelNisiQuasiAut."
            },
            "context": "dolore",
            "attributes": []
        },
        "attributes": []
    }
}
 

Request   

POST api/v2/environment/{environment_id}/service-tasks/{reference}/unlock

Headers

Authorization      

Example: Bearer {OPENID_CONNECT_TOKEN}

Content-Type      

Example: application/json

Accept      

Example: application/json

X-Tenant      

Example: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx

URL Parameters

environment_id   string   

The ID of the environment. Example: officiis

reference   string   

Example: possimus

Serve a Service Task

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://base.stackflows.com/api/v2/environment/possimus/service-tasks/nulla/serve',
    [
        'headers' => [
            'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
        ],
        'json' => [
            'submission' => [
                'assumenda',
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "https://base.stackflows.com/api/v2/environment/possimus/service-tasks/nulla/serve"
);

const headers = {
    "Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};

let body = {
    "submission": [
        "assumenda"
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request POST \
    "https://base.stackflows.com/api/v2/environment/possimus/service-tasks/nulla/serve" \
    --header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx" \
    --data "{
    \"submission\": [
        \"assumenda\"
    ]
}"

Example response (200):


{
    "data": {
        "reference": "et",
        "topic": "nobis",
        "suspended": false,
        "priority": 70,
        "environment": {
            "engine_id": "400bb170-c16a-11ee-935e-97405198a454",
            "engine_reference": "dc21c2d1-1b4e-3c0e-bc32-1ae953a51ee0",
            "production": true,
            "name": "ea",
            "auth_token": "326eef64-ce13-3a9c-a732-a331ef2a215e"
        },
        "activity": {
            "name": "aut",
            "reference": "ut"
        },
        "instance": {
            "reference": "facilis",
            "startedAt": {
                "date": "1984-03-06 04:17:36.000000",
                "timezone_type": 3,
                "timezone": "UTC"
            },
            "endedAt": {
                "date": "2014-11-11 07:00:13.000000",
                "timezone_type": 3,
                "timezone": "UTC"
            },
            "p