MENU navbar-image

Introduction

100% Light api for storing article information and exporting to Navision

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 {YOUR_AUTH_KEY}".

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

Authentication tokens can be requested using the proper channels, please visit Guideline Belgium for more information.

Article

Article api calls. To create, edit, delete, etc. articles.

Copy

requires authentication

Create a new article by copying another one

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://api.100p.xcs.be/api/v1/articles',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'Accept-Encoding' => 'gzip, deflate, br',
            'Connection' => 'keep-alive',
        ],
        'json' => [
            'customNumber' => '"12411116-copy"',
            'F_1' => '"12411116"',
            'F_*' => '"F_5"',
            'C_*' => '"C_75015"',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
curl --request POST \
    "https://api.100p.xcs.be/api/v1/articles" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "Accept-Encoding: gzip, deflate, br" \
    --header "Connection: keep-alive" \
    --data "{
    \"customNumber\": \"\\\"12411116-copy\\\"\",
    \"F_1\": \"\\\"12411116\\\"\",
    \"F_*\": \"\\\"F_5\\\"\",
    \"C_*\": \"\\\"C_75015\\\"\"
}"

const url = new URL(
    "https://api.100p.xcs.be/api/v1/articles"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "Accept-Encoding": "gzip, deflate, br",
    "Connection": "keep-alive",
};

let body = {
    "customNumber": "\"12411116-copy\"",
    "F_1": "\"12411116\"",
    "F_*": "\"F_5\"",
    "C_*": "\"C_75015\""
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
import requests
import json

url = 'https://api.100p.xcs.be/api/v1/articles'
payload = {
    "customNumber": "\"12411116-copy\"",
    "F_1": "\"12411116\"",
    "F_*": "\"F_5\"",
    "C_*": "\"C_75015\""
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Accept-Encoding': 'gzip, deflate, br',
  'Connection': 'keep-alive'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Example response (200):


{
    "status": "success",
    "message": "Copy successfully created",
    "data": {
        "id": "12411116-copy",
        "F_1": "12411116-copy",
        "F_3": "BH30-IP20-LG08-CRI90-6,1W-4K-BM45°-RFL-WHT-IDD350mADC(DALI)",
        "F_5": "",
        "F_80000": "BULLET HOLE 30 - IP20 - LED G08 - CRI 90 - 6,1 W - 4000K - BEAM 45°-REFLECTOR",
        "F_80001": "MATT WHITE TEXTURED - INCL. DIM. DRIVER 350mA DC (DALI)",
        "F_80002": "",
        "F_80003": "",
        "F_80007": "",
        "C_75048": "BULLET HOLE",
        "C_75027": "BULLET HOLE 30",
        "C_75000": "INDOOR",
        "C_75001": "CEILING",
        "F_80006": "20/06/2022"
    }
}

Example response (401):


{
    "status": "error",
    "message": "Message describing the error",
    "data": null
}

Request   

POST api/v1/articles

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Accept-Encoding      

Example: gzip, deflate, br

Connection      

Example: keep-alive

Body Parameters

customNumber   string   

The new article number for copy. Example: "12411116-copy"

F_1   string   

The article number to copy. Example: "12411116"

F_*   string  optional  

optional Params to add or overrule on the copy for "F" params. Example: "F_5"

C_*   string  optional  

optional Params to add or overrule on the copy for "C" params. Example: "C_75015"

Delta Update

requires authentication

Call articles delta updates routine This will add jobs to the queue to handle the file and all operations therein

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://api.100p.xcs.be/api/v1/articles/delta-update',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'Accept-Encoding' => 'gzip, deflate, br',
            'Connection' => 'keep-alive',
        ],
        'json' => [
            'file' => '"http://localhost/data/test.TestHandleSyncRequestMix.json"',
            'files' => '"[http://localhost/data/test.TestHandleSyncRequestMix.json, http://localhost/data/test.TestHandleSyncRequestMix2.json]"',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
curl --request POST \
    "https://api.100p.xcs.be/api/v1/articles/delta-update" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "Accept-Encoding: gzip, deflate, br" \
    --header "Connection: keep-alive" \
    --data "{
    \"file\": \"\\\"http:\\/\\/localhost\\/data\\/test.TestHandleSyncRequestMix.json\\\"\",
    \"files\": \"\\\"[http:\\/\\/localhost\\/data\\/test.TestHandleSyncRequestMix.json, http:\\/\\/localhost\\/data\\/test.TestHandleSyncRequestMix2.json]\\\"\"
}"

const url = new URL(
    "https://api.100p.xcs.be/api/v1/articles/delta-update"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "Accept-Encoding": "gzip, deflate, br",
    "Connection": "keep-alive",
};

let body = {
    "file": "\"http:\/\/localhost\/data\/test.TestHandleSyncRequestMix.json\"",
    "files": "\"[http:\/\/localhost\/data\/test.TestHandleSyncRequestMix.json, http:\/\/localhost\/data\/test.TestHandleSyncRequestMix2.json]\""
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
import requests
import json

url = 'https://api.100p.xcs.be/api/v1/articles/delta-update'
payload = {
    "file": "\"http:\/\/localhost\/data\/test.TestHandleSyncRequestMix.json\"",
    "files": "\"[http:\/\/localhost\/data\/test.TestHandleSyncRequestMix.json, http:\/\/localhost\/data\/test.TestHandleSyncRequestMix2.json]\""
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Accept-Encoding': 'gzip, deflate, br',
  'Connection': 'keep-alive'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Example response (200):


{
    "status": "success",
    "message": "Delta file accepted and added to the job queue",
    "data": null
}

Example response (401):


{
    "status": "error",
    "message": "Message describing the error",
    "data": null
}

Request   

POST api/v1/articles/delta-update

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Accept-Encoding      

Example: gzip, deflate, br

Connection      

Example: keep-alive

Body Parameters

file   string   

The url to the delta update json file. Example: "http://localhost/data/test.TestHandleSyncRequestMix.json"

files   string   

Array of urls to the delta update json file(s). Example: "[http://localhost/data/test.TestHandleSyncRequestMix.json, http://localhost/data/test.TestHandleSyncRequestMix2.json]"

Update

requires authentication

Update an article

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://api.100p.xcs.be/api/v1/articles/update',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'Accept-Encoding' => 'gzip, deflate, br',
            'Connection' => 'keep-alive',
        ],
        'json' => [
            'customNumber' => 'commodi',
            'F_1' => '"12411116"',
            'F_*' => '"F_5"',
            'C_*' => '"C_75015"',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
curl --request POST \
    "https://api.100p.xcs.be/api/v1/articles/update" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "Accept-Encoding: gzip, deflate, br" \
    --header "Connection: keep-alive" \
    --data "{
    \"customNumber\": \"commodi\",
    \"F_1\": \"\\\"12411116\\\"\",
    \"F_*\": \"\\\"F_5\\\"\",
    \"C_*\": \"\\\"C_75015\\\"\"
}"

const url = new URL(
    "https://api.100p.xcs.be/api/v1/articles/update"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "Accept-Encoding": "gzip, deflate, br",
    "Connection": "keep-alive",
};

let body = {
    "customNumber": "commodi",
    "F_1": "\"12411116\"",
    "F_*": "\"F_5\"",
    "C_*": "\"C_75015\""
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
import requests
import json

url = 'https://api.100p.xcs.be/api/v1/articles/update'
payload = {
    "customNumber": "commodi",
    "F_1": "\"12411116\"",
    "F_*": "\"F_5\"",
    "C_*": "\"C_75015\""
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Accept-Encoding': 'gzip, deflate, br',
  'Connection': 'keep-alive'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Example response (200):


{
    "status": "success",
    "message": "Update successful",
    "data": {
        "id": "12411116",
        "F_1": "12411116",
        "F_3": "BH30-IP20-LG08-CRI90-6,1W-4K-BM45°-RFL-WHT-IDD350mADC(DALI)",
        "F_5": "",
        "F_80000": "BULLET HOLE 30 - IP20 - LED G08 - CRI 90 - 6,1 W - 4000K - BEAM 45°-REFLECTOR",
        "F_80001": "MATT WHITE TEXTURED - INCL. DIM. DRIVER 350mA DC (DALI)",
        "F_80002": "",
        "F_80003": "",
        "F_80007": "",
        "C_75048": "BULLET HOLE",
        "C_75027": "BULLET HOLE 30",
        "C_75000": "INDOOR",
        "C_75001": "CEILING",
        "F_80006": "20/06/2022"
    }
}

Example response (401):


{
    "status": "error",
    "message": "Message describing the error",
    "data": null
}

Request   

POST api/v1/articles/update

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Accept-Encoding      

Example: gzip, deflate, br

Connection      

Example: keep-alive

Body Parameters

customNumber   string   

Example: commodi

F_1   string   

The article number to copy. Example: "12411116"

F_*   string  optional  

optional Params to add or update for "F" params. Example: "F_5"

C_*   string  optional  

optional Params to add or update for "C" params. Example: "C_75015"

Delete

requires authentication

Delete an article by its number "F_1" which is the id used internally (Navision)

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://api.100p.xcs.be/api/v1/articles/delete/"12411116"',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'Accept-Encoding' => 'gzip, deflate, br',
            'Connection' => 'keep-alive',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
curl --request GET \
    --get "https://api.100p.xcs.be/api/v1/articles/delete/"12411116"" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "Accept-Encoding: gzip, deflate, br" \
    --header "Connection: keep-alive"
const url = new URL(
    "https://api.100p.xcs.be/api/v1/articles/delete/"12411116""
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "Accept-Encoding": "gzip, deflate, br",
    "Connection": "keep-alive",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
import requests
import json

url = 'https://api.100p.xcs.be/api/v1/articles/delete/"12411116"'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Accept-Encoding': 'gzip, deflate, br',
  'Connection': 'keep-alive'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (200):


{
    "status": "success",
    "message": "Articles deleted",
    "data": {
        "_index": "articles",
        "_type": "_doc",
        "_id": "12411116",
        "_version": 4,
        "result": "deleted",
        "_shards": {
            "total": 2,
            "successful": 1,
            "failed": 0
        },
        "_seq_no": 2338,
        "_primary_term": 26
    }
}

Example response (401):


{
    "status": "error",
    "message": "Message describing the error",
    "data": null
}

Request   

GET api/v1/articles/delete/{articleNumber}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Accept-Encoding      

Example: gzip, deflate, br

Connection      

Example: keep-alive

URL Parameters

articleNumber   string   

The article number on "F_1". Example: "12411116"

Search

requires authentication

Search an article by its number "F_1" which is the id used internally (Navision)

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://api.100p.xcs.be/api/v1/articles/"12411116"',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'Accept-Encoding' => 'gzip, deflate, br',
            'Connection' => 'keep-alive',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
curl --request GET \
    --get "https://api.100p.xcs.be/api/v1/articles/"12411116"" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "Accept-Encoding: gzip, deflate, br" \
    --header "Connection: keep-alive"
const url = new URL(
    "https://api.100p.xcs.be/api/v1/articles/"12411116""
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "Accept-Encoding": "gzip, deflate, br",
    "Connection": "keep-alive",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
import requests
import json

url = 'https://api.100p.xcs.be/api/v1/articles/"12411116"'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Accept-Encoding': 'gzip, deflate, br',
  'Connection': 'keep-alive'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (200):


{
    "status": "success",
    "message": "Articles found",
    "data": {
        "id": "12411116",
        "F_1": "12411116",
        "F_3": "BH30-IP20-LG08-CRI90-6,1W-4K-BM45°-RFL-WHT-IDD350mADC(DALI)",
        "F_5": "",
        "F_80000": "BULLET HOLE 30 - IP20 - LED G08 - CRI 90 - 6,1 W - 4000K - BEAM 45°-REFLECTOR",
        "F_80001": "MATT WHITE TEXTURED - INCL. DIM. DRIVER 350mA DC (DALI)",
        "F_80002": "",
        "F_80003": "",
        "F_80007": "",
        "C_75048": "BULLET HOLE",
        "C_75027": "BULLET HOLE 30",
        "C_75000": "INDOOR",
        "C_75001": "CEILING",
        "F_80006": "20/06/2022"
    }
}

Example response (401):


{
    "status": "error",
    "message": "Message describing the error",
    "data": null
}

Request   

GET api/v1/articles/{articleNumber}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Accept-Encoding      

Example: gzip, deflate, br

Connection      

Example: keep-alive

URL Parameters

articleNumber   string   

The article number on "F_1". Example: "12411116"

Endpoints

Create User (Admin)

Admin-only action. Creates a new user with the provided name, email and password. Returns the user's name and a freshly created personal access token for that user.

Authorization:

Request payload:

Responses:

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://api.100p.xcs.be/api/v1/admin/create-user',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'quis',
            'email' => 'muhammad.davis@example.org',
            'password' => 'Z{Vz:Ui',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
curl --request POST \
    "https://api.100p.xcs.be/api/v1/admin/create-user" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"quis\",
    \"email\": \"muhammad.davis@example.org\",
    \"password\": \"Z{Vz:Ui\"
}"

const url = new URL(
    "https://api.100p.xcs.be/api/v1/admin/create-user"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "name": "quis",
    "email": "muhammad.davis@example.org",
    "password": "Z{Vz:Ui"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
import requests
import json

url = 'https://api.100p.xcs.be/api/v1/admin/create-user'
payload = {
    "name": "quis",
    "email": "muhammad.davis@example.org",
    "password": "Z{Vz:Ui"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Request   

POST api/v1/admin/create-user

Headers

Content-Type      

Example: application/json

Accept      

Example: application/json

Body Parameters

name   string   

Example: quis

email   string   

Must be a valid email address. Example: muhammad.davis@example.org

password   string   

Must be at least 8 characters. Example: Z{Vz:Ui

Users List (Admin)

Admin-only action. Returns the list of users with limited fields and token usage info per user.

Authorization:

Response 200 OK: Array of items with fields:

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://api.100p.xcs.be/api/v1/admin/users',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
curl --request GET \
    --get "https://api.100p.xcs.be/api/v1/admin/users" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.100p.xcs.be/api/v1/admin/users"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
import requests
import json

url = 'https://api.100p.xcs.be/api/v1/admin/users'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
vary: Origin
set-cookie: 100p_api_session=IuHO1CHrVBcwQLk2yRb4SGD3ygOPGRGIBdIWKKbQ; expires=Mon, 02-Mar-2026 17:47:13 GMT; Max-Age=7200; path=/; httponly; samesite=lax
 

{
    "message": "Unauthenticated."
}

Request   

GET api/v1/admin/users

Headers

Content-Type      

Example: application/json

Accept      

Example: application/json

Delete User (Admin)

Admin-only action. Deletes a non-admin user identified by email. All the user's personal access tokens are deleted before removing the user record. Admin users cannot be deleted via this endpoint.

Authorization:

Request payload:

Responses:

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'https://api.100p.xcs.be/api/v1/admin/user',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'email' => 'autem',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
curl --request DELETE \
    "https://api.100p.xcs.be/api/v1/admin/user" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"email\": \"autem\"
}"

const url = new URL(
    "https://api.100p.xcs.be/api/v1/admin/user"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "email": "autem"
};

fetch(url, {
    method: "DELETE",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
import requests
import json

url = 'https://api.100p.xcs.be/api/v1/admin/user'
payload = {
    "email": "autem"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('DELETE', url, headers=headers, json=payload)
response.json()

Request   

DELETE api/v1/admin/user

Headers

Content-Type      

Example: application/json

Accept      

Example: application/json

Body Parameters

email   string   

Example: autem

Renew Token (Admin)

Admin-only action. Given a user's unique email, revoke all of that user's existing personal access tokens and return a newly created token for that user.

Request payload:

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://api.100p.xcs.be/api/v1/admin/user/renew',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'email' => 'schneider.herta@example.com',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
curl --request POST \
    "https://api.100p.xcs.be/api/v1/admin/user/renew" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"email\": \"schneider.herta@example.com\"
}"

const url = new URL(
    "https://api.100p.xcs.be/api/v1/admin/user/renew"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "email": "schneider.herta@example.com"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
import requests
import json

url = 'https://api.100p.xcs.be/api/v1/admin/user/renew'
payload = {
    "email": "schneider.herta@example.com"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Request   

POST api/v1/admin/user/renew

Headers

Content-Type      

Example: application/json

Accept      

Example: application/json

Body Parameters

email   string   

Must be a valid email address. Example: schneider.herta@example.com

Job

Job api calls. To see, flush and clear jobs in the job queue.

Job

requires authentication

Get first job. This is the first job found in the queue, same as calling jobs with (1)

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://api.100p.xcs.be/api/v1/jobs/job',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'Accept-Encoding' => 'gzip, deflate, br',
            'Connection' => 'keep-alive',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
curl --request GET \
    --get "https://api.100p.xcs.be/api/v1/jobs/job" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "Accept-Encoding: gzip, deflate, br" \
    --header "Connection: keep-alive"
const url = new URL(
    "https://api.100p.xcs.be/api/v1/jobs/job"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "Accept-Encoding": "gzip, deflate, br",
    "Connection": "keep-alive",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
import requests
import json

url = 'https://api.100p.xcs.be/api/v1/jobs/job'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Accept-Encoding': 'gzip, deflate, br',
  'Connection': 'keep-alive'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (200):


{
    "status": "success",
    "message": "Jobs found [job]",
    "data": [
        {
            "payload": {
                "file": "http://localhost/data/test.TestHandleSyncRequestMix.json",
                "tries": 1,
                "timeout": 300,
                "failOnTimeout": true,
                "queue": "delta-file",
                "middleware": [],
                "chained": []
            }
        }
    ]
}

Example response (401):


{
    "status": "error",
    "message": "Message describing the error",
    "data": null
}

Request   

GET api/v1/jobs/job

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Accept-Encoding      

Example: gzip, deflate, br

Connection      

Example: keep-alive

Jobs

requires authentication

Get all jobs paginated. These are the jobs that still need to be handled

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://api.100p.xcs.be/api/v1/jobs/jobs',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'Accept-Encoding' => 'gzip, deflate, br',
            'Connection' => 'keep-alive',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
curl --request GET \
    --get "https://api.100p.xcs.be/api/v1/jobs/jobs" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "Accept-Encoding: gzip, deflate, br" \
    --header "Connection: keep-alive"
const url = new URL(
    "https://api.100p.xcs.be/api/v1/jobs/jobs"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "Accept-Encoding": "gzip, deflate, br",
    "Connection": "keep-alive",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
import requests
import json

url = 'https://api.100p.xcs.be/api/v1/jobs/jobs'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Accept-Encoding': 'gzip, deflate, br',
  'Connection': 'keep-alive'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (200):


{
    "status": "success",
    "message": "Jobs found [jobs]",
    "data": [
        {
            "payload": {
                "file": "http://localhost/data/test.TestHandleSyncRequestMix.json",
                "tries": 1,
                "timeout": 300,
                "failOnTimeout": true,
                "queue": "delta-file",
                "middleware": [],
                "chained": []
            }
        }
    ]
}

Example response (401):


{
    "status": "error",
    "message": "Message describing the error",
    "data": null
}

Request   

GET api/v1/jobs/jobs

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Accept-Encoding      

Example: gzip, deflate, br

Connection      

Example: keep-alive

Files

requires authentication

This fetches a list of files in job queue. It is meant to be used as a reference point of files that still need processing

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://api.100p.xcs.be/api/v1/jobs/files',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'Accept-Encoding' => 'gzip, deflate, br',
            'Connection' => 'keep-alive',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
curl --request GET \
    --get "https://api.100p.xcs.be/api/v1/jobs/files" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "Accept-Encoding: gzip, deflate, br" \
    --header "Connection: keep-alive"
const url = new URL(
    "https://api.100p.xcs.be/api/v1/jobs/files"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "Accept-Encoding": "gzip, deflate, br",
    "Connection": "keep-alive",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
import requests
import json

url = 'https://api.100p.xcs.be/api/v1/jobs/files'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Accept-Encoding': 'gzip, deflate, br',
  'Connection': 'keep-alive'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (200):


{
    "status": "success",
    "message": "files found (1)",
    "data": [
        "http://localhost/data/test.TestHandleSyncRequestMix.json.gz"
    ]
}

Example response (401):


{
    "status": "error",
    "message": "Message describing the error",
    "data": null
}

Request   

GET api/v1/jobs/files

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Accept-Encoding      

Example: gzip, deflate, br

Connection      

Example: keep-alive

Failed Job

requires authentication

Get first failed job. This gets the original failed job that prevents the rest from running, same as failed jobs (1)

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://api.100p.xcs.be/api/v1/jobs/failedjob',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'Accept-Encoding' => 'gzip, deflate, br',
            'Connection' => 'keep-alive',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
curl --request GET \
    --get "https://api.100p.xcs.be/api/v1/jobs/failedjob" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "Accept-Encoding: gzip, deflate, br" \
    --header "Connection: keep-alive"
const url = new URL(
    "https://api.100p.xcs.be/api/v1/jobs/failedjob"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "Accept-Encoding": "gzip, deflate, br",
    "Connection": "keep-alive",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
import requests
import json

url = 'https://api.100p.xcs.be/api/v1/jobs/failedjob'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Accept-Encoding': 'gzip, deflate, br',
  'Connection': 'keep-alive'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (200):


{
    "status": "success",
    "message": "Failed job found",
    "data": {
        "errors": [
            "Trying to add feature to an existing article, but the article does not exist: 12411112"
        ],
        "payload": {
            "articleData": {
                "F_1": "12411112",
                "F_80004": "248,28"
            },
            "file": "http://localhost/data/test.TestHandleSyncRequestMix.json",
            "operation": "replace-article-feature",
            "tries": 1,
            "timeout": 60,
            "failOnTimeout": true,
            "queue": "delta-article",
            "middleware": [],
            "chained": []
        }
    }
}

Example response (401):


{
    "status": "error",
    "message": "Message describing the error",
    "data": null
}

Request   

GET api/v1/jobs/failedjob

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Accept-Encoding      

Example: gzip, deflate, br

Connection      

Example: keep-alive

Failed Jobs

requires authentication

Get all failed jobs paginated. these are the jobs in order of first to last that failed to run. Check payload for original file and errors for exceptions that caused the issue

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://api.100p.xcs.be/api/v1/jobs/failedjobs',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'Accept-Encoding' => 'gzip, deflate, br',
            'Connection' => 'keep-alive',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
curl --request GET \
    --get "https://api.100p.xcs.be/api/v1/jobs/failedjobs" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "Accept-Encoding: gzip, deflate, br" \
    --header "Connection: keep-alive"
const url = new URL(
    "https://api.100p.xcs.be/api/v1/jobs/failedjobs"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "Accept-Encoding": "gzip, deflate, br",
    "Connection": "keep-alive",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
import requests
import json

url = 'https://api.100p.xcs.be/api/v1/jobs/failedjobs'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Accept-Encoding': 'gzip, deflate, br',
  'Connection': 'keep-alive'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (200):


{
    "status": "success",
    "message": "Failed jobs found",
    "data": {
        "errors": [
            "Trying to add feature to an existing article, but the article does not exist: 12411112"
        ],
        "payload": {
            "articleData": {
                "F_1": "12411112",
                "F_80004": "248,28"
            },
            "file": "http://localhost/data/test.TestHandleSyncRequestMix.json",
            "operation": "replace-article-feature",
            "tries": 1,
            "timeout": 60,
            "failOnTimeout": true,
            "queue": "delta-article",
            "middleware": [],
            "chained": []
        }
    }
}

Example response (401):


{
    "status": "error",
    "message": "Message describing the error",
    "data": null
}

Request   

GET api/v1/jobs/failedjobs

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Accept-Encoding      

Example: gzip, deflate, br

Connection      

Example: keep-alive

Failed Articles

requires authentication

This fetches a list of article numbers that have failed jobs. It is meant to be used as a reference point of articles that need to be re-evaluated and uploaded using the delta-update after a flush.

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://api.100p.xcs.be/api/v1/jobs/failedarticles',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'Accept-Encoding' => 'gzip, deflate, br',
            'Connection' => 'keep-alive',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
curl --request GET \
    --get "https://api.100p.xcs.be/api/v1/jobs/failedarticles" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "Accept-Encoding: gzip, deflate, br" \
    --header "Connection: keep-alive"
const url = new URL(
    "https://api.100p.xcs.be/api/v1/jobs/failedarticles"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "Accept-Encoding": "gzip, deflate, br",
    "Connection": "keep-alive",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
import requests
import json

url = 'https://api.100p.xcs.be/api/v1/jobs/failedarticles'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Accept-Encoding': 'gzip, deflate, br',
  'Connection': 'keep-alive'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (200):


{
    "status": "success",
    "message": "Failed articles found (10)",
    "data": [
        "12411112",
        "12411122",
        "12411132",
        "12411142",
        "12411152",
        "12411162",
        "12411172",
        "12411182",
        "12411212",
        "12411222"
    ]
}

Example response (401):


{
    "status": "error",
    "message": "Message describing the error",
    "data": null
}

Request   

GET api/v1/jobs/failedarticles

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Accept-Encoding      

Example: gzip, deflate, br

Connection      

Example: keep-alive

Failed Files

requires authentication

This fetches a list of files connected to failed jobs. It is meant to be used as a reference point of files that need to be re-evaluated and uploaded using the delta-update after a flush.

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://api.100p.xcs.be/api/v1/jobs/failedfiles',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'Accept-Encoding' => 'gzip, deflate, br',
            'Connection' => 'keep-alive',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
curl --request GET \
    --get "https://api.100p.xcs.be/api/v1/jobs/failedfiles" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "Accept-Encoding: gzip, deflate, br" \
    --header "Connection: keep-alive"
const url = new URL(
    "https://api.100p.xcs.be/api/v1/jobs/failedfiles"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "Accept-Encoding": "gzip, deflate, br",
    "Connection": "keep-alive",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
import requests
import json

url = 'https://api.100p.xcs.be/api/v1/jobs/failedfiles'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Accept-Encoding': 'gzip, deflate, br',
  'Connection': 'keep-alive'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (200):


{
    "status": "success",
    "message": "Failed files found (1)",
    "data": [
        "http://localhost/data/test.TestHandleSyncRequestMix.json.gz"
    ]
}

Example response (401):


{
    "status": "error",
    "message": "Message describing the error",
    "data": null
}

Request   

GET api/v1/jobs/failedfiles

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Accept-Encoding      

Example: gzip, deflate, br

Connection      

Example: keep-alive

Successful Files

requires authentication

This fetches a list of successful files in job queue. It is meant to be used as a reference point of files that have been processed successfully

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://api.100p.xcs.be/api/v1/jobs/successfulfiles',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'Accept-Encoding' => 'gzip, deflate, br',
            'Connection' => 'keep-alive',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
curl --request GET \
    --get "https://api.100p.xcs.be/api/v1/jobs/successfulfiles" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "Accept-Encoding: gzip, deflate, br" \
    --header "Connection: keep-alive"
const url = new URL(
    "https://api.100p.xcs.be/api/v1/jobs/successfulfiles"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "Accept-Encoding": "gzip, deflate, br",
    "Connection": "keep-alive",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
import requests
import json

url = 'https://api.100p.xcs.be/api/v1/jobs/successfulfiles'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Accept-Encoding': 'gzip, deflate, br',
  'Connection': 'keep-alive'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (200):


{
    "status": "success",
    "message": "successful files found (1)",
    "data": [
        "http://localhost/data/test.TestHandleSyncRequestMix.json.gz"
    ]
}

Example response (401):


{
    "status": "error",
    "message": "Message describing the error",
    "data": null
}

Request   

GET api/v1/jobs/successfulfiles

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Accept-Encoding      

Example: gzip, deflate, br

Connection      

Example: keep-alive

Clear Jobs

requires authentication

this clears all active jobs from the queue before they are finished

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://api.100p.xcs.be/api/v1/jobs/clear',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'Accept-Encoding' => 'gzip, deflate, br',
            'Connection' => 'keep-alive',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
curl --request GET \
    --get "https://api.100p.xcs.be/api/v1/jobs/clear" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "Accept-Encoding: gzip, deflate, br" \
    --header "Connection: keep-alive"
const url = new URL(
    "https://api.100p.xcs.be/api/v1/jobs/clear"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "Accept-Encoding": "gzip, deflate, br",
    "Connection": "keep-alive",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
import requests
import json

url = 'https://api.100p.xcs.be/api/v1/jobs/clear'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Accept-Encoding': 'gzip, deflate, br',
  'Connection': 'keep-alive'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (200):


{
    "status": "success",
    "message": "Clear of jobs queue successful",
    "data": null
}

Example response (401):


{
    "status": "error",
    "message": "Message describing the error",
    "data": null
}

Request   

GET api/v1/jobs/clear

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Accept-Encoding      

Example: gzip, deflate, br

Connection      

Example: keep-alive

Clear Successful Jobs

requires authentication

this clears all successful jobs from thecustom database

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://api.100p.xcs.be/api/v1/jobs/clearsuccessful',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'Accept-Encoding' => 'gzip, deflate, br',
            'Connection' => 'keep-alive',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
curl --request GET \
    --get "https://api.100p.xcs.be/api/v1/jobs/clearsuccessful" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "Accept-Encoding: gzip, deflate, br" \
    --header "Connection: keep-alive"
const url = new URL(
    "https://api.100p.xcs.be/api/v1/jobs/clearsuccessful"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "Accept-Encoding": "gzip, deflate, br",
    "Connection": "keep-alive",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
import requests
import json

url = 'https://api.100p.xcs.be/api/v1/jobs/clearsuccessful'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Accept-Encoding': 'gzip, deflate, br',
  'Connection': 'keep-alive'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (200):


{
    "status": "success",
    "message": "Clear of finished jobs successful",
    "data": null
}

Example response (401):


{
    "status": "error",
    "message": "Message describing the error",
    "data": null
}

Request   

GET api/v1/jobs/clearsuccessful

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Accept-Encoding      

Example: gzip, deflate, br

Connection      

Example: keep-alive

Flush Failed Jobs

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://api.100p.xcs.be/api/v1/jobs/flush',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'Accept-Encoding' => 'gzip, deflate, br',
            'Connection' => 'keep-alive',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
curl --request GET \
    --get "https://api.100p.xcs.be/api/v1/jobs/flush" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "Accept-Encoding: gzip, deflate, br" \
    --header "Connection: keep-alive"
const url = new URL(
    "https://api.100p.xcs.be/api/v1/jobs/flush"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
    "Accept-Encoding": "gzip, deflate, br",
    "Connection": "keep-alive",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
import requests
import json

url = 'https://api.100p.xcs.be/api/v1/jobs/flush'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Accept-Encoding': 'gzip, deflate, br',
  'Connection': 'keep-alive'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (200):


{
    "status": "success",
    "message": "Flush of failed jobs queue successful",
    "data": null
}

Example response (401):


{
    "status": "error",
    "message": "Message describing the error",
    "data": null
}

Request   

GET api/v1/jobs/flush

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Accept-Encoding      

Example: gzip, deflate, br

Connection      

Example: keep-alive