MENU navbar-image

Introduction

Kvalitetskontroll API

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

Authenticating requests

To authenticate requests, include an Authorization header with the value "Bearer your-token".

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

You can generate and retrieve your token by visiting your dashboard and adding a new Personal Access Token.

Contact Addresses

GET /contacts/{contact}/addresses

requires authentication

Example request:
curl --request GET \
    --get "https://api.kvalitetskontroll.no/contacts/1/addresses" \
    --header "Authorization: Bearer kvDZ8gb63heE1adPc6f4a5V" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"id\": 7,
    \"is_deleted\": false,
    \"offset\": 16,
    \"limit\": 19
}"

const url = new URL(
    "https://api.kvalitetskontroll.no/contacts/1/addresses"
);

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

let body = {
    "id": 7,
    "is_deleted": false,
    "offset": 16,
    "limit": 19
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/contacts/1/addresses';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer kvDZ8gb63heE1adPc6f4a5V',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'id' => 7,
            'is_deleted' => false,
            'offset' => 16,
            'limit' => 19,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/contacts/1/addresses'
payload = {
    "id": 7,
    "is_deleted": false,
    "offset": 16,
    "limit": 19
}
headers = {
  'Authorization': 'Bearer kvDZ8gb63heE1adPc6f4a5V',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

GET contacts/{contact_id}/addresses

Headers

Authorization      

Example: Bearer kvDZ8gb63heE1adPc6f4a5V

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

contact_id   integer   

The ID of the contact. Example: 1

Body Parameters

id   integer  optional  

Example: 7

is_deleted   boolean  optional  

Example: false

offset   integer  optional  

Example: 16

limit   integer  optional  

Example: 19

GET /contacts/{contact}/addresses/{address}

requires authentication

Example request:
curl --request GET \
    --get "https://api.kvalitetskontroll.no/contacts/1/addresses/1" \
    --header "Authorization: Bearer Eb4e5favgZ3D1VahkP686dc" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.kvalitetskontroll.no/contacts/1/addresses/1"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/contacts/1/addresses/1';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer Eb4e5favgZ3D1VahkP686dc',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/contacts/1/addresses/1'
headers = {
  'Authorization': 'Bearer Eb4e5favgZ3D1VahkP686dc',
  '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
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

GET contacts/{contact_id}/addresses/{address_id}

Headers

Authorization      

Example: Bearer Eb4e5favgZ3D1VahkP686dc

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

contact_id   integer   

The ID of the contact. Example: 1

address_id   integer   

The ID of the address. Example: 1

POST /contacts/{contact}/addresses

requires authentication

Example request:
curl --request POST \
    "https://api.kvalitetskontroll.no/contacts/1/addresses" \
    --header "Authorization: Bearer vdcaDgPEV66kbf8aZh3e541" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"label\": \"suscipit\",
    \"address_line_1\": \"repellendus\",
    \"address_line_2\": \"sunt\",
    \"postal_code\": \"est\",
    \"city\": \"dignissimos\",
    \"country_id\": 14,
    \"external_id\": 16
}"

const url = new URL(
    "https://api.kvalitetskontroll.no/contacts/1/addresses"
);

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

let body = {
    "label": "suscipit",
    "address_line_1": "repellendus",
    "address_line_2": "sunt",
    "postal_code": "est",
    "city": "dignissimos",
    "country_id": 14,
    "external_id": 16
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/contacts/1/addresses';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer vdcaDgPEV66kbf8aZh3e541',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'label' => 'suscipit',
            'address_line_1' => 'repellendus',
            'address_line_2' => 'sunt',
            'postal_code' => 'est',
            'city' => 'dignissimos',
            'country_id' => 14,
            'external_id' => 16,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/contacts/1/addresses'
payload = {
    "label": "suscipit",
    "address_line_1": "repellendus",
    "address_line_2": "sunt",
    "postal_code": "est",
    "city": "dignissimos",
    "country_id": 14,
    "external_id": 16
}
headers = {
  'Authorization': 'Bearer vdcaDgPEV66kbf8aZh3e541',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

POST contacts/{contact_id}/addresses

Headers

Authorization      

Example: Bearer vdcaDgPEV66kbf8aZh3e541

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

contact_id   integer   

The ID of the contact. Example: 1

Body Parameters

label   string  optional  

Example: suscipit

address_line_1   string   

Example: repellendus

address_line_2   string  optional  

Example: sunt

postal_code   string   

Example: est

city   string   

Example: dignissimos

country_id   integer   

Example: 14

external_id   integer  optional  

Example: 16

PUT /contacts/{contact}/addresses/{address}

requires authentication

Example request:
curl --request PUT \
    "https://api.kvalitetskontroll.no/contacts/1/addresses/1" \
    --header "Authorization: Bearer kc6v1abg4deE6f5DaZP3Vh8" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"label\": \"deserunt\",
    \"address_line_1\": \"sed\",
    \"address_line_2\": \"illum\",
    \"postal_code\": \"quibusdam\",
    \"city\": \"aliquam\",
    \"country_id\": 5,
    \"external_id\": 19
}"

const url = new URL(
    "https://api.kvalitetskontroll.no/contacts/1/addresses/1"
);

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

let body = {
    "label": "deserunt",
    "address_line_1": "sed",
    "address_line_2": "illum",
    "postal_code": "quibusdam",
    "city": "aliquam",
    "country_id": 5,
    "external_id": 19
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/contacts/1/addresses/1';
$response = $client->put(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer kc6v1abg4deE6f5DaZP3Vh8',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'label' => 'deserunt',
            'address_line_1' => 'sed',
            'address_line_2' => 'illum',
            'postal_code' => 'quibusdam',
            'city' => 'aliquam',
            'country_id' => 5,
            'external_id' => 19,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/contacts/1/addresses/1'
payload = {
    "label": "deserunt",
    "address_line_1": "sed",
    "address_line_2": "illum",
    "postal_code": "quibusdam",
    "city": "aliquam",
    "country_id": 5,
    "external_id": 19
}
headers = {
  'Authorization': 'Bearer kc6v1abg4deE6f5DaZP3Vh8',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

PUT contacts/{contact_id}/addresses/{address_id}

Headers

Authorization      

Example: Bearer kc6v1abg4deE6f5DaZP3Vh8

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

contact_id   integer   

The ID of the contact. Example: 1

address_id   integer   

The ID of the address. Example: 1

Body Parameters

label   string  optional  

Example: deserunt

address_line_1   string  optional  

Example: sed

address_line_2   string  optional  

Example: illum

postal_code   string  optional  

Example: quibusdam

city   string  optional  

Example: aliquam

country_id   integer  optional  

Example: 5

external_id   integer  optional  

Example: 19

Contact Categories

GET /contacts/{contact}/categories

requires authentication

Example request:
curl --request GET \
    --get "https://api.kvalitetskontroll.no/contacts/1/categories" \
    --header "Authorization: Bearer D68ghka5bvaZ13VPec6df4E" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"id\": \"jgelyleggmkg\",
    \"company_id\": \"zfgdrlklbeerhdap\",
    \"is_deleted\": true,
    \"offset\": 5,
    \"limit\": 6
}"

const url = new URL(
    "https://api.kvalitetskontroll.no/contacts/1/categories"
);

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

let body = {
    "id": "jgelyleggmkg",
    "company_id": "zfgdrlklbeerhdap",
    "is_deleted": true,
    "offset": 5,
    "limit": 6
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/contacts/1/categories';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer D68ghka5bvaZ13VPec6df4E',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'id' => 'jgelyleggmkg',
            'company_id' => 'zfgdrlklbeerhdap',
            'is_deleted' => true,
            'offset' => 5,
            'limit' => 6,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/contacts/1/categories'
payload = {
    "id": "jgelyleggmkg",
    "company_id": "zfgdrlklbeerhdap",
    "is_deleted": true,
    "offset": 5,
    "limit": 6
}
headers = {
  'Authorization': 'Bearer D68ghka5bvaZ13VPec6df4E',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

GET contacts/{contact_id}/categories

Headers

Authorization      

Example: Bearer D68ghka5bvaZ13VPec6df4E

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

contact_id   integer   

The ID of the contact. Example: 1

contact   integer  optional  

Example: 1

Body Parameters

id   string  optional  

Must not be greater than 50 characters. Example: jgelyleggmkg

company_id   string  optional  

Must not be greater than 50 characters. Example: zfgdrlklbeerhdap

is_deleted   boolean  optional  

Example: true

offset   integer  optional  

Example: 5

limit   integer  optional  

Example: 6

GET /contacts/{contact}/categories/{category}

requires authentication

Example request:
curl --request GET \
    --get "https://api.kvalitetskontroll.no/contacts/1/categories/1" \
    --header "Authorization: Bearer eV6vkad4hc1gDa56f3bEZ8P" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.kvalitetskontroll.no/contacts/1/categories/1"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/contacts/1/categories/1';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer eV6vkad4hc1gDa56f3bEZ8P',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/contacts/1/categories/1'
headers = {
  'Authorization': 'Bearer eV6vkad4hc1gDa56f3bEZ8P',
  '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
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

GET contacts/{contact_id}/categories/{category_id}

Headers

Authorization      

Example: Bearer eV6vkad4hc1gDa56f3bEZ8P

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

contact_id   integer   

The ID of the contact. Example: 1

category_id   integer   

The ID of the category. Example: 1

category   integer  optional  

Example: 2

Contact Persons

GET /contacts/{contact}/people

requires authentication

Example request:
curl --request GET \
    --get "https://api.kvalitetskontroll.no/contacts/1/people" \
    --header "Authorization: Bearer DbafVhkv3gZd4E6c15P6ae8" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"id\": \"mbfgplyemketwyyvy\",
    \"is_deleted\": true,
    \"offset\": 8,
    \"limit\": 5
}"

const url = new URL(
    "https://api.kvalitetskontroll.no/contacts/1/people"
);

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

let body = {
    "id": "mbfgplyemketwyyvy",
    "is_deleted": true,
    "offset": 8,
    "limit": 5
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/contacts/1/people';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer DbafVhkv3gZd4E6c15P6ae8',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'id' => 'mbfgplyemketwyyvy',
            'is_deleted' => true,
            'offset' => 8,
            'limit' => 5,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/contacts/1/people'
payload = {
    "id": "mbfgplyemketwyyvy",
    "is_deleted": true,
    "offset": 8,
    "limit": 5
}
headers = {
  'Authorization': 'Bearer DbafVhkv3gZd4E6c15P6ae8',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

GET contacts/{contact_id}/people

Headers

Authorization      

Example: Bearer DbafVhkv3gZd4E6c15P6ae8

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

contact_id   integer   

The ID of the contact. Example: 1

Body Parameters

id   string  optional  

Must not be greater than 50 characters. Example: mbfgplyemketwyyvy

is_deleted   boolean  optional  

Example: true

offset   integer  optional  

Example: 8

limit   integer  optional  

Example: 5

GET /contacts/{contact}/people/{person}

requires authentication

Example request:
curl --request GET \
    --get "https://api.kvalitetskontroll.no/contacts/1/people/1" \
    --header "Authorization: Bearer aa566DecPkvfbVZEg13h8d4" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.kvalitetskontroll.no/contacts/1/people/1"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/contacts/1/people/1';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer aa566DecPkvfbVZEg13h8d4',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/contacts/1/people/1'
headers = {
  'Authorization': 'Bearer aa566DecPkvfbVZEg13h8d4',
  '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
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

GET contacts/{contact_id}/people/{person_id}

Headers

Authorization      

Example: Bearer aa566DecPkvfbVZEg13h8d4

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

contact_id   integer   

The ID of the contact. Example: 1

person_id   integer   

The ID of the person. Example: 1

POST /contacts/{contact}/people

requires authentication

Example request:
curl --request POST \
    "https://api.kvalitetskontroll.no/contacts/1/people" \
    --header "Authorization: Bearer e1gva3PbZVE6kdac85D6h4f" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"first_name\": \"animi\",
    \"last_name\": \"ut\",
    \"phone\": \"aliquam\",
    \"mobile\": \"animi\",
    \"email\": \"ytorp@example.com\",
    \"position\": \"autem\",
    \"external_id\": 8
}"

const url = new URL(
    "https://api.kvalitetskontroll.no/contacts/1/people"
);

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

let body = {
    "first_name": "animi",
    "last_name": "ut",
    "phone": "aliquam",
    "mobile": "animi",
    "email": "ytorp@example.com",
    "position": "autem",
    "external_id": 8
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/contacts/1/people';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer e1gva3PbZVE6kdac85D6h4f',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'first_name' => 'animi',
            'last_name' => 'ut',
            'phone' => 'aliquam',
            'mobile' => 'animi',
            'email' => 'ytorp@example.com',
            'position' => 'autem',
            'external_id' => 8,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/contacts/1/people'
payload = {
    "first_name": "animi",
    "last_name": "ut",
    "phone": "aliquam",
    "mobile": "animi",
    "email": "ytorp@example.com",
    "position": "autem",
    "external_id": 8
}
headers = {
  'Authorization': 'Bearer e1gva3PbZVE6kdac85D6h4f',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

POST contacts/{contact_id}/people

Headers

Authorization      

Example: Bearer e1gva3PbZVE6kdac85D6h4f

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

contact_id   integer   

The ID of the contact. Example: 1

Body Parameters

first_name   string   

Example: animi

last_name   string  optional  

Example: ut

phone   string  optional  

Example: aliquam

mobile   string  optional  

Example: animi

email   string  optional  

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

position   string  optional  

Example: autem

external_id   integer  optional  

Example: 8

PUT /contacts/{contact}/people/{person}

requires authentication

Example request:
curl --request PUT \
    "https://api.kvalitetskontroll.no/contacts/1/people/1" \
    --header "Authorization: Bearer Pgf1bVa3546hE8vZd6eakcD" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"first_name\": \"a\",
    \"last_name\": \"quis\",
    \"phone\": \"odio\",
    \"mobile\": \"qui\",
    \"email\": \"aletha.wunsch@example.net\",
    \"position\": \"magnam\",
    \"external_id\": 15
}"

const url = new URL(
    "https://api.kvalitetskontroll.no/contacts/1/people/1"
);

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

let body = {
    "first_name": "a",
    "last_name": "quis",
    "phone": "odio",
    "mobile": "qui",
    "email": "aletha.wunsch@example.net",
    "position": "magnam",
    "external_id": 15
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/contacts/1/people/1';
$response = $client->put(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer Pgf1bVa3546hE8vZd6eakcD',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'first_name' => 'a',
            'last_name' => 'quis',
            'phone' => 'odio',
            'mobile' => 'qui',
            'email' => 'aletha.wunsch@example.net',
            'position' => 'magnam',
            'external_id' => 15,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/contacts/1/people/1'
payload = {
    "first_name": "a",
    "last_name": "quis",
    "phone": "odio",
    "mobile": "qui",
    "email": "aletha.wunsch@example.net",
    "position": "magnam",
    "external_id": 15
}
headers = {
  'Authorization': 'Bearer Pgf1bVa3546hE8vZd6eakcD',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

PUT contacts/{contact_id}/people/{person_id}

Headers

Authorization      

Example: Bearer Pgf1bVa3546hE8vZd6eakcD

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

contact_id   integer   

The ID of the contact. Example: 1

person_id   integer   

The ID of the person. Example: 1

Body Parameters

first_name   string  optional  

Example: a

last_name   string  optional  

Example: quis

phone   string  optional  

Example: odio

mobile   string  optional  

Example: qui

email   string  optional  

Must be a valid email address. Example: aletha.wunsch@example.net

position   string  optional  

Example: magnam

external_id   integer  optional  

Example: 15

Contacts

GET /contacts

requires authentication

Example request:
curl --request GET \
    --get "https://api.kvalitetskontroll.no/contacts?id=cqencufombvp&is_deleted=&offset=19&limit=1" \
    --header "Authorization: Bearer Ea6v63ad1g4chDfVekPb5Z8" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.kvalitetskontroll.no/contacts"
);

const params = {
    "id": "cqencufombvp",
    "is_deleted": "0",
    "offset": "19",
    "limit": "1",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/contacts';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer Ea6v63ad1g4chDfVekPb5Z8',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'id' => 'cqencufombvp',
            'is_deleted' => '0',
            'offset' => '19',
            'limit' => '1',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/contacts'
params = {
  'id': 'cqencufombvp',
  'is_deleted': '0',
  'offset': '19',
  'limit': '1',
}
headers = {
  'Authorization': 'Bearer Ea6v63ad1g4chDfVekPb5Z8',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

GET contacts

Headers

Authorization      

Example: Bearer Ea6v63ad1g4chDfVekPb5Z8

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

id   string  optional  

Must not be greater than 50 characters. Example: cqencufombvp

is_deleted   boolean  optional  

Example: false

offset   integer  optional  

Example: 19

limit   integer  optional  

Example: 1

GET /contacts/{contact}

requires authentication

Example request:
curl --request GET \
    --get "https://api.kvalitetskontroll.no/contacts/1" \
    --header "Authorization: Bearer E5D1c8a4k3V6Ph6egvabdfZ" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.kvalitetskontroll.no/contacts/1"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/contacts/1';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer E5D1c8a4k3V6Ph6egvabdfZ',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/contacts/1'
headers = {
  'Authorization': 'Bearer E5D1c8a4k3V6Ph6egvabdfZ',
  '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
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

GET contacts/{contact_id}

Headers

Authorization      

Example: Bearer E5D1c8a4k3V6Ph6egvabdfZ

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

contact_id   integer   

The ID of the contact. Example: 1

POST /contacts

requires authentication

Example request:
curl --request POST \
    "https://api.kvalitetskontroll.no/contacts" \
    --header "Authorization: Bearer 4a8aDPbdEv6cgZ3kef5V61h" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"vel\",
    \"contact_type\": \"COMPANY\",
    \"is_customer\": true,
    \"customer_number\": 1,
    \"is_vendor\": false,
    \"vendor_number\": 17,
    \"phone\": 81549300,
    \"mobile\": 91509000,
    \"email\": \"witting.enoch@example.org\",
    \"web\": \"http:\\/\\/douglas.com\\/\",
    \"notes\": \"praesentium\",
    \"vat_identification_number\": \"sed\",
    \"default_delivery_address_id\": 1,
    \"default_invoice_address_id\": 2,
    \"external_id\": 1
}"

const url = new URL(
    "https://api.kvalitetskontroll.no/contacts"
);

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

let body = {
    "name": "vel",
    "contact_type": "COMPANY",
    "is_customer": true,
    "customer_number": 1,
    "is_vendor": false,
    "vendor_number": 17,
    "phone": 81549300,
    "mobile": 91509000,
    "email": "witting.enoch@example.org",
    "web": "http:\/\/douglas.com\/",
    "notes": "praesentium",
    "vat_identification_number": "sed",
    "default_delivery_address_id": 1,
    "default_invoice_address_id": 2,
    "external_id": 1
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/contacts';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer 4a8aDPbdEv6cgZ3kef5V61h',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'vel',
            'contact_type' => 'COMPANY',
            'is_customer' => true,
            'customer_number' => 1,
            'is_vendor' => false,
            'vendor_number' => 17,
            'phone' => 81549300,
            'mobile' => 91509000,
            'email' => 'witting.enoch@example.org',
            'web' => 'http://douglas.com/',
            'notes' => 'praesentium',
            'vat_identification_number' => 'sed',
            'default_delivery_address_id' => 1,
            'default_invoice_address_id' => 2,
            'external_id' => 1,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/contacts'
payload = {
    "name": "vel",
    "contact_type": "COMPANY",
    "is_customer": true,
    "customer_number": 1,
    "is_vendor": false,
    "vendor_number": 17,
    "phone": 81549300,
    "mobile": 91509000,
    "email": "witting.enoch@example.org",
    "web": "http:\/\/douglas.com\/",
    "notes": "praesentium",
    "vat_identification_number": "sed",
    "default_delivery_address_id": 1,
    "default_invoice_address_id": 2,
    "external_id": 1
}
headers = {
  'Authorization': 'Bearer 4a8aDPbdEv6cgZ3kef5V61h',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

POST contacts

Headers

Authorization      

Example: Bearer 4a8aDPbdEv6cgZ3kef5V61h

Content-Type      

Example: application/json

Accept      

Example: application/json

Body Parameters

name   string   

Example: vel

contact_type   string  optional  

Example: COMPANY

Must be one of:
  • COMPANY
  • PERSON
  • OTHER
is_customer   boolean  optional  

Example: true

customer_number   integer  optional  

Example: 1

is_vendor   boolean  optional  

Example: false

vendor_number   integer  optional  

Example: 17

phone   string  optional  

Must be between 8 and 12 digits. Example: 81549300

mobile   string  optional  

Must be between 8 and 12 digits. Example: 91509000

email   string  optional  

Must be a valid email address. Example: witting.enoch@example.org

web   string  optional  

Must be a valid URL. Example: http://douglas.com/

notes   string  optional  

Example: praesentium

vat_identification_number   string  optional  

Example: sed

default_delivery_address_id   integer  optional  

Example: 1

default_invoice_address_id   integer  optional  

Example: 2

external_id   integer  optional  

Example: 1

PUT /contacts/{contact}

requires authentication

Example request:
curl --request PUT \
    "https://api.kvalitetskontroll.no/contacts/1" \
    --header "Authorization: Bearer vk45Zg8b6Ddh1fVe36acPEa" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"sed\",
    \"contact_type\": \"OTHER\",
    \"is_customer\": false,
    \"customer_number\": 3,
    \"is_vendor\": true,
    \"vendor_number\": 16,
    \"phone\": 81549300,
    \"mobile\": 91509000,
    \"email\": \"zweber@example.net\",
    \"web\": \"http:\\/\\/ondricka.com\\/nobis-rerum-ea-officiis-soluta\",
    \"notes\": \"dolore\",
    \"vat_identification_number\": \"et\",
    \"default_delivery_address_id\": 5,
    \"default_invoice_address_id\": 12,
    \"external_id\": 15
}"

const url = new URL(
    "https://api.kvalitetskontroll.no/contacts/1"
);

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

let body = {
    "name": "sed",
    "contact_type": "OTHER",
    "is_customer": false,
    "customer_number": 3,
    "is_vendor": true,
    "vendor_number": 16,
    "phone": 81549300,
    "mobile": 91509000,
    "email": "zweber@example.net",
    "web": "http:\/\/ondricka.com\/nobis-rerum-ea-officiis-soluta",
    "notes": "dolore",
    "vat_identification_number": "et",
    "default_delivery_address_id": 5,
    "default_invoice_address_id": 12,
    "external_id": 15
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/contacts/1';
$response = $client->put(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer vk45Zg8b6Ddh1fVe36acPEa',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'sed',
            'contact_type' => 'OTHER',
            'is_customer' => false,
            'customer_number' => 3,
            'is_vendor' => true,
            'vendor_number' => 16,
            'phone' => 81549300,
            'mobile' => 91509000,
            'email' => 'zweber@example.net',
            'web' => 'http://ondricka.com/nobis-rerum-ea-officiis-soluta',
            'notes' => 'dolore',
            'vat_identification_number' => 'et',
            'default_delivery_address_id' => 5,
            'default_invoice_address_id' => 12,
            'external_id' => 15,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/contacts/1'
payload = {
    "name": "sed",
    "contact_type": "OTHER",
    "is_customer": false,
    "customer_number": 3,
    "is_vendor": true,
    "vendor_number": 16,
    "phone": 81549300,
    "mobile": 91509000,
    "email": "zweber@example.net",
    "web": "http:\/\/ondricka.com\/nobis-rerum-ea-officiis-soluta",
    "notes": "dolore",
    "vat_identification_number": "et",
    "default_delivery_address_id": 5,
    "default_invoice_address_id": 12,
    "external_id": 15
}
headers = {
  'Authorization': 'Bearer vk45Zg8b6Ddh1fVe36acPEa',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

PUT contacts/{contact_id}

Headers

Authorization      

Example: Bearer vk45Zg8b6Ddh1fVe36acPEa

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

contact_id   integer   

The ID of the contact. Example: 1

Body Parameters

name   string  optional  

Example: sed

contact_type   string  optional  

Example: OTHER

Must be one of:
  • COMPANY
  • PERSON
  • OTHER
is_customer   boolean  optional  

Example: false

customer_number   integer  optional  

Example: 3

is_vendor   boolean  optional  

Example: true

vendor_number   integer  optional  

Example: 16

phone   string  optional  

Must be between 8 and 12 digits. Example: 81549300

mobile   string  optional  

Must be between 8 and 12 digits. Example: 91509000

email   string  optional  

Must be a valid email address. Example: zweber@example.net

web   string  optional  

Must be a valid URL. Example: http://ondricka.com/nobis-rerum-ea-officiis-soluta

notes   string  optional  

Example: dolore

vat_identification_number   string  optional  

Example: et

default_delivery_address_id   integer  optional  

Example: 5

default_invoice_address_id   integer  optional  

Example: 12

external_id   integer  optional  

Example: 15

POST /contacts/{contact}/categories/{category}

requires authentication

Example request:
curl --request POST \
    "https://api.kvalitetskontroll.no/contacts/1/categories/1" \
    --header "Authorization: Bearer va6Dk53Vgb4E6chPZe8a1df" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.kvalitetskontroll.no/contacts/1/categories/1"
);

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

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/contacts/1/categories/1';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer va6Dk53Vgb4E6chPZe8a1df',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/contacts/1/categories/1'
headers = {
  'Authorization': 'Bearer va6Dk53Vgb4E6chPZe8a1df',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

POST contacts/{contact_id}/categories/{category_id}

Headers

Authorization      

Example: Bearer va6Dk53Vgb4E6chPZe8a1df

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

contact_id   integer   

The ID of the contact. Example: 1

category_id   integer   

The ID of the category. Example: 1

DELETE /contacts/{contact}/categories/{category}

requires authentication

Example request:
curl --request DELETE \
    "https://api.kvalitetskontroll.no/contacts/1/categories/1" \
    --header "Authorization: Bearer 16Pev5kbV3Daf4a8gh6cZEd" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.kvalitetskontroll.no/contacts/1/categories/1"
);

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

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/contacts/1/categories/1';
$response = $client->delete(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer 16Pev5kbV3Daf4a8gh6cZEd',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/contacts/1/categories/1'
headers = {
  'Authorization': 'Bearer 16Pev5kbV3Daf4a8gh6cZEd',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

DELETE contacts/{contact_id}/categories/{category_id}

Headers

Authorization      

Example: Bearer 16Pev5kbV3Daf4a8gh6cZEd

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

contact_id   integer   

The ID of the contact. Example: 1

category_id   integer   

The ID of the category. Example: 1

Countries

GET /countries

requires authentication

Example request:
curl --request GET \
    --get "https://api.kvalitetskontroll.no/countries" \
    --header "Authorization: Bearer Pv5ecDV46E8Z6agbf3k1adh" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.kvalitetskontroll.no/countries"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/countries';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer Pv5ecDV46E8Z6agbf3k1adh',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/countries'
headers = {
  'Authorization': 'Bearer Pv5ecDV46E8Z6agbf3k1adh',
  '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
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

GET countries

Headers

Authorization      

Example: Bearer Pv5ecDV46E8Z6agbf3k1adh

Content-Type      

Example: application/json

Accept      

Example: application/json

GET /countries/{country}

requires authentication

Example request:
curl --request GET \
    --get "https://api.kvalitetskontroll.no/countries/1" \
    --header "Authorization: Bearer EfVhe5aDa4Pdgc1k683vZb6" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.kvalitetskontroll.no/countries/1"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/countries/1';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer EfVhe5aDa4Pdgc1k683vZb6',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/countries/1'
headers = {
  'Authorization': 'Bearer EfVhe5aDa4Pdgc1k683vZb6',
  '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
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

GET countries/{country_id}

Headers

Authorization      

Example: Bearer EfVhe5aDa4Pdgc1k683vZb6

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

country_id   integer   

The ID of the country. Example: 1

Departments

List all departments.

requires authentication

List all departments.

Example request:
curl --request GET \
    --get "https://api.kvalitetskontroll.no/departments" \
    --header "Authorization: Bearer 5gPbv83akdZhE6ec1fVD4a6" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.kvalitetskontroll.no/departments"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/departments';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer 5gPbv83akdZhE6ec1fVD4a6',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/departments'
headers = {
  'Authorization': 'Bearer 5gPbv83akdZhE6ec1fVD4a6',
  '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
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

GET departments

Headers

Authorization      

Example: Bearer 5gPbv83akdZhE6ec1fVD4a6

Content-Type      

Example: application/json

Accept      

Example: application/json

Show department.

requires authentication

Show department.

Example request:
curl --request GET \
    --get "https://api.kvalitetskontroll.no/departments/1" \
    --header "Authorization: Bearer P6Zg45aEVfead6D83chbv1k" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.kvalitetskontroll.no/departments/1"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/departments/1';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer P6Zg45aEVfead6D83chbv1k',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/departments/1'
headers = {
  'Authorization': 'Bearer P6Zg45aEVfead6D83chbv1k',
  '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
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

GET departments/{department_id}

Headers

Authorization      

Example: Bearer P6Zg45aEVfead6D83chbv1k

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

department_id   integer   

The ID of the department. Example: 1

Store department.

requires authentication

Store department.

Example request:
curl --request POST \
    "https://api.kvalitetskontroll.no/departments" \
    --header "Authorization: Bearer 6ge6VE4c8aPadD3hf5bvk1Z" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"department_name\": \"Administration\",
    \"external_id\": \"ABC123\"
}"

const url = new URL(
    "https://api.kvalitetskontroll.no/departments"
);

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

let body = {
    "department_name": "Administration",
    "external_id": "ABC123"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/departments';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer 6ge6VE4c8aPadD3hf5bvk1Z',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'department_name' => 'Administration',
            'external_id' => 'ABC123',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/departments'
payload = {
    "department_name": "Administration",
    "external_id": "ABC123"
}
headers = {
  'Authorization': 'Bearer 6ge6VE4c8aPadD3hf5bvk1Z',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

POST departments

Headers

Authorization      

Example: Bearer 6ge6VE4c8aPadD3hf5bvk1Z

Content-Type      

Example: application/json

Accept      

Example: application/json

Body Parameters

department_name   string  optional  

Example: Administration

external_id   string  optional  

Example: ABC123

Update department.

requires authentication

Update department.

Example request:
curl --request PUT \
    "https://api.kvalitetskontroll.no/departments/1" \
    --header "Authorization: Bearer bdevf8c4615aZ3ghD6PaEVk" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"department_name\": \"Administration\",
    \"external_id\": \"ABC123\"
}"

const url = new URL(
    "https://api.kvalitetskontroll.no/departments/1"
);

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

let body = {
    "department_name": "Administration",
    "external_id": "ABC123"
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/departments/1';
$response = $client->put(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer bdevf8c4615aZ3ghD6PaEVk',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'department_name' => 'Administration',
            'external_id' => 'ABC123',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/departments/1'
payload = {
    "department_name": "Administration",
    "external_id": "ABC123"
}
headers = {
  'Authorization': 'Bearer bdevf8c4615aZ3ghD6PaEVk',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

PUT departments/{department_id}

Headers

Authorization      

Example: Bearer bdevf8c4615aZ3ghD6PaEVk

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

department_id   integer   

The ID of the department. Example: 1

Body Parameters

department_name   string  optional  

Example: Administration

external_id   string  optional  

Example: ABC123

Delete department.

requires authentication

Delete department.

Example request:
curl --request DELETE \
    "https://api.kvalitetskontroll.no/departments/1" \
    --header "Authorization: Bearer hZkdaf3gbEa6vc85e1P64DV" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.kvalitetskontroll.no/departments/1"
);

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

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/departments/1';
$response = $client->delete(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer hZkdaf3gbEa6vc85e1P64DV',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/departments/1'
headers = {
  'Authorization': 'Bearer hZkdaf3gbEa6vc85e1P64DV',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

DELETE departments/{department_id}

Headers

Authorization      

Example: Bearer hZkdaf3gbEa6vc85e1P64DV

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

department_id   integer   

The ID of the department. Example: 1

Employees

GET /employees

requires authentication

Example request:
curl --request GET \
    --get "https://api.kvalitetskontroll.no/employees" \
    --header "Authorization: Bearer f8avbDe5g13dVEPk4cZ6a6h" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"employee_no\": \"rxivexirylhv\",
    \"is_disabled\": false,
    \"is_deleted\": true,
    \"offset\": 10,
    \"limit\": 6
}"

const url = new URL(
    "https://api.kvalitetskontroll.no/employees"
);

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

let body = {
    "employee_no": "rxivexirylhv",
    "is_disabled": false,
    "is_deleted": true,
    "offset": 10,
    "limit": 6
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/employees';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer f8avbDe5g13dVEPk4cZ6a6h',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'employee_no' => 'rxivexirylhv',
            'is_disabled' => false,
            'is_deleted' => true,
            'offset' => 10,
            'limit' => 6,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/employees'
payload = {
    "employee_no": "rxivexirylhv",
    "is_disabled": false,
    "is_deleted": true,
    "offset": 10,
    "limit": 6
}
headers = {
  'Authorization': 'Bearer f8avbDe5g13dVEPk4cZ6a6h',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

GET employees

Headers

Authorization      

Example: Bearer f8avbDe5g13dVEPk4cZ6a6h

Content-Type      

Example: application/json

Accept      

Example: application/json

Body Parameters

employee_no   string  optional  

Must not be greater than 50 characters. Example: rxivexirylhv

is_disabled   boolean  optional  

Example: false

is_deleted   boolean  optional  

Example: true

offset   integer  optional  

Example: 10

limit   integer  optional  

Example: 6

GET /employees/{employee}

requires authentication

Example request:
curl --request GET \
    --get "https://api.kvalitetskontroll.no/employees/1" \
    --header "Authorization: Bearer 64c3dke5Da16h8ZvgEaPVbf" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.kvalitetskontroll.no/employees/1"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/employees/1';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer 64c3dke5Da16h8ZvgEaPVbf',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/employees/1'
headers = {
  'Authorization': 'Bearer 64c3dke5Da16h8ZvgEaPVbf',
  '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
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

GET employees/{employee_userId}

Headers

Authorization      

Example: Bearer 64c3dke5Da16h8ZvgEaPVbf

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

employee_userId   integer   

Example: 1

POST /employees

requires authentication

Example request:
curl --request POST \
    "https://api.kvalitetskontroll.no/employees" \
    --header "Authorization: Bearer h5kf43gaeDdEca668vbP1VZ" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"user_name\": \"fqcerffbsyghfy\",
    \"first_name\": \"ntxghmnexhejxplhfvd\",
    \"last_name\": \"izrvckjyctpizjdfgocvcqf\",
    \"employee_no\": \"chynqkwysqzx\",
    \"description\": \"Repellendus dolores sint ut tempore.\",
    \"address\": \"p\",
    \"zip\": \"jelculxvssjg\",
    \"city\": \"yxzedpdawxkhtegesc\",
    \"email\": \"kautzer.ora@example.com\",
    \"team\": \"bprjuwywzpzvficvhij\",
    \"position\": \"yijijofdubiom\",
    \"phone\": \"es\",
    \"mobile\": \"hgmkiqxzgt\",
    \"user_role_active\": false,
    \"notes\": \"shknyraudgqqyjcrbzmeohcpr\"
}"

const url = new URL(
    "https://api.kvalitetskontroll.no/employees"
);

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

let body = {
    "user_name": "fqcerffbsyghfy",
    "first_name": "ntxghmnexhejxplhfvd",
    "last_name": "izrvckjyctpizjdfgocvcqf",
    "employee_no": "chynqkwysqzx",
    "description": "Repellendus dolores sint ut tempore.",
    "address": "p",
    "zip": "jelculxvssjg",
    "city": "yxzedpdawxkhtegesc",
    "email": "kautzer.ora@example.com",
    "team": "bprjuwywzpzvficvhij",
    "position": "yijijofdubiom",
    "phone": "es",
    "mobile": "hgmkiqxzgt",
    "user_role_active": false,
    "notes": "shknyraudgqqyjcrbzmeohcpr"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/employees';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer h5kf43gaeDdEca668vbP1VZ',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'user_name' => 'fqcerffbsyghfy',
            'first_name' => 'ntxghmnexhejxplhfvd',
            'last_name' => 'izrvckjyctpizjdfgocvcqf',
            'employee_no' => 'chynqkwysqzx',
            'description' => 'Repellendus dolores sint ut tempore.',
            'address' => 'p',
            'zip' => 'jelculxvssjg',
            'city' => 'yxzedpdawxkhtegesc',
            'email' => 'kautzer.ora@example.com',
            'team' => 'bprjuwywzpzvficvhij',
            'position' => 'yijijofdubiom',
            'phone' => 'es',
            'mobile' => 'hgmkiqxzgt',
            'user_role_active' => false,
            'notes' => 'shknyraudgqqyjcrbzmeohcpr',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/employees'
payload = {
    "user_name": "fqcerffbsyghfy",
    "first_name": "ntxghmnexhejxplhfvd",
    "last_name": "izrvckjyctpizjdfgocvcqf",
    "employee_no": "chynqkwysqzx",
    "description": "Repellendus dolores sint ut tempore.",
    "address": "p",
    "zip": "jelculxvssjg",
    "city": "yxzedpdawxkhtegesc",
    "email": "kautzer.ora@example.com",
    "team": "bprjuwywzpzvficvhij",
    "position": "yijijofdubiom",
    "phone": "es",
    "mobile": "hgmkiqxzgt",
    "user_role_active": false,
    "notes": "shknyraudgqqyjcrbzmeohcpr"
}
headers = {
  'Authorization': 'Bearer h5kf43gaeDdEca668vbP1VZ',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

POST employees

Headers

Authorization      

Example: Bearer h5kf43gaeDdEca668vbP1VZ

Content-Type      

Example: application/json

Accept      

Example: application/json

Body Parameters

user_name   string   

Must not be greater than 50 characters. Example: fqcerffbsyghfy

first_name   string  optional  

Must not be greater than 50 characters. Example: ntxghmnexhejxplhfvd

last_name   string  optional  

Must not be greater than 50 characters. Example: izrvckjyctpizjdfgocvcqf

employee_no   string  optional  

Must not be greater than 50 characters. Example: chynqkwysqzx

description   string  optional  

Must not be greater than 150 characters. Example: Repellendus dolores sint ut tempore.

address   string  optional  

Must not be greater than 100 characters. Example: p

zip   string  optional  

Must not be greater than 50 characters. Example: jelculxvssjg

city   string  optional  

Must not be greater than 50 characters. Example: yxzedpdawxkhtegesc

email   string  optional  

Must not be greater than 100 characters. Example: kautzer.ora@example.com

team   string  optional  

Must not be greater than 150 characters. Example: bprjuwywzpzvficvhij

position   string  optional  

Must not be greater than 255 characters. Example: yijijofdubiom

phone   string  optional  

Must not be greater than 25 characters. Example: es

mobile   string  optional  

Must not be greater than 25 characters. Example: hgmkiqxzgt

user_role_active   boolean  optional  

Example: false

notes   string  optional  

Must not be greater than 255 characters. Example: shknyraudgqqyjcrbzmeohcpr

PUT /employees/{employee}

requires authentication

Example request:
curl --request PUT \
    "https://api.kvalitetskontroll.no/employees/1" \
    --header "Authorization: Bearer 6d3V65c8bEDPaaehZ4gv1kf" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"user_name\": \"flbntftfufuxgucd\",
    \"first_name\": \"of\",
    \"last_name\": \"scysojdnx\",
    \"employee_no\": \"mxoqkkip\",
    \"description\": \"Magni voluptate accusantium itaque.\",
    \"address\": \"uwyoyitw\",
    \"zip\": \"zboxcfh\",
    \"city\": \"lhcilznm\",
    \"email\": \"frederique35@example.net\",
    \"team\": \"khcingxgvopscurxcpgde\",
    \"position\": \"fjfjjidrfbarqmybdbmii\",
    \"phone\": \"g\",
    \"mobile\": \"jv\",
    \"user_role_active\": true,
    \"notes\": \"adgcnjtruszbuzrywobyxjzwp\"
}"

const url = new URL(
    "https://api.kvalitetskontroll.no/employees/1"
);

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

let body = {
    "user_name": "flbntftfufuxgucd",
    "first_name": "of",
    "last_name": "scysojdnx",
    "employee_no": "mxoqkkip",
    "description": "Magni voluptate accusantium itaque.",
    "address": "uwyoyitw",
    "zip": "zboxcfh",
    "city": "lhcilznm",
    "email": "frederique35@example.net",
    "team": "khcingxgvopscurxcpgde",
    "position": "fjfjjidrfbarqmybdbmii",
    "phone": "g",
    "mobile": "jv",
    "user_role_active": true,
    "notes": "adgcnjtruszbuzrywobyxjzwp"
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/employees/1';
$response = $client->put(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer 6d3V65c8bEDPaaehZ4gv1kf',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'user_name' => 'flbntftfufuxgucd',
            'first_name' => 'of',
            'last_name' => 'scysojdnx',
            'employee_no' => 'mxoqkkip',
            'description' => 'Magni voluptate accusantium itaque.',
            'address' => 'uwyoyitw',
            'zip' => 'zboxcfh',
            'city' => 'lhcilznm',
            'email' => 'frederique35@example.net',
            'team' => 'khcingxgvopscurxcpgde',
            'position' => 'fjfjjidrfbarqmybdbmii',
            'phone' => 'g',
            'mobile' => 'jv',
            'user_role_active' => true,
            'notes' => 'adgcnjtruszbuzrywobyxjzwp',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/employees/1'
payload = {
    "user_name": "flbntftfufuxgucd",
    "first_name": "of",
    "last_name": "scysojdnx",
    "employee_no": "mxoqkkip",
    "description": "Magni voluptate accusantium itaque.",
    "address": "uwyoyitw",
    "zip": "zboxcfh",
    "city": "lhcilznm",
    "email": "frederique35@example.net",
    "team": "khcingxgvopscurxcpgde",
    "position": "fjfjjidrfbarqmybdbmii",
    "phone": "g",
    "mobile": "jv",
    "user_role_active": true,
    "notes": "adgcnjtruszbuzrywobyxjzwp"
}
headers = {
  'Authorization': 'Bearer 6d3V65c8bEDPaaehZ4gv1kf',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

PUT employees/{employee_userId}

Headers

Authorization      

Example: Bearer 6d3V65c8bEDPaaehZ4gv1kf

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

employee_userId   integer   

Example: 1

Body Parameters

user_name   string  optional  

Must not be greater than 50 characters. Example: flbntftfufuxgucd

first_name   string  optional  

Must not be greater than 50 characters. Example: of

last_name   string  optional  

Must not be greater than 50 characters. Example: scysojdnx

employee_no   string  optional  

Must not be greater than 50 characters. Example: mxoqkkip

description   string  optional  

Must not be greater than 150 characters. Example: Magni voluptate accusantium itaque.

address   string  optional  

Must not be greater than 100 characters. Example: uwyoyitw

zip   string  optional  

Must not be greater than 50 characters. Example: zboxcfh

city   string  optional  

Must not be greater than 50 characters. Example: lhcilznm

email   string  optional  

Must not be greater than 100 characters. Example: frederique35@example.net

team   string  optional  

Must not be greater than 150 characters. Example: khcingxgvopscurxcpgde

position   string  optional  

Must not be greater than 255 characters. Example: fjfjjidrfbarqmybdbmii

phone   string  optional  

Must not be greater than 25 characters. Example: g

mobile   string  optional  

Must not be greater than 25 characters. Example: jv

user_role_active   boolean  optional  

Example: true

notes   string  optional  

Must not be greater than 255 characters. Example: adgcnjtruszbuzrywobyxjzwp

Endpoints

GET /industries

requires authentication

Example request:
curl --request GET \
    --get "https://api.kvalitetskontroll.no/industries" \
    --header "Authorization: Bearer 4akhPV366ZdgevEc85Dbf1a" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.kvalitetskontroll.no/industries"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/industries';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer 4akhPV366ZdgevEc85Dbf1a',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/industries'
headers = {
  'Authorization': 'Bearer 4akhPV366ZdgevEc85Dbf1a',
  '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
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

GET industries

Headers

Authorization      

Example: Bearer 4akhPV366ZdgevEc85Dbf1a

Content-Type      

Example: application/json

Accept      

Example: application/json

GET /v2/employees

requires authentication

Example request:
curl --request GET \
    --get "https://api.kvalitetskontroll.no/v2/employees" \
    --header "Authorization: Bearer 38ga66dEP4eVchak1fb5DZv" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.kvalitetskontroll.no/v2/employees"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/v2/employees';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer 38ga66dEP4eVchak1fb5DZv',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/v2/employees'
headers = {
  'Authorization': 'Bearer 38ga66dEP4eVchak1fb5DZv',
  '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
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

GET v2/employees

Headers

Authorization      

Example: Bearer 38ga66dEP4eVchak1fb5DZv

Content-Type      

Example: application/json

Accept      

Example: application/json

GET /v2/employees/{employee}

requires authentication

Example request:
curl --request GET \
    --get "https://api.kvalitetskontroll.no/v2/employees/1" \
    --header "Authorization: Bearer bZdEkDcP4hg35V68faev16a" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.kvalitetskontroll.no/v2/employees/1"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/v2/employees/1';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer bZdEkDcP4hg35V68faev16a',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/v2/employees/1'
headers = {
  'Authorization': 'Bearer bZdEkDcP4hg35V68faev16a',
  '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
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

GET v2/employees/{employee_userId}

Headers

Authorization      

Example: Bearer bZdEkDcP4hg35V68faev16a

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

employee_userId   integer   

Example: 1

POST /v2/employees/request-licences/{added}

requires authentication

Example request:
curl --request POST \
    "https://api.kvalitetskontroll.no/v2/employees/request-licences/omnis" \
    --header "Authorization: Bearer aP1hVD3fZvc4d866egkE5ba" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.kvalitetskontroll.no/v2/employees/request-licences/omnis"
);

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

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/v2/employees/request-licences/omnis';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer aP1hVD3fZvc4d866egkE5ba',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/v2/employees/request-licences/omnis'
headers = {
  'Authorization': 'Bearer aP1hVD3fZvc4d866egkE5ba',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

POST v2/employees/request-licences/{added}

Headers

Authorization      

Example: Bearer aP1hVD3fZvc4d866egkE5ba

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

added   string   

Example: omnis

POST /v2/employees

requires authentication

Example request:
curl --request POST \
    "https://api.kvalitetskontroll.no/v2/employees" \
    --header "Authorization: Bearer b34a8kfcEegPVadZv6D61h5" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"user\": {
        \"first_name\": \"ullam\",
        \"last_name\": \"nostrum\",
        \"address\": \"voluptates\",
        \"address_zip\": \"sint\",
        \"address_city\": \"quo\",
        \"email\": \"wprice@example.com\",
        \"phone\": \"aliquid\",
        \"mobile\": \"corrupti\",
        \"education\": \"nihil\",
        \"first_next_of_kin\": \"beatae\",
        \"first_next_of_kin_phone\": \"nihil\",
        \"second_next_of_kin\": \"qui\",
        \"second_next_of_kin_phone\": \"sit\",
        \"username\": \"huqkbcqdyhqqyfllryff\",
        \"password\": \"dj+xhE,(RsuS\\\"\",
        \"send_login\": false,
        \"language\": \"pl\",
        \"birthday\": \"2024-03-13T14:59:40\",
        \"image\": \"est\"
    },
    \"roles\": {
        \"system_user\": true,
        \"project_manager\": false,
        \"hours_admin\": false,
        \"admin\": true,
        \"hr_admin\": false
    },
    \"employee\": {
        \"joined_at\": \"2024-03-13T14:59:40\",
        \"trial_period\": \"consequatur\",
        \"notice_period\": \"ipsum\",
        \"pay\": \"vitae\",
        \"hourly_pay\": \"ducimus\",
        \"overtime_50\": \"ut\",
        \"overtime_100\": \"sint\",
        \"payment_date\": \"accusamus\",
        \"work_time_week\": \"est\",
        \"work_time_weekend\": \"natus\",
        \"employee_id\": \"sint\",
        \"efficiency\": 1,
        \"work_start\": \"14:59\",
        \"work_stop\": \"14:59\",
        \"lunch_start\": \"14:59\",
        \"lunch_stop\": \"14:59\",
        \"position\": [],
        \"team\": [],
        \"external_id\": \"vero\",
        \"notes\": \"consequatur\",
        \"has_access_to_company_files\": false
    },
    \"settings\": {
        \"deviations_external_only\": false,
        \"procedure_project_only\": true,
        \"infotech_key\": \"illum\"
    }
}"

const url = new URL(
    "https://api.kvalitetskontroll.no/v2/employees"
);

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

let body = {
    "user": {
        "first_name": "ullam",
        "last_name": "nostrum",
        "address": "voluptates",
        "address_zip": "sint",
        "address_city": "quo",
        "email": "wprice@example.com",
        "phone": "aliquid",
        "mobile": "corrupti",
        "education": "nihil",
        "first_next_of_kin": "beatae",
        "first_next_of_kin_phone": "nihil",
        "second_next_of_kin": "qui",
        "second_next_of_kin_phone": "sit",
        "username": "huqkbcqdyhqqyfllryff",
        "password": "dj+xhE,(RsuS\"",
        "send_login": false,
        "language": "pl",
        "birthday": "2024-03-13T14:59:40",
        "image": "est"
    },
    "roles": {
        "system_user": true,
        "project_manager": false,
        "hours_admin": false,
        "admin": true,
        "hr_admin": false
    },
    "employee": {
        "joined_at": "2024-03-13T14:59:40",
        "trial_period": "consequatur",
        "notice_period": "ipsum",
        "pay": "vitae",
        "hourly_pay": "ducimus",
        "overtime_50": "ut",
        "overtime_100": "sint",
        "payment_date": "accusamus",
        "work_time_week": "est",
        "work_time_weekend": "natus",
        "employee_id": "sint",
        "efficiency": 1,
        "work_start": "14:59",
        "work_stop": "14:59",
        "lunch_start": "14:59",
        "lunch_stop": "14:59",
        "position": [],
        "team": [],
        "external_id": "vero",
        "notes": "consequatur",
        "has_access_to_company_files": false
    },
    "settings": {
        "deviations_external_only": false,
        "procedure_project_only": true,
        "infotech_key": "illum"
    }
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/v2/employees';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer b34a8kfcEegPVadZv6D61h5',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'user' => [
                'first_name' => 'ullam',
                'last_name' => 'nostrum',
                'address' => 'voluptates',
                'address_zip' => 'sint',
                'address_city' => 'quo',
                'email' => 'wprice@example.com',
                'phone' => 'aliquid',
                'mobile' => 'corrupti',
                'education' => 'nihil',
                'first_next_of_kin' => 'beatae',
                'first_next_of_kin_phone' => 'nihil',
                'second_next_of_kin' => 'qui',
                'second_next_of_kin_phone' => 'sit',
                'username' => 'huqkbcqdyhqqyfllryff',
                'password' => 'dj+xhE,(RsuS"',
                'send_login' => false,
                'language' => 'pl',
                'birthday' => '2024-03-13T14:59:40',
                'image' => 'est',
            ],
            'roles' => [
                'system_user' => true,
                'project_manager' => false,
                'hours_admin' => false,
                'admin' => true,
                'hr_admin' => false,
            ],
            'employee' => [
                'joined_at' => '2024-03-13T14:59:40',
                'trial_period' => 'consequatur',
                'notice_period' => 'ipsum',
                'pay' => 'vitae',
                'hourly_pay' => 'ducimus',
                'overtime_50' => 'ut',
                'overtime_100' => 'sint',
                'payment_date' => 'accusamus',
                'work_time_week' => 'est',
                'work_time_weekend' => 'natus',
                'employee_id' => 'sint',
                'efficiency' => 1,
                'work_start' => '14:59',
                'work_stop' => '14:59',
                'lunch_start' => '14:59',
                'lunch_stop' => '14:59',
                'position' => [],
                'team' => [],
                'external_id' => 'vero',
                'notes' => 'consequatur',
                'has_access_to_company_files' => false,
            ],
            'settings' => [
                'deviations_external_only' => false,
                'procedure_project_only' => true,
                'infotech_key' => 'illum',
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/v2/employees'
payload = {
    "user": {
        "first_name": "ullam",
        "last_name": "nostrum",
        "address": "voluptates",
        "address_zip": "sint",
        "address_city": "quo",
        "email": "wprice@example.com",
        "phone": "aliquid",
        "mobile": "corrupti",
        "education": "nihil",
        "first_next_of_kin": "beatae",
        "first_next_of_kin_phone": "nihil",
        "second_next_of_kin": "qui",
        "second_next_of_kin_phone": "sit",
        "username": "huqkbcqdyhqqyfllryff",
        "password": "dj+xhE,(RsuS\"",
        "send_login": false,
        "language": "pl",
        "birthday": "2024-03-13T14:59:40",
        "image": "est"
    },
    "roles": {
        "system_user": true,
        "project_manager": false,
        "hours_admin": false,
        "admin": true,
        "hr_admin": false
    },
    "employee": {
        "joined_at": "2024-03-13T14:59:40",
        "trial_period": "consequatur",
        "notice_period": "ipsum",
        "pay": "vitae",
        "hourly_pay": "ducimus",
        "overtime_50": "ut",
        "overtime_100": "sint",
        "payment_date": "accusamus",
        "work_time_week": "est",
        "work_time_weekend": "natus",
        "employee_id": "sint",
        "efficiency": 1,
        "work_start": "14:59",
        "work_stop": "14:59",
        "lunch_start": "14:59",
        "lunch_stop": "14:59",
        "position": [],
        "team": [],
        "external_id": "vero",
        "notes": "consequatur",
        "has_access_to_company_files": false
    },
    "settings": {
        "deviations_external_only": false,
        "procedure_project_only": true,
        "infotech_key": "illum"
    }
}
headers = {
  'Authorization': 'Bearer b34a8kfcEegPVadZv6D61h5',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

POST v2/employees

Headers

Authorization      

Example: Bearer b34a8kfcEegPVadZv6D61h5

Content-Type      

Example: application/json

Accept      

Example: application/json

Body Parameters

user   object  optional  
first_name   string  optional  

Example: ullam

last_name   string  optional  

Example: nostrum

address   string  optional  

Example: voluptates

address_zip   string  optional  

Example: sint

address_city   string  optional  

Example: quo

email   string  optional  

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

phone   string  optional  

Example: aliquid

mobile   string  optional  

Example: corrupti

education   string  optional  

Example: nihil

first_next_of_kin   string  optional  

Example: beatae

first_next_of_kin_phone   string  optional  

Example: nihil

second_next_of_kin   string  optional  

Example: qui

second_next_of_kin_phone   string  optional  

Example: sit

username   string  optional  

Must be at least 2 characters. Must not be greater than 255 characters. Example: huqkbcqdyhqqyfllryff

password   string  optional  

Must be at least 8 characters. Must not be greater than 255 characters. Example: dj+xhE,(RsuS"

send_login   boolean  optional  

Example: false

language   string  optional  

Example: pl

Must be one of:
  • nb
  • en
  • pl
  • de
  • lt
  • ru
birthday   string  optional  

Must be a valid date. Example: 2024-03-13T14:59:40

image   string  optional  

Example: est

roles   object  optional  
system_user   boolean  optional  

Example: true

project_manager   boolean  optional  

Example: false

hours_admin   boolean  optional  

Example: false

admin   boolean  optional  

Example: true

hr_admin   boolean  optional  

Example: false

employee   object  optional  
joined_at   string  optional  

Must be a valid date. Example: 2024-03-13T14:59:40

trial_period   string  optional  

Example: consequatur

notice_period   string  optional  

Example: ipsum

pay   string  optional  

Example: vitae

hourly_pay   string  optional  

Example: ducimus

overtime_50   string  optional  

Example: ut

overtime_100   string  optional  

Example: sint

payment_date   string  optional  

Example: accusamus

work_time_week   string  optional  

Example: est

work_time_weekend   string  optional  

Example: natus

employee_id   string  optional  

Example: sint

efficiency   number  optional  

Must be at least 0. Must not be greater than 1. Example: 1

work_start   string  optional  

Must be a valid date in the format H:i. Example: 14:59

work_stop   string  optional  

Must be a valid date in the format H:i. Example: 14:59

lunch_start   string  optional  

Must be a valid date in the format H:i. Example: 14:59

lunch_stop   string  optional  

Must be a valid date in the format H:i. Example: 14:59

position   object  optional  
id   string  optional  
team   object  optional  
id   string  optional  
external_id   string  optional  

Example: vero

notes   string  optional  

Example: consequatur

has_access_to_company_files   boolean  optional  

Example: false

settings   object  optional  
deviations_external_only   boolean  optional  

Example: false

procedure_project_only   boolean  optional  

Example: true

infotech_key   string  optional  

Example: illum

PUT /v2/employees/{employee}/enable

requires authentication

Example request:
curl --request PUT \
    "https://api.kvalitetskontroll.no/v2/employees/1/enable" \
    --header "Authorization: Bearer P45v6bc31gV8hEaZdkafD6e" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.kvalitetskontroll.no/v2/employees/1/enable"
);

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

fetch(url, {
    method: "PUT",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/v2/employees/1/enable';
$response = $client->put(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer P45v6bc31gV8hEaZdkafD6e',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/v2/employees/1/enable'
headers = {
  'Authorization': 'Bearer P45v6bc31gV8hEaZdkafD6e',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

PUT v2/employees/{employee_userId}/enable

Headers

Authorization      

Example: Bearer P45v6bc31gV8hEaZdkafD6e

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

employee_userId   integer   

Example: 1

PUT /v2/employees/{employee}/disable

requires authentication

Example request:
curl --request PUT \
    "https://api.kvalitetskontroll.no/v2/employees/1/disable" \
    --header "Authorization: Bearer 4akDVcEea1b63hP6Zfv5d8g" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.kvalitetskontroll.no/v2/employees/1/disable"
);

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

fetch(url, {
    method: "PUT",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/v2/employees/1/disable';
$response = $client->put(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer 4akDVcEea1b63hP6Zfv5d8g',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/v2/employees/1/disable'
headers = {
  'Authorization': 'Bearer 4akDVcEea1b63hP6Zfv5d8g',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

PUT v2/employees/{employee_userId}/disable

Headers

Authorization      

Example: Bearer 4akDVcEea1b63hP6Zfv5d8g

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

employee_userId   integer   

Example: 1

POST /v2/employees/{employee}/forgot-password-email

requires authentication

Example request:
curl --request POST \
    "https://api.kvalitetskontroll.no/v2/employees/1/forgot-password-email" \
    --header "Authorization: Bearer hDvVe6cb53ZgaEfk8aP41d6" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.kvalitetskontroll.no/v2/employees/1/forgot-password-email"
);

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

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/v2/employees/1/forgot-password-email';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer hDvVe6cb53ZgaEfk8aP41d6',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/v2/employees/1/forgot-password-email'
headers = {
  'Authorization': 'Bearer hDvVe6cb53ZgaEfk8aP41d6',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

POST v2/employees/{employee_userId}/forgot-password-email

Headers

Authorization      

Example: Bearer hDvVe6cb53ZgaEfk8aP41d6

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

employee_userId   integer   

Example: 1

POST /v2/employees/{employee}/forgot-password-sms

requires authentication

Example request:
curl --request POST \
    "https://api.kvalitetskontroll.no/v2/employees/1/forgot-password-sms" \
    --header "Authorization: Bearer 1d6g46PZvaVEfhD3ac5eb8k" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.kvalitetskontroll.no/v2/employees/1/forgot-password-sms"
);

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

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/v2/employees/1/forgot-password-sms';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer 1d6g46PZvaVEfhD3ac5eb8k',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/v2/employees/1/forgot-password-sms'
headers = {
  'Authorization': 'Bearer 1d6g46PZvaVEfhD3ac5eb8k',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

POST v2/employees/{employee_userId}/forgot-password-sms

Headers

Authorization      

Example: Bearer 1d6g46PZvaVEfhD3ac5eb8k

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

employee_userId   integer   

Example: 1

POST /v2/employees/{employee}/assign-to-projects

requires authentication

Example request:
curl --request POST \
    "https://api.kvalitetskontroll.no/v2/employees/1/assign-to-projects" \
    --header "Authorization: Bearer 41kZVD38cvb6ahf56PdagEe" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \

const url = new URL(
    "https://api.kvalitetskontroll.no/v2/employees/1/assign-to-projects"
);

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

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/v2/employees/1/assign-to-projects';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer 41kZVD38cvb6ahf56PdagEe',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/v2/employees/1/assign-to-projects'
headers = {
  'Authorization': 'Bearer 41kZVD38cvb6ahf56PdagEe',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

POST v2/employees/{employee_userId}/assign-to-projects

Headers

Authorization      

Example: Bearer 41kZVD38cvb6ahf56PdagEe

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

employee_userId   integer   

Example: 1

Body Parameters

project_ids   string[]  optional  

Me

GET /me

requires authentication

Example request:
curl --request GET \
    --get "https://api.kvalitetskontroll.no/me" \
    --header "Authorization: Bearer bVfdeg46Zac8Dah16P5kE3v" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.kvalitetskontroll.no/me"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/me';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer bVfdeg46Zac8Dah16P5kE3v',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/me'
headers = {
  'Authorization': 'Bearer bVfdeg46Zac8Dah16P5kE3v',
  '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
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

GET me

Headers

Authorization      

Example: Bearer bVfdeg46Zac8Dah16P5kE3v

Content-Type      

Example: application/json

Accept      

Example: application/json

Owner

Endpoints for owner company

GET /owner

requires authentication

Example request:
curl --request GET \
    --get "https://api.kvalitetskontroll.no/owner" \
    --header "Authorization: Bearer gda5V1bh86f4c36kvPaeEZD" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.kvalitetskontroll.no/owner"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/owner';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer gda5V1bh86f4c36kvPaeEZD',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/owner'
headers = {
  'Authorization': 'Bearer gda5V1bh86f4c36kvPaeEZD',
  '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
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

GET owner

Headers

Authorization      

Example: Bearer gda5V1bh86f4c36kvPaeEZD

Content-Type      

Example: application/json

Accept      

Example: application/json

Product Categories

GET /productcategories

requires authentication

Example request:
curl --request GET \
    --get "https://api.kvalitetskontroll.no/productcategories" \
    --header "Authorization: Bearer fh13aDVZag65dke6c48EbvP" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.kvalitetskontroll.no/productcategories"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/productcategories';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer fh13aDVZag65dke6c48EbvP',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/productcategories'
headers = {
  'Authorization': 'Bearer fh13aDVZag65dke6c48EbvP',
  '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
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

GET productcategories

Headers

Authorization      

Example: Bearer fh13aDVZag65dke6c48EbvP

Content-Type      

Example: application/json

Accept      

Example: application/json

GET /productcategories/{productcategory}

requires authentication

Example request:
curl --request GET \
    --get "https://api.kvalitetskontroll.no/productcategories/1" \
    --header "Authorization: Bearer d5DvE6k13ac6b4gahVZf8Pe" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.kvalitetskontroll.no/productcategories/1"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/productcategories/1';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer d5DvE6k13ac6b4gahVZf8Pe',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/productcategories/1'
headers = {
  'Authorization': 'Bearer d5DvE6k13ac6b4gahVZf8Pe',
  '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
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

GET productcategories/{productcategory_id}

Headers

Authorization      

Example: Bearer d5DvE6k13ac6b4gahVZf8Pe

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

productcategory_id   integer   

The ID of the productcategory. Example: 1

productcategory   integer  optional  

Example: 1

POST /productcategories

requires authentication

Example request:
curl --request POST \
    "https://api.kvalitetskontroll.no/productcategories" \
    --header "Authorization: Bearer 5c4V6kh6ZfDg1E8aevPbd3a" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"category_name\": \"quai\",
    \"parent_category_id\": 1
}"

const url = new URL(
    "https://api.kvalitetskontroll.no/productcategories"
);

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

let body = {
    "category_name": "quai",
    "parent_category_id": 1
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/productcategories';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer 5c4V6kh6ZfDg1E8aevPbd3a',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'category_name' => 'quai',
            'parent_category_id' => 1,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/productcategories'
payload = {
    "category_name": "quai",
    "parent_category_id": 1
}
headers = {
  'Authorization': 'Bearer 5c4V6kh6ZfDg1E8aevPbd3a',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

POST productcategories

Headers

Authorization      

Example: Bearer 5c4V6kh6ZfDg1E8aevPbd3a

Content-Type      

Example: application/json

Accept      

Example: application/json

Body Parameters

category_name   string   

Must not be greater than 255 characters. Example: quai

parent_category_id   integer  optional  

Example: 1

PUT /productcategories/{productcategory}

requires authentication

Example request:
curl --request PUT \
    "https://api.kvalitetskontroll.no/productcategories/1" \
    --header "Authorization: Bearer a51cdbehZvE8VDfakP664g3" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"category_name\": \"jetzemvlelitoxtlpw\"
}"

const url = new URL(
    "https://api.kvalitetskontroll.no/productcategories/1"
);

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

let body = {
    "category_name": "jetzemvlelitoxtlpw"
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/productcategories/1';
$response = $client->put(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer a51cdbehZvE8VDfakP664g3',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'category_name' => 'jetzemvlelitoxtlpw',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/productcategories/1'
payload = {
    "category_name": "jetzemvlelitoxtlpw"
}
headers = {
  'Authorization': 'Bearer a51cdbehZvE8VDfakP664g3',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

PUT productcategories/{productcategory_id}

Headers

Authorization      

Example: Bearer a51cdbehZvE8VDfakP664g3

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

productcategory_id   integer   

The ID of the productcategory. Example: 1

productcategory   integer  optional  

Example: 2

Body Parameters

category_name   string   

Must not be greater than 255 characters. Example: jetzemvlelitoxtlpw

parent_category_id   integer  optional  

DELETE /productcategories/{productcategory}

requires authentication

Example request:
curl --request DELETE \
    "https://api.kvalitetskontroll.no/productcategories/1" \
    --header "Authorization: Bearer bh6ZP34a5DeEfcv8gV16akd" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.kvalitetskontroll.no/productcategories/1"
);

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

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/productcategories/1';
$response = $client->delete(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer bh6ZP34a5DeEfcv8gV16akd',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/productcategories/1'
headers = {
  'Authorization': 'Bearer bh6ZP34a5DeEfcv8gV16akd',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (200):


{
    "id": 3,
    "category_name": "Uimpregnert",
    "parent": {
        "id": 1,
        "self": "https://api.kvalitetskontroll.no/productcategories/1"
    },
    "children": null
}

Request      

DELETE productcategories/{productcategory_id}

Headers

Authorization      

Example: Bearer bh6ZP34a5DeEfcv8gV16akd

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

productcategory_id   integer   

The ID of the productcategory. Example: 1

productcategory   integer   

Example: 3

Bulk delete product categories.

requires authentication

IDs for categories to delete needs to be sent in as JSON in the request body, like so (javascript):

Example request:
curl --request DELETE \
    "https://api.kvalitetskontroll.no/productcategories" \
    --header "Authorization: Bearer vbZd5gDh6fVPa68E4e1k3ac" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.kvalitetskontroll.no/productcategories"
);

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

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/productcategories';
$response = $client->delete(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer vbZd5gDh6fVPa68E4e1k3ac',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/productcategories'
headers = {
  'Authorization': 'Bearer vbZd5gDh6fVPa68E4e1k3ac',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (200):


{
    "deleted": [
        {
            "id": 1,
            "category_name": "Trevirke",
            "parent": null,
            "children": null
        }
    ],
    "errors": []
}

Request      

DELETE productcategories

Headers

Authorization      

Example: Bearer vbZd5gDh6fVPa68E4e1k3ac

Content-Type      

Example: application/json

Accept      

Example: application/json

Product Data

GET /productdata

requires authentication

Example request:
curl --request GET \
    --get "https://api.kvalitetskontroll.no/productdata" \
    --header "Authorization: Bearer Pckd61aEhfe3vabDZ5Vg648" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.kvalitetskontroll.no/productdata"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/productdata';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer Pckd61aEhfe3vabDZ5Vg648',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/productdata'
headers = {
  'Authorization': 'Bearer Pckd61aEhfe3vabDZ5Vg648',
  '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
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

GET productdata

Headers

Authorization      

Example: Bearer Pckd61aEhfe3vabDZ5Vg648

Content-Type      

Example: application/json

Accept      

Example: application/json

Product Prices

Display a listing of prices for the requested product.

requires authentication

Display a listing of prices for the requested product.

Example request:
curl --request GET \
    --get "https://api.kvalitetskontroll.no/products/1/prices" \
    --header "Authorization: Bearer d4vZEP3gVb8e1ah6aDc65fk" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.kvalitetskontroll.no/products/1/prices"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/products/1/prices';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer d4vZEP3gVb8e1ah6aDc65fk',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/products/1/prices'
headers = {
  'Authorization': 'Bearer d4vZEP3gVb8e1ah6aDc65fk',
  '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
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

GET products/{product_id}/prices

Headers

Authorization      

Example: Bearer d4vZEP3gVb8e1ah6aDc65fk

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

product_id   integer   

The ID of the product. Example: 1

GET /products/{product}/prices/{productprice}

requires authentication

Example request:
curl --request GET \
    --get "https://api.kvalitetskontroll.no/products/1/prices/1" \
    --header "Authorization: Bearer ad4g6a8VDfk6b15hEPZ3cve" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.kvalitetskontroll.no/products/1/prices/1"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/products/1/prices/1';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer ad4g6a8VDfk6b15hEPZ3cve',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/products/1/prices/1'
headers = {
  'Authorization': 'Bearer ad4g6a8VDfk6b15hEPZ3cve',
  '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
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

GET products/{product_id}/prices/{productprice_id}

Headers

Authorization      

Example: Bearer ad4g6a8VDfk6b15hEPZ3cve

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

product_id   integer   

The ID of the product. Example: 1

productprice_id   integer   

The ID of the productprice. Example: 1

POST /products/{product}/prices

requires authentication

Example request:
curl --request POST \
    "https://api.kvalitetskontroll.no/products/1/prices" \
    --header "Authorization: Bearer ecD5PE6hZ13agadbfk4vV68" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"price_title\": \"nfbheajt\",
    \"price_description\": \"est\",
    \"from_date\": \"2020-01-01 00:00:00\",
    \"to_date\": \"2029-12-31 23:59:59\",
    \"vat_type\": {
        \"id\": 1
    },
    \"cost\": 462301.142,
    \"sales_price\": 295475656.87058514
}"

const url = new URL(
    "https://api.kvalitetskontroll.no/products/1/prices"
);

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

let body = {
    "price_title": "nfbheajt",
    "price_description": "est",
    "from_date": "2020-01-01 00:00:00",
    "to_date": "2029-12-31 23:59:59",
    "vat_type": {
        "id": 1
    },
    "cost": 462301.142,
    "sales_price": 295475656.87058514
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/products/1/prices';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer ecD5PE6hZ13agadbfk4vV68',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'price_title' => 'nfbheajt',
            'price_description' => 'est',
            'from_date' => '2020-01-01 00:00:00',
            'to_date' => '2029-12-31 23:59:59',
            'vat_type' => [
                'id' => 1,
            ],
            'cost' => 462301.142,
            'sales_price' => 295475656.87058514,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/products/1/prices'
payload = {
    "price_title": "nfbheajt",
    "price_description": "est",
    "from_date": "2020-01-01 00:00:00",
    "to_date": "2029-12-31 23:59:59",
    "vat_type": {
        "id": 1
    },
    "cost": 462301.142,
    "sales_price": 295475656.87058514
}
headers = {
  'Authorization': 'Bearer ecD5PE6hZ13agadbfk4vV68',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

POST products/{product_id}/prices

Headers

Authorization      

Example: Bearer ecD5PE6hZ13agadbfk4vV68

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

product_id   integer   

The ID of the product. Example: 1

product   integer  optional  

Example: 4

Body Parameters

price_title   string  optional  

Must not be greater than 255 characters. Example: nfbheajt

price_description   string  optional  

Example: est

from_date   date  optional  

Example: 2020-01-01 00:00:00

to_date   date  optional  

Example: 2029-12-31 23:59:59

vat_type   object  optional  
id   integer  optional  

Example: 1

cost   number  optional  

Example: 462301.142

sales_price   number   

Example: 295475656.87059

PUT /products/{product}/prices/{productprice}

requires authentication

Example request:
curl --request PUT \
    "https://api.kvalitetskontroll.no/products/1/prices/1" \
    --header "Authorization: Bearer ZPkdgb64a5faDe1c6V3vE8h" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"price_title\": \"reoycccffwhzwhfjkmfcph\",
    \"price_description\": \"consequatur\",
    \"from_date\": \"2024-03-13T14:59:38\",
    \"to_date\": \"2073-05-09\",
    \"vat_type\": {
        \"id\": 1
    },
    \"cost\": 5.678934452,
    \"sales_price\": 638156.18
}"

const url = new URL(
    "https://api.kvalitetskontroll.no/products/1/prices/1"
);

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

let body = {
    "price_title": "reoycccffwhzwhfjkmfcph",
    "price_description": "consequatur",
    "from_date": "2024-03-13T14:59:38",
    "to_date": "2073-05-09",
    "vat_type": {
        "id": 1
    },
    "cost": 5.678934452,
    "sales_price": 638156.18
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/products/1/prices/1';
$response = $client->put(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer ZPkdgb64a5faDe1c6V3vE8h',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'price_title' => 'reoycccffwhzwhfjkmfcph',
            'price_description' => 'consequatur',
            'from_date' => '2024-03-13T14:59:38',
            'to_date' => '2073-05-09',
            'vat_type' => [
                'id' => 1,
            ],
            'cost' => 5.678934452,
            'sales_price' => 638156.18,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/products/1/prices/1'
payload = {
    "price_title": "reoycccffwhzwhfjkmfcph",
    "price_description": "consequatur",
    "from_date": "2024-03-13T14:59:38",
    "to_date": "2073-05-09",
    "vat_type": {
        "id": 1
    },
    "cost": 5.678934452,
    "sales_price": 638156.18
}
headers = {
  'Authorization': 'Bearer ZPkdgb64a5faDe1c6V3vE8h',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

PUT products/{product_id}/prices/{productprice_id}

Headers

Authorization      

Example: Bearer ZPkdgb64a5faDe1c6V3vE8h

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

product_id   integer   

The ID of the product. Example: 1

productprice_id   integer   

The ID of the productprice. Example: 1

product   integer  optional  

Example: 5

productprice   integer  optional  

Example: 5

Body Parameters

price_title   string  optional  

Must not be greater than 255 characters. Example: reoycccffwhzwhfjkmfcph

price_description   string  optional  

Example: consequatur

from_date   string  optional  

Must be a valid date. Example: 2024-03-13T14:59:38

to_date   string  optional  

Must be a valid date. Must be a date after from_date. Example: 2073-05-09

vat_type   object  optional  
id   integer  optional  

Example: 1

cost   number  optional  

Example: 5.678934452

sales_price   number   

Example: 638156.18

DELETE /products/{product}/prices/{productprice}

requires authentication

Example request:
curl --request DELETE \
    "https://api.kvalitetskontroll.no/products/1/prices/1" \
    --header "Authorization: Bearer 8c4baaeg31dhkEV6fPZv56D" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.kvalitetskontroll.no/products/1/prices/1"
);

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

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/products/1/prices/1';
$response = $client->delete(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer 8c4baaeg31dhkEV6fPZv56D',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/products/1/prices/1'
headers = {
  'Authorization': 'Bearer 8c4baaeg31dhkEV6fPZv56D',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

DELETE products/{product_id}/prices/{productprice_id}

Headers

Authorization      

Example: Bearer 8c4baaeg31dhkEV6fPZv56D

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

product_id   integer   

The ID of the product. Example: 1

productprice_id   integer   

The ID of the productprice. Example: 1

product   integer  optional  

Example: 18

productPrice   integer  optional  

Example: 15

Bulk delete product prices

requires authentication

IDs for prices to delete needs to be sent in as JSON in the request body, like so (javascript):

Example request:
curl --request DELETE \
    "https://api.kvalitetskontroll.no/products/sint/prices" \
    --header "Authorization: Bearer E8eZak6vgf64hc3aV1dPD5b" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.kvalitetskontroll.no/products/sint/prices"
);

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

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/products/sint/prices';
$response = $client->delete(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer E8eZak6vgf64hc3aV1dPD5b',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/products/sint/prices'
headers = {
  'Authorization': 'Bearer E8eZak6vgf64hc3aV1dPD5b',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (200):


{
    "deleted": [
        {
            "id": 1,
            "product": {
                "id": 1,
                "product_number": "QFIZWYIQ",
                "product_name": "ut dolor atque error",
                "supplier_product_number": "397951",
                "product_description": "Deserunt et enim fugiat veniam est quae molestias.",
                "ean": "9171498194647",
                "product_type": 2,
                "do_require_serial_number": false,
                "do_activate_stock": false,
                "external_id": "89013",
                "current_price": null,
                "prices": null,
                "categories": "https://api.kvalitetskontroll.no/api/productcategories",
                "supplier": {
                    "id": 1,
                    "self": "https://api.kvalitetskontroll.no/contacts/1"
                },
                "unit": {
                    "id": 5,
                    "self": "https://api.kvalitetskontroll.no/productunits/5"
                },
                "created_at": "2021-05-27T12:51:06.000000Z",
                "updated_at": "2021-05-27T12:51:06.000000Z",
                "deleted_at": null
            },
            "price_title": "Ordinær varepris",
            "price_description": "Dette er den ordinære prisen for denne varen",
            "from_date": "2021-05-27T12:51:07.000000Z",
            "to_date": null,
            "cost": 11384,
            "sales_price": 20491.2,
            "vat_type": {
                "id": 1,
                "self": "https://api.kvalitetskontroll.no/vattypes/1"
            },
            "created_at": null,
            "updated_at": null
        }
    ],
    "errors": []
}

Request      

DELETE products/{product}/prices

Headers

Authorization      

Example: Bearer E8eZak6vgf64hc3aV1dPD5b

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

product   string   

The product. Example: sint

Product Units

GET /productunits

requires authentication

Example request:
curl --request GET \
    --get "https://api.kvalitetskontroll.no/productunits" \
    --header "Authorization: Bearer kfagd6ahvD813c6ebEZP4V5" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.kvalitetskontroll.no/productunits"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/productunits';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer kfagd6ahvD813c6ebEZP4V5',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/productunits'
headers = {
  'Authorization': 'Bearer kfagd6ahvD813c6ebEZP4V5',
  '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
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

GET productunits

Headers

Authorization      

Example: Bearer kfagd6ahvD813c6ebEZP4V5

Content-Type      

Example: application/json

Accept      

Example: application/json

GET /productunits/{productunit}

requires authentication

Example request:
curl --request GET \
    --get "https://api.kvalitetskontroll.no/productunits/1" \
    --header "Authorization: Bearer V4kZc3vabdEahP6f8g56eD1" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.kvalitetskontroll.no/productunits/1"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/productunits/1';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer V4kZc3vabdEahP6f8g56eD1',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/productunits/1'
headers = {
  'Authorization': 'Bearer V4kZc3vabdEahP6f8g56eD1',
  '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
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

GET productunits/{productunit_id}

Headers

Authorization      

Example: Bearer V4kZc3vabdEahP6f8g56eD1

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

productunit_id   integer   

The ID of the productunit. Example: 1

POST /productunits

requires authentication

Example request:
curl --request POST \
    "https://api.kvalitetskontroll.no/productunits" \
    --header "Authorization: Bearer D3E6Paae14bV5Zgcvkhdf68" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"unit_name\": \"v\"
}"

const url = new URL(
    "https://api.kvalitetskontroll.no/productunits"
);

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

let body = {
    "unit_name": "v"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/productunits';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer D3E6Paae14bV5Zgcvkhdf68',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'unit_name' => 'v',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/productunits'
payload = {
    "unit_name": "v"
}
headers = {
  'Authorization': 'Bearer D3E6Paae14bV5Zgcvkhdf68',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

POST productunits

Headers

Authorization      

Example: Bearer D3E6Paae14bV5Zgcvkhdf68

Content-Type      

Example: application/json

Accept      

Example: application/json

Body Parameters

unit_name   string   

Must not be greater than 255 characters. Example: v

PUT /productunits/{productunit}

requires authentication

Example request:
curl --request PUT \
    "https://api.kvalitetskontroll.no/productunits/1" \
    --header "Authorization: Bearer 4V58vbaach6P6k13gEZfdeD" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"unit_name\": \"klemieom\"
}"

const url = new URL(
    "https://api.kvalitetskontroll.no/productunits/1"
);

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

let body = {
    "unit_name": "klemieom"
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/productunits/1';
$response = $client->put(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer 4V58vbaach6P6k13gEZfdeD',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'unit_name' => 'klemieom',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/productunits/1'
payload = {
    "unit_name": "klemieom"
}
headers = {
  'Authorization': 'Bearer 4V58vbaach6P6k13gEZfdeD',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

PUT productunits/{productunit_id}

Headers

Authorization      

Example: Bearer 4V58vbaach6P6k13gEZfdeD

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

productunit_id   integer   

The ID of the productunit. Example: 1

Body Parameters

unit_name   string   

Must not be greater than 255 characters. Example: klemieom

DELETE /productunits/{productunit}

requires authentication

Example request:
curl --request DELETE \
    "https://api.kvalitetskontroll.no/productunits/1" \
    --header "Authorization: Bearer V6haeEcgP8a4651DkvfdZ3b" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.kvalitetskontroll.no/productunits/1"
);

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

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/productunits/1';
$response = $client->delete(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer V6haeEcgP8a4651DkvfdZ3b',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/productunits/1'
headers = {
  'Authorization': 'Bearer V6haeEcgP8a4651DkvfdZ3b',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

DELETE productunits/{productunit_id}

Headers

Authorization      

Example: Bearer V6haeEcgP8a4651DkvfdZ3b

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

productunit_id   integer   

The ID of the productunit. Example: 1

Bulk delete product units

requires authentication

IDs for units to delete needs to be sent in as JSON in the request body, like so (javascript):

Example request:
curl --request DELETE \
    "https://api.kvalitetskontroll.no/productunits" \
    --header "Authorization: Bearer kZ5c8eD3a4PgdvE6b6Vha1f" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.kvalitetskontroll.no/productunits"
);

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

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/productunits';
$response = $client->delete(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer kZ5c8eD3a4PgdvE6b6Vha1f',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/productunits'
headers = {
  'Authorization': 'Bearer kZ5c8eD3a4PgdvE6b6Vha1f',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (200):


{
    "deleted": [
        {
            "id": 1,
            "unit_name": "stk",
            "deleted_at": "2021-05-27T14:33:08.000000Z"
        }
    ],
    "errors": []
}

Request      

DELETE productunits

Headers

Authorization      

Example: Bearer kZ5c8eD3a4PgdvE6b6Vha1f

Content-Type      

Example: application/json

Accept      

Example: application/json

Products

GET /products

requires authentication

Example request:
curl --request GET \
    --get "https://api.kvalitetskontroll.no/products" \
    --header "Authorization: Bearer 168ZPkefV6dahcaE5Dg4bv3" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.kvalitetskontroll.no/products"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/products';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer 168ZPkefV6dahcaE5Dg4bv3',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/products'
headers = {
  'Authorization': 'Bearer 168ZPkefV6dahcaE5Dg4bv3',
  '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
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

GET products

Headers

Authorization      

Example: Bearer 168ZPkefV6dahcaE5Dg4bv3

Content-Type      

Example: application/json

Accept      

Example: application/json

GET /products/{product}

requires authentication

Example request:
curl --request GET \
    --get "https://api.kvalitetskontroll.no/products/1" \
    --header "Authorization: Bearer bacV665ZEDegv13Pkda8hf4" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.kvalitetskontroll.no/products/1"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/products/1';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer bacV665ZEDegv13Pkda8hf4',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/products/1'
headers = {
  'Authorization': 'Bearer bacV665ZEDegv13Pkda8hf4',
  '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
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

GET products/{product_id}

Headers

Authorization      

Example: Bearer bacV665ZEDegv13Pkda8hf4

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

product_id   integer   

The ID of the product. Example: 1

POST /products

requires authentication

Example request:
curl --request POST \
    "https://api.kvalitetskontroll.no/products" \
    --header "Authorization: Bearer 8e6P1akaZ6ch5vDgbE3d4fV" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"product_number\": \"heryqbbble\",
    \"product_name\": \"xraufhvdshtlaulj\",
    \"product_type\": \"1\",
    \"unit\": {
        \"id\": 2
    },
    \"product_description\": \"qhy\",
    \"ean\": 1234567890123,
    \"supplier_id\": 1,
    \"supplier_product_number\": \"voluptas\",
    \"do_require_serial_number\": true,
    \"do_activate_stock\": true,
    \"external_id\": \"tmpfwpddcdqlyqqo\",
    \"prices\": [
        {
            \"vat_type\": {
                \"id\": 1
            }
        }
    ]
}"

const url = new URL(
    "https://api.kvalitetskontroll.no/products"
);

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

let body = {
    "product_number": "heryqbbble",
    "product_name": "xraufhvdshtlaulj",
    "product_type": "1",
    "unit": {
        "id": 2
    },
    "product_description": "qhy",
    "ean": 1234567890123,
    "supplier_id": 1,
    "supplier_product_number": "voluptas",
    "do_require_serial_number": true,
    "do_activate_stock": true,
    "external_id": "tmpfwpddcdqlyqqo",
    "prices": [
        {
            "vat_type": {
                "id": 1
            }
        }
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/products';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer 8e6P1akaZ6ch5vDgbE3d4fV',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'product_number' => 'heryqbbble',
            'product_name' => 'xraufhvdshtlaulj',
            'product_type' => '1',
            'unit' => [
                'id' => 2,
            ],
            'product_description' => 'qhy',
            'ean' => 1234567890123,
            'supplier_id' => 1.0,
            'supplier_product_number' => 'voluptas',
            'do_require_serial_number' => true,
            'do_activate_stock' => true,
            'external_id' => 'tmpfwpddcdqlyqqo',
            'prices' => [
                [
                    'vat_type' => [
                        'id' => 1,
                    ],
                ],
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/products'
payload = {
    "product_number": "heryqbbble",
    "product_name": "xraufhvdshtlaulj",
    "product_type": "1",
    "unit": {
        "id": 2
    },
    "product_description": "qhy",
    "ean": 1234567890123,
    "supplier_id": 1,
    "supplier_product_number": "voluptas",
    "do_require_serial_number": true,
    "do_activate_stock": true,
    "external_id": "tmpfwpddcdqlyqqo",
    "prices": [
        {
            "vat_type": {
                "id": 1
            }
        }
    ]
}
headers = {
  'Authorization': 'Bearer 8e6P1akaZ6ch5vDgbE3d4fV',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

POST products

Headers

Authorization      

Example: Bearer 8e6P1akaZ6ch5vDgbE3d4fV

Content-Type      

Example: application/json

Accept      

Example: application/json

Body Parameters

product_number   string   

Must not be greater than 255 characters. Example: heryqbbble

product_name   string   

Must not be greater than 255 characters. Example: xraufhvdshtlaulj

product_type   string   

Example: 1

Must be one of:
  • 1
  • 2
unit   object  optional  
id   string   

Example: 2

product_description   string  optional  

Must not be greater than 255 characters. Example: qhy

ean   string  optional  

Must be 13 digits. Example: 1234567890123

supplier_id   number  optional  

Example: 1

supplier_product_number   string  optional  

Example: voluptas

do_require_serial_number   boolean  optional  

Example: true

do_activate_stock   boolean  optional  

Example: true

external_id   string  optional  

Must not be greater than 255 characters. Example: tmpfwpddcdqlyqqo

prices   string[]   

Must have at least 1 items. Example: ozothmgsgreueisgwcwicrltxzlbxxriflqoppd
price_title   string   

Must not be greater than 255 characters. Example: lknrzgrmlnhxlagoxhob

from_date   string   

Must be a valid date. Example: 2024-03-13T14:59:38

to_date   string  optional  

Must be a valid date. Example: 2024-03-13T14:59:38

vat_type   object  optional  
id   integer   

Example: 1

sales_price   string   

Example: est

cost   number   

Example: 165.793901

PUT /products/{product}

requires authentication

Example request:
curl --request PUT \
    "https://api.kvalitetskontroll.no/products/1" \
    --header "Authorization: Bearer 65gP6dhfVkavce18E3Z4aDb" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"product_number\": \"kiisipwibrxxu\",
    \"product_name\": \"bkjhlctaaqgxppf\",
    \"product_type\": \"2\",
    \"unit\": {
        \"id\": 2
    },
    \"product_description\": \"erxytdxvo\",
    \"ean\": 1234567890123,
    \"supplier_id\": 1,
    \"supplier_product_number\": \"eos\",
    \"do_require_serial_number\": false,
    \"do_activate_stock\": true,
    \"external_id\": \"vpbmgo\",
    \"prices\": [
        {
            \"vat_type\": {
                \"id\": 1
            }
        }
    ]
}"

const url = new URL(
    "https://api.kvalitetskontroll.no/products/1"
);

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

let body = {
    "product_number": "kiisipwibrxxu",
    "product_name": "bkjhlctaaqgxppf",
    "product_type": "2",
    "unit": {
        "id": 2
    },
    "product_description": "erxytdxvo",
    "ean": 1234567890123,
    "supplier_id": 1,
    "supplier_product_number": "eos",
    "do_require_serial_number": false,
    "do_activate_stock": true,
    "external_id": "vpbmgo",
    "prices": [
        {
            "vat_type": {
                "id": 1
            }
        }
    ]
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/products/1';
$response = $client->put(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer 65gP6dhfVkavce18E3Z4aDb',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'product_number' => 'kiisipwibrxxu',
            'product_name' => 'bkjhlctaaqgxppf',
            'product_type' => '2',
            'unit' => [
                'id' => 2,
            ],
            'product_description' => 'erxytdxvo',
            'ean' => 1234567890123,
            'supplier_id' => 1.0,
            'supplier_product_number' => 'eos',
            'do_require_serial_number' => false,
            'do_activate_stock' => true,
            'external_id' => 'vpbmgo',
            'prices' => [
                [
                    'vat_type' => [
                        'id' => 1,
                    ],
                ],
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/products/1'
payload = {
    "product_number": "kiisipwibrxxu",
    "product_name": "bkjhlctaaqgxppf",
    "product_type": "2",
    "unit": {
        "id": 2
    },
    "product_description": "erxytdxvo",
    "ean": 1234567890123,
    "supplier_id": 1,
    "supplier_product_number": "eos",
    "do_require_serial_number": false,
    "do_activate_stock": true,
    "external_id": "vpbmgo",
    "prices": [
        {
            "vat_type": {
                "id": 1
            }
        }
    ]
}
headers = {
  'Authorization': 'Bearer 65gP6dhfVkavce18E3Z4aDb',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

PUT products/{product_id}

Headers

Authorization      

Example: Bearer 65gP6dhfVkavce18E3Z4aDb

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

product_id   integer   

The ID of the product. Example: 1

Body Parameters

product_number   string   

Must not be greater than 255 characters. Example: kiisipwibrxxu

product_name   string   

Must not be greater than 255 characters. Example: bkjhlctaaqgxppf

product_type   string   

Example: 2

Must be one of:
  • 1
  • 2
unit   object  optional  
id   string   

Example: 2

product_description   string  optional  

Must not be greater than 255 characters. Example: erxytdxvo

ean   string  optional  

Must be 13 digits. Example: 1234567890123

supplier_id   number  optional  

Example: 1

supplier_product_number   string  optional  

Example: eos

do_require_serial_number   boolean  optional  

Example: false

do_activate_stock   boolean  optional  

Example: true

external_id   string  optional  

Must not be greater than 255 characters. Example: vpbmgo

prices   string[]   

Must have at least 1 items. Example: libeyubagrqwtyenfduwzfmllplouftfvjyhlapagtqllujapdpbvtwegxjodyvjrplwmnsgxcewlqbcymbgar
price_title   string   

Must not be greater than 255 characters. Example: wgienhduut

from_date   string   

Must be a valid date. Example: 2024-03-13T14:59:38

to_date   string  optional  

Must be a valid date. Example: 2024-03-13T14:59:38

vat_type   object  optional  
id   integer   

Example: 1

sales_price   string   

Example: ipsum

cost   number   

Example: 17539

DELETE /products/{product}

requires authentication

Example request:
curl --request DELETE \
    "https://api.kvalitetskontroll.no/products/1" \
    --header "Authorization: Bearer Pa64fbhV6v1dgec8ZDEka53" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.kvalitetskontroll.no/products/1"
);

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

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/products/1';
$response = $client->delete(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer Pa64fbhV6v1dgec8ZDEka53',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/products/1'
headers = {
  'Authorization': 'Bearer Pa64fbhV6v1dgec8ZDEka53',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

DELETE products/{product_id}

Headers

Authorization      

Example: Bearer Pa64fbhV6v1dgec8ZDEka53

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

product_id   integer   

The ID of the product. Example: 1

product   integer   

Example: 1

Bulk delete products

requires authentication

IDs for products to delete needs to be sent in as JSON in the request body, like so (javascript):

Example request:
curl --request DELETE \
    "https://api.kvalitetskontroll.no/products" \
    --header "Authorization: Bearer Ddc5k1aEPV36bgZh4af6ev8" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.kvalitetskontroll.no/products"
);

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

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/products';
$response = $client->delete(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer Ddc5k1aEPV36bgZh4af6ev8',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/products'
headers = {
  'Authorization': 'Bearer Ddc5k1aEPV36bgZh4af6ev8',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (200):


{
    "deleted": [
        {
            "id": 1,
            "product_number": "QFIZWYIQ",
            "product_name": "ut dolor atque error",
            "supplier_product_number": "397951",
            "product_description": "Deserunt et enim fugiat veniam est quae molestias.",
            "ean": "9171498194647",
            "product_type": 2,
            "do_require_serial_number": false,
            "do_activate_stock": false,
            "external_id": "89013",
            "current_price": null,
            "prices": null,
            "categories": "https://api.kvalitetskontroll.no/api/productcategories",
            "supplier": {
                "id": 1,
                "self": "https://api.kvalitetskontroll.no/contacts/1"
            },
            "unit": {
                "id": 5,
                "self": "https://api.kvalitetskontroll.no/productunits/5"
            },
            "created_at": "2021-05-27T12:51:06.000000Z",
            "updated_at": "2021-05-27T14:34:37.000000Z",
            "deleted_at": "2021-05-27T14:34:37.000000Z"
        }
    ],
    "errors": []
}

Request      

DELETE products

Headers

Authorization      

Example: Bearer Ddc5k1aEPV36bgZh4af6ev8

Content-Type      

Example: application/json

Accept      

Example: application/json

Projects

GET /projects

requires authentication

Example request:
curl --request GET \
    --get "https://api.kvalitetskontroll.no/projects" \
    --header "Authorization: Bearer 1Zchefa6gDba8v3V4k6Ed5P" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"project_no\": \"znhzp\",
    \"is_archived\": false,
    \"updated_from\": \"2024-03-13T14:59:27\",
    \"updated_to\": \"2024-03-13T14:59:27\",
    \"offset\": 7,
    \"limit\": 18
}"

const url = new URL(
    "https://api.kvalitetskontroll.no/projects"
);

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

let body = {
    "project_no": "znhzp",
    "is_archived": false,
    "updated_from": "2024-03-13T14:59:27",
    "updated_to": "2024-03-13T14:59:27",
    "offset": 7,
    "limit": 18
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/projects';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer 1Zchefa6gDba8v3V4k6Ed5P',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'project_no' => 'znhzp',
            'is_archived' => false,
            'updated_from' => '2024-03-13T14:59:27',
            'updated_to' => '2024-03-13T14:59:27',
            'offset' => 7,
            'limit' => 18,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/projects'
payload = {
    "project_no": "znhzp",
    "is_archived": false,
    "updated_from": "2024-03-13T14:59:27",
    "updated_to": "2024-03-13T14:59:27",
    "offset": 7,
    "limit": 18
}
headers = {
  'Authorization': 'Bearer 1Zchefa6gDba8v3V4k6Ed5P',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

GET projects

Headers

Authorization      

Example: Bearer 1Zchefa6gDba8v3V4k6Ed5P

Content-Type      

Example: application/json

Accept      

Example: application/json

Body Parameters

project_no   string  optional  

Must not be greater than 50 characters. Example: znhzp

is_archived   boolean  optional  

Example: false

updated_from   string  optional  

Must be a valid date. Example: 2024-03-13T14:59:27

updated_to   string  optional  

Must be a valid date. Example: 2024-03-13T14:59:27

offset   integer  optional  

Example: 7

limit   integer  optional  

Example: 18

GET /projects/{project}

requires authentication

Example request:
curl --request GET \
    --get "https://api.kvalitetskontroll.no/projects/2" \
    --header "Authorization: Bearer 56hfP1vckZV4e68Dbad3Eag" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.kvalitetskontroll.no/projects/2"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/projects/2';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer 56hfP1vckZV4e68Dbad3Eag',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/projects/2'
headers = {
  'Authorization': 'Bearer 56hfP1vckZV4e68Dbad3Eag',
  '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
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

GET projects/{project_prosjektId}

Headers

Authorization      

Example: Bearer 56hfP1vckZV4e68Dbad3Eag

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_prosjektId   integer   

Example: 2

GET /projects/{project}/employees

requires authentication

Example request:
curl --request GET \
    --get "https://api.kvalitetskontroll.no/projects/2/employees" \
    --header "Authorization: Bearer e6dfE5gbPV3kZD1aa4v8ch6" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.kvalitetskontroll.no/projects/2/employees"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/projects/2/employees';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer e6dfE5gbPV3kZD1aa4v8ch6',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/projects/2/employees'
headers = {
  'Authorization': 'Bearer e6dfE5gbPV3kZD1aa4v8ch6',
  '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
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

GET projects/{project_prosjektId}/employees

Headers

Authorization      

Example: Bearer e6dfE5gbPV3kZD1aa4v8ch6

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_prosjektId   integer   

Example: 2

POST /projects

requires authentication

Example request:
curl --request POST \
    "https://api.kvalitetskontroll.no/projects" \
    --header "Authorization: Bearer Ekv6D83ha6cfg1ZePadb4V5" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"znmdnxekmfi\",
    \"project_no\": \"qaaevujjdtgps\",
    \"description\": \"Harum beatae eaque delectus impedit dolorem ipsam quis ut.\",
    \"cadastral_unit\": \"wtejamhvlqxxbhjs\",
    \"property_unit\": \"kkgrewxxn\",
    \"leasehold_number\": \"bjvigwvhrordihwthfxmgf\",
    \"condominium_unit_number\": \"oilqinrtydpvgbd\",
    \"developer\": \"yfanvrsm\",
    \"building_number\": \"cbqvmwqnzrgxktrfobqfr\",
    \"residential_number\": \"eoww\",
    \"municipality\": \"eegtufkcyvrxhpnny\",
    \"address\": \"vjwqvwwnkalylrcitknlheqlz\",
    \"zip\": \"reydhzvjnggxikbthhjf\",
    \"city\": \"oudhxdonu\",
    \"responsible_applicant\": false,
    \"responsible_designer\": false,
    \"responsible_contractor\": true,
    \"external_id\": \"cxfdppwcdejhtpvpjzofh\",
    \"level_of_action\": \"1\",
    \"sha\": false,
    \"archived\": true,
    \"is_accessible_to_all\": true,
    \"use_global_hour_types\": false,
    \"file_server_url\": \"http:\\/\\/www.keeling.info\\/quia-minima-tempora-eos-quo\",
    \"project_manager_id\": 1,
    \"supervisor_id\": 1,
    \"cordel_order_number\": \"nulla\",
    \"start_date\": \"2024-03-13T14:59:28\",
    \"end_date\": \"2090-12-31\"
}"

const url = new URL(
    "https://api.kvalitetskontroll.no/projects"
);

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

let body = {
    "name": "znmdnxekmfi",
    "project_no": "qaaevujjdtgps",
    "description": "Harum beatae eaque delectus impedit dolorem ipsam quis ut.",
    "cadastral_unit": "wtejamhvlqxxbhjs",
    "property_unit": "kkgrewxxn",
    "leasehold_number": "bjvigwvhrordihwthfxmgf",
    "condominium_unit_number": "oilqinrtydpvgbd",
    "developer": "yfanvrsm",
    "building_number": "cbqvmwqnzrgxktrfobqfr",
    "residential_number": "eoww",
    "municipality": "eegtufkcyvrxhpnny",
    "address": "vjwqvwwnkalylrcitknlheqlz",
    "zip": "reydhzvjnggxikbthhjf",
    "city": "oudhxdonu",
    "responsible_applicant": false,
    "responsible_designer": false,
    "responsible_contractor": true,
    "external_id": "cxfdppwcdejhtpvpjzofh",
    "level_of_action": "1",
    "sha": false,
    "archived": true,
    "is_accessible_to_all": true,
    "use_global_hour_types": false,
    "file_server_url": "http:\/\/www.keeling.info\/quia-minima-tempora-eos-quo",
    "project_manager_id": 1,
    "supervisor_id": 1,
    "cordel_order_number": "nulla",
    "start_date": "2024-03-13T14:59:28",
    "end_date": "2090-12-31"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/projects';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer Ekv6D83ha6cfg1ZePadb4V5',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'znmdnxekmfi',
            'project_no' => 'qaaevujjdtgps',
            'description' => 'Harum beatae eaque delectus impedit dolorem ipsam quis ut.',
            'cadastral_unit' => 'wtejamhvlqxxbhjs',
            'property_unit' => 'kkgrewxxn',
            'leasehold_number' => 'bjvigwvhrordihwthfxmgf',
            'condominium_unit_number' => 'oilqinrtydpvgbd',
            'developer' => 'yfanvrsm',
            'building_number' => 'cbqvmwqnzrgxktrfobqfr',
            'residential_number' => 'eoww',
            'municipality' => 'eegtufkcyvrxhpnny',
            'address' => 'vjwqvwwnkalylrcitknlheqlz',
            'zip' => 'reydhzvjnggxikbthhjf',
            'city' => 'oudhxdonu',
            'responsible_applicant' => false,
            'responsible_designer' => false,
            'responsible_contractor' => true,
            'external_id' => 'cxfdppwcdejhtpvpjzofh',
            'level_of_action' => '1',
            'sha' => false,
            'archived' => true,
            'is_accessible_to_all' => true,
            'use_global_hour_types' => false,
            'file_server_url' => 'http://www.keeling.info/quia-minima-tempora-eos-quo',
            'project_manager_id' => 1,
            'supervisor_id' => 1,
            'cordel_order_number' => 'nulla',
            'start_date' => '2024-03-13T14:59:28',
            'end_date' => '2090-12-31',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/projects'
payload = {
    "name": "znmdnxekmfi",
    "project_no": "qaaevujjdtgps",
    "description": "Harum beatae eaque delectus impedit dolorem ipsam quis ut.",
    "cadastral_unit": "wtejamhvlqxxbhjs",
    "property_unit": "kkgrewxxn",
    "leasehold_number": "bjvigwvhrordihwthfxmgf",
    "condominium_unit_number": "oilqinrtydpvgbd",
    "developer": "yfanvrsm",
    "building_number": "cbqvmwqnzrgxktrfobqfr",
    "residential_number": "eoww",
    "municipality": "eegtufkcyvrxhpnny",
    "address": "vjwqvwwnkalylrcitknlheqlz",
    "zip": "reydhzvjnggxikbthhjf",
    "city": "oudhxdonu",
    "responsible_applicant": false,
    "responsible_designer": false,
    "responsible_contractor": true,
    "external_id": "cxfdppwcdejhtpvpjzofh",
    "level_of_action": "1",
    "sha": false,
    "archived": true,
    "is_accessible_to_all": true,
    "use_global_hour_types": false,
    "file_server_url": "http:\/\/www.keeling.info\/quia-minima-tempora-eos-quo",
    "project_manager_id": 1,
    "supervisor_id": 1,
    "cordel_order_number": "nulla",
    "start_date": "2024-03-13T14:59:28",
    "end_date": "2090-12-31"
}
headers = {
  'Authorization': 'Bearer Ekv6D83ha6cfg1ZePadb4V5',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

POST projects

Headers

Authorization      

Example: Bearer Ekv6D83ha6cfg1ZePadb4V5

Content-Type      

Example: application/json

Accept      

Example: application/json

Body Parameters

name   string   

Must not be greater than 150 characters. Example: znmdnxekmfi

project_no   string  optional  

Must not be greater than 50 characters. Example: qaaevujjdtgps

description   string  optional  

Must not be greater than 32768 characters. Example: Harum beatae eaque delectus impedit dolorem ipsam quis ut.

cadastral_unit   string  optional  

Must not be greater than 50 characters. Example: wtejamhvlqxxbhjs

property_unit   string  optional  

Must not be greater than 50 characters. Example: kkgrewxxn

leasehold_number   string  optional  

Must not be greater than 50 characters. Example: bjvigwvhrordihwthfxmgf

condominium_unit_number   string  optional  

Must not be greater than 50 characters. Example: oilqinrtydpvgbd

developer   string  optional  

Must not be greater than 150 characters. Example: yfanvrsm

building_number   string  optional  

Must not be greater than 50 characters. Example: cbqvmwqnzrgxktrfobqfr

residential_number   string  optional  

Must not be greater than 50 characters. Example: eoww

municipality   string  optional  

Must not be greater than 100 characters. Example: eegtufkcyvrxhpnny

address   string  optional  

Must not be greater than 100 characters. Example: vjwqvwwnkalylrcitknlheqlz

zip   string  optional  

Must not be greater than 50 characters. Example: reydhzvjnggxikbthhjf

city   string  optional  

Must not be greater than 50 characters. Example: oudhxdonu

responsible_applicant   boolean  optional  

Example: false

responsible_designer   boolean  optional  

Example: false

responsible_contractor   boolean  optional  

Example: true

external_id   string  optional  

Must not be greater than 50 characters. Example: cxfdppwcdejhtpvpjzofh

level_of_action   string  optional  

Example: 1

Must be one of:
  • 1
  • 2
  • 3
sha   boolean  optional  

Example: false

archived   boolean  optional  

Example: true

is_accessible_to_all   boolean  optional  

Example: true

use_global_hour_types   boolean  optional  

Example: false

file_server_url   string  optional  

Must not be greater than 255 characters. Example: http://www.keeling.info/quia-minima-tempora-eos-quo

project_manager_id   integer  optional  

Example: 1

supervisor_id   integer  optional  

Example: 1

contact_id   string  optional  
contact_person_id   string  optional  
cordel_order_number   string  optional  

Example: nulla

start_date   string  optional  

Must be a valid date. Example: 2024-03-13T14:59:28

end_date   string  optional  

Must be a valid date. Must be a date after or equal to start_date. Example: 2090-12-31

PUT /projects/{project}

requires authentication

Example request:
curl --request PUT \
    "https://api.kvalitetskontroll.no/projects/2" \
    --header "Authorization: Bearer k5184efE3a6dVgacvbh6PZD" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"dotpifsqmm\",
    \"project_no\": \"ndhfhcwdjuw\",
    \"description\": \"Perferendis eos magni totam labore reiciendis vero.\",
    \"cadastral_unit\": \"owgrcydsadwb\",
    \"property_unit\": \"guaywrlbjnzge\",
    \"leasehold_number\": \"pmpdxcm\",
    \"condominium_unit_number\": \"smmwtfpxow\",
    \"developer\": \"btznu\",
    \"building_number\": \"on\",
    \"residential_number\": \"qndlabwzbxzlijarxrpkflrn\",
    \"municipality\": \"qzxpiklrxvbjcwbfizocbpyi\",
    \"address\": \"mpmqovnbuhmrgggi\",
    \"zip\": \"pbhmyoxfvell\",
    \"city\": \"ragvdrisyhtgjcpunob\",
    \"responsible_applicant\": false,
    \"responsible_designer\": false,
    \"responsible_contractor\": false,
    \"external_id\": \"kmrxzapjatfhmfwoklnhnzahh\",
    \"level_of_action\": \"2\",
    \"sha\": true,
    \"archived\": true,
    \"is_accessible_to_all\": false,
    \"use_global_hour_types\": true,
    \"file_server_url\": \"http:\\/\\/www.kozey.com\\/nihil-consequatur-ex-sint-quaerat-cupiditate-nobis-quod\",
    \"project_manager_id\": 1,
    \"supervisor_id\": 1,
    \"cordel_order_number\": \"aut\",
    \"start_date\": \"2024-03-13T14:59:28\",
    \"end_date\": \"2043-07-28\"
}"

const url = new URL(
    "https://api.kvalitetskontroll.no/projects/2"
);

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

let body = {
    "name": "dotpifsqmm",
    "project_no": "ndhfhcwdjuw",
    "description": "Perferendis eos magni totam labore reiciendis vero.",
    "cadastral_unit": "owgrcydsadwb",
    "property_unit": "guaywrlbjnzge",
    "leasehold_number": "pmpdxcm",
    "condominium_unit_number": "smmwtfpxow",
    "developer": "btznu",
    "building_number": "on",
    "residential_number": "qndlabwzbxzlijarxrpkflrn",
    "municipality": "qzxpiklrxvbjcwbfizocbpyi",
    "address": "mpmqovnbuhmrgggi",
    "zip": "pbhmyoxfvell",
    "city": "ragvdrisyhtgjcpunob",
    "responsible_applicant": false,
    "responsible_designer": false,
    "responsible_contractor": false,
    "external_id": "kmrxzapjatfhmfwoklnhnzahh",
    "level_of_action": "2",
    "sha": true,
    "archived": true,
    "is_accessible_to_all": false,
    "use_global_hour_types": true,
    "file_server_url": "http:\/\/www.kozey.com\/nihil-consequatur-ex-sint-quaerat-cupiditate-nobis-quod",
    "project_manager_id": 1,
    "supervisor_id": 1,
    "cordel_order_number": "aut",
    "start_date": "2024-03-13T14:59:28",
    "end_date": "2043-07-28"
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/projects/2';
$response = $client->put(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer k5184efE3a6dVgacvbh6PZD',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'dotpifsqmm',
            'project_no' => 'ndhfhcwdjuw',
            'description' => 'Perferendis eos magni totam labore reiciendis vero.',
            'cadastral_unit' => 'owgrcydsadwb',
            'property_unit' => 'guaywrlbjnzge',
            'leasehold_number' => 'pmpdxcm',
            'condominium_unit_number' => 'smmwtfpxow',
            'developer' => 'btznu',
            'building_number' => 'on',
            'residential_number' => 'qndlabwzbxzlijarxrpkflrn',
            'municipality' => 'qzxpiklrxvbjcwbfizocbpyi',
            'address' => 'mpmqovnbuhmrgggi',
            'zip' => 'pbhmyoxfvell',
            'city' => 'ragvdrisyhtgjcpunob',
            'responsible_applicant' => false,
            'responsible_designer' => false,
            'responsible_contractor' => false,
            'external_id' => 'kmrxzapjatfhmfwoklnhnzahh',
            'level_of_action' => '2',
            'sha' => true,
            'archived' => true,
            'is_accessible_to_all' => false,
            'use_global_hour_types' => true,
            'file_server_url' => 'http://www.kozey.com/nihil-consequatur-ex-sint-quaerat-cupiditate-nobis-quod',
            'project_manager_id' => 1,
            'supervisor_id' => 1,
            'cordel_order_number' => 'aut',
            'start_date' => '2024-03-13T14:59:28',
            'end_date' => '2043-07-28',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/projects/2'
payload = {
    "name": "dotpifsqmm",
    "project_no": "ndhfhcwdjuw",
    "description": "Perferendis eos magni totam labore reiciendis vero.",
    "cadastral_unit": "owgrcydsadwb",
    "property_unit": "guaywrlbjnzge",
    "leasehold_number": "pmpdxcm",
    "condominium_unit_number": "smmwtfpxow",
    "developer": "btznu",
    "building_number": "on",
    "residential_number": "qndlabwzbxzlijarxrpkflrn",
    "municipality": "qzxpiklrxvbjcwbfizocbpyi",
    "address": "mpmqovnbuhmrgggi",
    "zip": "pbhmyoxfvell",
    "city": "ragvdrisyhtgjcpunob",
    "responsible_applicant": false,
    "responsible_designer": false,
    "responsible_contractor": false,
    "external_id": "kmrxzapjatfhmfwoklnhnzahh",
    "level_of_action": "2",
    "sha": true,
    "archived": true,
    "is_accessible_to_all": false,
    "use_global_hour_types": true,
    "file_server_url": "http:\/\/www.kozey.com\/nihil-consequatur-ex-sint-quaerat-cupiditate-nobis-quod",
    "project_manager_id": 1,
    "supervisor_id": 1,
    "cordel_order_number": "aut",
    "start_date": "2024-03-13T14:59:28",
    "end_date": "2043-07-28"
}
headers = {
  'Authorization': 'Bearer k5184efE3a6dVgacvbh6PZD',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

PUT projects/{project_prosjektId}

Headers

Authorization      

Example: Bearer k5184efE3a6dVgacvbh6PZD

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_prosjektId   integer   

Example: 2

Body Parameters

name   string  optional  

Must not be greater than 150 characters. Example: dotpifsqmm

project_no   string  optional  

Must not be greater than 50 characters. Example: ndhfhcwdjuw

description   string  optional  

Must not be greater than 32768 characters. Example: Perferendis eos magni totam labore reiciendis vero.

cadastral_unit   string  optional  

Must not be greater than 50 characters. Example: owgrcydsadwb

property_unit   string  optional  

Must not be greater than 50 characters. Example: guaywrlbjnzge

leasehold_number   string  optional  

Must not be greater than 50 characters. Example: pmpdxcm

condominium_unit_number   string  optional  

Must not be greater than 50 characters. Example: smmwtfpxow

developer   string  optional  

Must not be greater than 150 characters. Example: btznu

building_number   string  optional  

Must not be greater than 50 characters. Example: on

residential_number   string  optional  

Must not be greater than 50 characters. Example: qndlabwzbxzlijarxrpkflrn

municipality   string  optional  

Must not be greater than 100 characters. Example: qzxpiklrxvbjcwbfizocbpyi

address   string  optional  

Must not be greater than 100 characters. Example: mpmqovnbuhmrgggi

zip   string  optional  

Must not be greater than 50 characters. Example: pbhmyoxfvell

city   string  optional  

Must not be greater than 50 characters. Example: ragvdrisyhtgjcpunob

responsible_applicant   boolean  optional  

Example: false

responsible_designer   boolean  optional  

Example: false

responsible_contractor   boolean  optional  

Example: false

external_id   string  optional  

Must not be greater than 50 characters. Example: kmrxzapjatfhmfwoklnhnzahh

level_of_action   string  optional  

Example: 2

Must be one of:
  • 1
  • 2
  • 3
sha   boolean  optional  

Example: true

archived   boolean  optional  

Example: true

is_accessible_to_all   boolean  optional  

Example: false

use_global_hour_types   boolean  optional  

Example: true

file_server_url   string  optional  

Must not be greater than 255 characters. Example: http://www.kozey.com/nihil-consequatur-ex-sint-quaerat-cupiditate-nobis-quod

project_manager_id   integer  optional  

Example: 1

supervisor_id   integer  optional  

Example: 1

contact_id   string  optional  
contact_person_id   string  optional  
cordel_order_number   string  optional  

Example: aut

start_date   string  optional  

Must be a valid date. Example: 2024-03-13T14:59:28

end_date   string  optional  

Must be a valid date. Must be a date after or equal to start_date. Example: 2043-07-28

POST /projects/{project}/allow/{user}

requires authentication

Example request:
curl --request POST \
    "https://api.kvalitetskontroll.no/projects/2/allow/1" \
    --header "Authorization: Bearer Z5E6D1a8ehkcda6v3bPgf4V" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.kvalitetskontroll.no/projects/2/allow/1"
);

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

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/projects/2/allow/1';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer Z5E6D1a8ehkcda6v3bPgf4V',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/projects/2/allow/1'
headers = {
  'Authorization': 'Bearer Z5E6D1a8ehkcda6v3bPgf4V',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

POST projects/{project_prosjektId}/allow/{user_userId}

Headers

Authorization      

Example: Bearer Z5E6D1a8ehkcda6v3bPgf4V

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_prosjektId   integer   

Example: 2

user_userId   integer   

Example: 1

POST /projects/{project}/deny/{user}

requires authentication

Example request:
curl --request POST \
    "https://api.kvalitetskontroll.no/projects/2/deny/1" \
    --header "Authorization: Bearer aPe36kZbchEa6V1d48gDvf5" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.kvalitetskontroll.no/projects/2/deny/1"
);

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

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/projects/2/deny/1';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer aPe36kZbchEa6V1d48gDvf5',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/projects/2/deny/1'
headers = {
  'Authorization': 'Bearer aPe36kZbchEa6V1d48gDvf5',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

POST projects/{project_prosjektId}/deny/{user_userId}

Headers

Authorization      

Example: Bearer aPe36kZbchEa6V1d48gDvf5

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_prosjektId   integer   

Example: 2

user_userId   integer   

Example: 1

POST /projects/{project}/hourtypes/{hourtype}

requires authentication

Example request:
curl --request POST \
    "https://api.kvalitetskontroll.no/projects/2/hourtypes/4" \
    --header "Authorization: Bearer hPZf48a316gvVkeDba56dcE" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.kvalitetskontroll.no/projects/2/hourtypes/4"
);

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

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/projects/2/hourtypes/4';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer hPZf48a316gvVkeDba56dcE',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/projects/2/hourtypes/4'
headers = {
  'Authorization': 'Bearer hPZf48a316gvVkeDba56dcE',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

POST projects/{project_prosjektId}/hourtypes/{hourtype_id}

Headers

Authorization      

Example: Bearer hPZf48a316gvVkeDba56dcE

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_prosjektId   integer   

Example: 2

hourtype_id   integer   

The ID of the hourtype. Example: 4

DELETE /projects/{project}/hourtypes/{hourtype}

requires authentication

Example request:
curl --request DELETE \
    "https://api.kvalitetskontroll.no/projects/2/hourtypes/4" \
    --header "Authorization: Bearer 56baZ3Dhe1VvgafPE84cdk6" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.kvalitetskontroll.no/projects/2/hourtypes/4"
);

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

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/projects/2/hourtypes/4';
$response = $client->delete(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer 56baZ3Dhe1VvgafPE84cdk6',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/projects/2/hourtypes/4'
headers = {
  'Authorization': 'Bearer 56baZ3Dhe1VvgafPE84cdk6',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

DELETE projects/{project_prosjektId}/hourtypes/{hourtype_id}

Headers

Authorization      

Example: Bearer 56baZ3Dhe1VvgafPE84cdk6

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_prosjektId   integer   

Example: 2

hourtype_id   integer   

The ID of the hourtype. Example: 4

TimeTracking Addition Types

GET /timetracking/additiontypes

requires authentication

Example request:
curl --request GET \
    --get "https://api.kvalitetskontroll.no/timetracking/additiontypes" \
    --header "Authorization: Bearer ebcdPVZ5D6f63h814Eagvak" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.kvalitetskontroll.no/timetracking/additiontypes"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/timetracking/additiontypes';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer ebcdPVZ5D6f63h814Eagvak',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/timetracking/additiontypes'
headers = {
  'Authorization': 'Bearer ebcdPVZ5D6f63h814Eagvak',
  '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
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

GET timetracking/additiontypes

Headers

Authorization      

Example: Bearer ebcdPVZ5D6f63h814Eagvak

Content-Type      

Example: application/json

Accept      

Example: application/json

GET /timetracking/additiontypes/{additionType}

requires authentication

Example request:
curl --request GET \
    --get "https://api.kvalitetskontroll.no/timetracking/additiontypes/1" \
    --header "Authorization: Bearer fe4Zd85V3bahcDv6gPk6Ea1" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.kvalitetskontroll.no/timetracking/additiontypes/1"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/timetracking/additiontypes/1';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer fe4Zd85V3bahcDv6gPk6Ea1',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/timetracking/additiontypes/1'
headers = {
  'Authorization': 'Bearer fe4Zd85V3bahcDv6gPk6Ea1',
  '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
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

GET timetracking/additiontypes/{additionType_id}

Headers

Authorization      

Example: Bearer fe4Zd85V3bahcDv6gPk6Ea1

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

additionType_id   integer   

The ID of the additionType. Example: 1

POST /timetracking/additiontypes

requires authentication

Example request:
curl --request POST \
    "https://api.kvalitetskontroll.no/timetracking/additiontypes" \
    --header "Authorization: Bearer VeghZPDab66v4Eka8d31f5c" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"title\": \"quod\",
    \"product\": {
        \"id\": 18
    },
    \"use_value_from\": \"default_value\"
}"

const url = new URL(
    "https://api.kvalitetskontroll.no/timetracking/additiontypes"
);

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

let body = {
    "title": "quod",
    "product": {
        "id": 18
    },
    "use_value_from": "default_value"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/timetracking/additiontypes';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer VeghZPDab66v4Eka8d31f5c',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'title' => 'quod',
            'product' => [
                'id' => 18,
            ],
            'use_value_from' => 'default_value',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/timetracking/additiontypes'
payload = {
    "title": "quod",
    "product": {
        "id": 18
    },
    "use_value_from": "default_value"
}
headers = {
  'Authorization': 'Bearer VeghZPDab66v4Eka8d31f5c',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (200):


{
    "id": 7,
    "self": "https://api.kvalitetskontroll.no/timetracking/additiontypes/7",
    "title": "sint",
    "default_value": null,
    "external_id": null,
    "is_billable": false,
    "product": {
        "id": 4,
        "self": "https://api.kvalitetskontroll.no/products/4"
    },
    "use_value_from": "registration_duration",
    "created_at": "2021-05-27T11:26:09.000000Z",
    "created_by": {
        "id": 1,
        "self": "https://api.kvalitetskontroll.no/me/1"
    },
    "updated_at": "2021-05-27T11:26:09.000000Z",
    "updated_by": {
        "id": 1,
        "self": "https://api.kvalitetskontroll.no/me/1"
    },
    "deleted_at": null,
    "deleted_by": null
}

Request      

POST timetracking/additiontypes

Headers

Authorization      

Example: Bearer VeghZPDab66v4Eka8d31f5c

Content-Type      

Example: application/json

Accept      

Example: application/json

Body Parameters

title   string   

Example: quod

product   object  optional  
id   integer  optional  

This field is required when is_billable is == or true. Example: 18

use_value_from   string  optional  

Example: default_value

Must be one of:
  • registration_duration
  • default_value

PUT /timetracking/additiontypes/{additionType}

requires authentication

Example request:
curl --request PUT \
    "https://api.kvalitetskontroll.no/timetracking/additiontypes/1" \
    --header "Authorization: Bearer 3v61c6b8DZgka5ePdVha4fE" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"title\": \"et\",
    \"product\": [],
    \"use_value_from\": \"registration_duration\"
}"

const url = new URL(
    "https://api.kvalitetskontroll.no/timetracking/additiontypes/1"
);

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

let body = {
    "title": "et",
    "product": [],
    "use_value_from": "registration_duration"
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/timetracking/additiontypes/1';
$response = $client->put(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer 3v61c6b8DZgka5ePdVha4fE',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'title' => 'et',
            'product' => [],
            'use_value_from' => 'registration_duration',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/timetracking/additiontypes/1'
payload = {
    "title": "et",
    "product": [],
    "use_value_from": "registration_duration"
}
headers = {
  'Authorization': 'Bearer 3v61c6b8DZgka5ePdVha4fE',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

PUT timetracking/additiontypes/{additionType_id}

Headers

Authorization      

Example: Bearer 3v61c6b8DZgka5ePdVha4fE

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

additionType_id   integer   

The ID of the additionType. Example: 1

Body Parameters

title   string  optional  

Example: et

product   object  optional  
id   integer  optional  
use_value_from   string  optional  

Example: registration_duration

Must be one of:
  • registration_duration
  • default_value

DELETE /timetracking/additiontypes/{additionType}

requires authentication

Example request:
curl --request DELETE \
    "https://api.kvalitetskontroll.no/timetracking/additiontypes/1" \
    --header "Authorization: Bearer 834bfa6d6hgkeZVD5av1EPc" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.kvalitetskontroll.no/timetracking/additiontypes/1"
);

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

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/timetracking/additiontypes/1';
$response = $client->delete(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer 834bfa6d6hgkeZVD5av1EPc',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/timetracking/additiontypes/1'
headers = {
  'Authorization': 'Bearer 834bfa6d6hgkeZVD5av1EPc',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

DELETE timetracking/additiontypes/{additionType_id}

Headers

Authorization      

Example: Bearer 834bfa6d6hgkeZVD5av1EPc

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

additionType_id   integer   

The ID of the additionType. Example: 1

TimeTracking Additions

GET /timetracking/registrations/{registration}/additions

requires authentication

Example request:
curl --request GET \
    --get "https://api.kvalitetskontroll.no/timetracking/registrations/1/additions" \
    --header "Authorization: Bearer E18fVkh45a636bDgPedvZca" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.kvalitetskontroll.no/timetracking/registrations/1/additions"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/timetracking/registrations/1/additions';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer E18fVkh45a636bDgPedvZca',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/timetracking/registrations/1/additions'
headers = {
  'Authorization': 'Bearer E18fVkh45a636bDgPedvZca',
  '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
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

GET timetracking/registrations/{registration_id}/additions

Headers

Authorization      

Example: Bearer E18fVkh45a636bDgPedvZca

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

registration_id   integer   

The ID of the registration. Example: 1

Display the specified resource.

requires authentication

Display the specified resource.

Example request:
curl --request GET \
    --get "https://api.kvalitetskontroll.no/timetracking/registrations/1/additions/5" \
    --header "Authorization: Bearer vV8a6b1e36PkaZhcf5dEgD4" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.kvalitetskontroll.no/timetracking/registrations/1/additions/5"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/timetracking/registrations/1/additions/5';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer vV8a6b1e36PkaZhcf5dEgD4',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/timetracking/registrations/1/additions/5'
headers = {
  'Authorization': 'Bearer vV8a6b1e36PkaZhcf5dEgD4',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (200):


{
    "id": 1,
    "registration": {
        "id": 1,
        "self": "https://api.kvalitetskontroll.no/timetracking/registrations/1"
    },
    "addition_type": {
        "id": 1,
        "self": "https://api.kvalitetskontroll.no/timetracking/additiontypes/1"
    },
    "value": null,
    "deleted_at": null
}

Request      

GET timetracking/registrations/{registration_id}/additions/{additionRegistration_id}

Headers

Authorization      

Example: Bearer vV8a6b1e36PkaZhcf5dEgD4

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

registration_id   integer   

The ID of the registration. Example: 1

additionRegistration_id   integer   

The ID of the additionRegistration. Example: 5

Store a newly created resource in storage.

requires authentication

Store a newly created resource in storage.

Example request:
curl --request POST \
    "https://api.kvalitetskontroll.no/timetracking/registrations/1/additions" \
    --header "Authorization: Bearer e6hvcg41kVbaEP3Z6da8f5D" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"addition_type\": {
        \"id\": 4
    },
    \"value\": 81
}"

const url = new URL(
    "https://api.kvalitetskontroll.no/timetracking/registrations/1/additions"
);

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

let body = {
    "addition_type": {
        "id": 4
    },
    "value": 81
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/timetracking/registrations/1/additions';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer e6hvcg41kVbaEP3Z6da8f5D',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'addition_type' => [
                'id' => 4,
            ],
            'value' => 81,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/timetracking/registrations/1/additions'
payload = {
    "addition_type": {
        "id": 4
    },
    "value": 81
}
headers = {
  'Authorization': 'Bearer e6hvcg41kVbaEP3Z6da8f5D',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (200):


{
    "id": 1,
    "registration": {
        "id": 1,
        "self": "https://api.kvalitetskontroll.no/timetracking/registrations/1"
    },
    "addition_type": {
        "id": 1,
        "self": "https://api.kvalitetskontroll.no/timetracking/additiontypes/1"
    },
    "value": 15.5,
    "deleted_at": null
}

Request      

POST timetracking/registrations/{registration_id}/additions

Headers

Authorization      

Example: Bearer e6hvcg41kVbaEP3Z6da8f5D

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

registration_id   integer   

The ID of the registration. Example: 1

Body Parameters

addition_type   object  optional  
id   integer   

Example: 4

value   number   

Must be at least 0. Example: 81

Update the specified resource in storage

requires authentication

Update the specified resource in storage

Example request:
curl --request PUT \
    "https://api.kvalitetskontroll.no/timetracking/registrations/1/additions/5" \
    --header "Authorization: Bearer gEd5Dk6a316eZafvbPhV8c4" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"addition_type\": {
        \"id\": 18
    },
    \"value\": 54
}"

const url = new URL(
    "https://api.kvalitetskontroll.no/timetracking/registrations/1/additions/5"
);

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

let body = {
    "addition_type": {
        "id": 18
    },
    "value": 54
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/timetracking/registrations/1/additions/5';
$response = $client->put(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer gEd5Dk6a316eZafvbPhV8c4',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'addition_type' => [
                'id' => 18,
            ],
            'value' => 54,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/timetracking/registrations/1/additions/5'
payload = {
    "addition_type": {
        "id": 18
    },
    "value": 54
}
headers = {
  'Authorization': 'Bearer gEd5Dk6a316eZafvbPhV8c4',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (200):


{
    "id": 1,
    "registration": {
        "id": 1,
        "self": "https://api.kvalitetskontroll.no/timetracking/registrations/1"
    },
    "addition_type": {
        "id": 1,
        "self": "https://api.kvalitetskontroll.no/timetracking/additiontypes/1"
    },
    "value": 15.5,
    "deleted_at": null
}

Request      

PUT timetracking/registrations/{registration_id}/additions/{additionRegistration_id}

Headers

Authorization      

Example: Bearer gEd5Dk6a316eZafvbPhV8c4

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

registration_id   integer   

The ID of the registration. Example: 1

additionRegistration_id   integer   

The ID of the additionRegistration. Example: 5

Body Parameters

addition_type   object  optional  
id   integer   

Example: 18

value   number   

Must be at least 0. Example: 54

Remove the specified resource from storage.

requires authentication

Remove the specified resource from storage.

Example request:
curl --request DELETE \
    "https://api.kvalitetskontroll.no/timetracking/registrations/1/additions/5" \
    --header "Authorization: Bearer gaZPD6Ek1e6f4acdV8b53vh" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.kvalitetskontroll.no/timetracking/registrations/1/additions/5"
);

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

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/timetracking/registrations/1/additions/5';
$response = $client->delete(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer gaZPD6Ek1e6f4acdV8b53vh',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/timetracking/registrations/1/additions/5'
headers = {
  'Authorization': 'Bearer gaZPD6Ek1e6f4acdV8b53vh',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (200):


{
    "id": 1,
    "registration": {
        "id": 1,
        "self": "https://api.kvalitetskontroll.no/timetracking/registrations/1"
    },
    "addition_type": {
        "id": 1,
        "self": "https://api.kvalitetskontroll.no/timetracking/additiontypes/1"
    },
    "value": 15.5,
    "deleted_at": "2021-05-27T11:42:54.000000Z"
}

Request      

DELETE timetracking/registrations/{registration_id}/additions/{additionRegistration_id}

Headers

Authorization      

Example: Bearer gaZPD6Ek1e6f4acdV8b53vh

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

registration_id   integer   

The ID of the registration. Example: 1

additionRegistration_id   integer   

The ID of the additionRegistration. Example: 5

TimeTracking Bank Registrations

GET /timetracking/registrations/{registration}/hourbank

requires authentication

Example request:
curl --request GET \
    --get "https://api.kvalitetskontroll.no/timetracking/registrations/1/hourbank" \
    --header "Authorization: Bearer a5dkVa6bZgEch6Dfv41P83e" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.kvalitetskontroll.no/timetracking/registrations/1/hourbank"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/timetracking/registrations/1/hourbank';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer a5dkVa6bZgEch6Dfv41P83e',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/timetracking/registrations/1/hourbank'
headers = {
  'Authorization': 'Bearer a5dkVa6bZgEch6Dfv41P83e',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (200):


{
    "id": 1,
    "registration": {
        "id": 1,
        "self": "https://api.kvalitetskontroll.no/timetracking/registrations/1"
    },
    "duration": 1,
    "updated_at": null,
    "deleted_at": null
}

Request      

GET timetracking/registrations/{registration_id}/hourbank

Headers

Authorization      

Example: Bearer a5dkVa6bZgEch6Dfv41P83e

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

registration_id   integer   

The ID of the registration. Example: 1

Display the specified resource.

requires authentication

Display the specified resource.

Example request:
curl --request GET \
    --get "https://api.kvalitetskontroll.no/timetracking/registrations/1/hourbank/4" \
    --header "Authorization: Bearer h6c6De5V483vbEkPda1gafZ" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.kvalitetskontroll.no/timetracking/registrations/1/hourbank/4"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/timetracking/registrations/1/hourbank/4';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer h6c6De5V483vbEkPda1gafZ',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/timetracking/registrations/1/hourbank/4'
headers = {
  'Authorization': 'Bearer h6c6De5V483vbEkPda1gafZ',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (200):


{
    "id": 1,
    "registration": {
        "id": 1,
        "self": "https://api.kvalitetskontroll.no/timetracking/registrations/1"
    },
    "duration": 1,
    "updated_at": null,
    "deleted_at": null
}

Request      

GET timetracking/registrations/{registration_id}/hourbank/{bankRegistration_id}

Headers

Authorization      

Example: Bearer h6c6De5V483vbEkPda1gafZ

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

registration_id   integer   

The ID of the registration. Example: 1

bankRegistration_id   integer   

The ID of the bankRegistration. Example: 4

Store a newly created resource in storage.

requires authentication

Store a newly created resource in storage.

Example request:
curl --request POST \
    "https://api.kvalitetskontroll.no/timetracking/registrations/1/hourbank" \
    --header "Authorization: Bearer Ea13658cekPg4ZvhV6dDbfa" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"duration\": 6
}"

const url = new URL(
    "https://api.kvalitetskontroll.no/timetracking/registrations/1/hourbank"
);

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

let body = {
    "duration": 6
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/timetracking/registrations/1/hourbank';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer Ea13658cekPg4ZvhV6dDbfa',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'duration' => 6,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/timetracking/registrations/1/hourbank'
payload = {
    "duration": 6
}
headers = {
  'Authorization': 'Bearer Ea13658cekPg4ZvhV6dDbfa',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (200):


{
    "id": 1,
    "registration": {
        "id": 1,
        "self": "https://api.kvalitetskontroll.no/timetracking/registrations/1"
    },
    "duration": 3,
    "updated_at": "2021-05-27T11:54:10.185404Z",
    "deleted_at": null
}

Request      

POST timetracking/registrations/{registration_id}/hourbank

Headers

Authorization      

Example: Bearer Ea13658cekPg4ZvhV6dDbfa

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

registration_id   integer   

The ID of the registration. Example: 1

Body Parameters

duration   integer   

Example: 6

Update the specified resource in storage

requires authentication

Update the specified resource in storage

Example request:
curl --request PUT \
    "https://api.kvalitetskontroll.no/timetracking/registrations/1/hourbank/4" \
    --header "Authorization: Bearer DZh1Pk5e683dagbv4aEcVf6" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"duration\": 13
}"

const url = new URL(
    "https://api.kvalitetskontroll.no/timetracking/registrations/1/hourbank/4"
);

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

let body = {
    "duration": 13
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/timetracking/registrations/1/hourbank/4';
$response = $client->put(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer DZh1Pk5e683dagbv4aEcVf6',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'duration' => 13,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/timetracking/registrations/1/hourbank/4'
payload = {
    "duration": 13
}
headers = {
  'Authorization': 'Bearer DZh1Pk5e683dagbv4aEcVf6',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (200):


{
    "id": 1,
    "registration": {
        "id": 1,
        "self": "https://api.kvalitetskontroll.no/timetracking/registrations/1"
    },
    "duration": 3,
    "updated_at": "2021-05-27T11:54:10.185404Z",
    "deleted_at": null
}

Request      

PUT timetracking/registrations/{registration_id}/hourbank/{bankRegistration_id}

Headers

Authorization      

Example: Bearer DZh1Pk5e683dagbv4aEcVf6

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

registration_id   integer   

The ID of the registration. Example: 1

bankRegistration_id   integer   

The ID of the bankRegistration. Example: 4

Body Parameters

duration   integer   

Example: 13

Remove the specified resource from storage.

requires authentication

Remove the specified resource from storage.

Example request:
curl --request DELETE \
    "https://api.kvalitetskontroll.no/timetracking/registrations/1/hourbank/4" \
    --header "Authorization: Bearer 4ah8gv5acD661bkfZePE3dV" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.kvalitetskontroll.no/timetracking/registrations/1/hourbank/4"
);

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

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/timetracking/registrations/1/hourbank/4';
$response = $client->delete(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer 4ah8gv5acD661bkfZePE3dV',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/timetracking/registrations/1/hourbank/4'
headers = {
  'Authorization': 'Bearer 4ah8gv5acD661bkfZePE3dV',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (200):


{
    "id": 1,
    "registration": {
        "id": 1,
        "self": "https://api.kvalitetskontroll.no/timetracking/registrations/1"
    },
    "duration": 3,
    "updated_at": "2021-05-27T11:57:35.004388Z",
    "deleted_at": "2021-05-27T11:57:35.000000Z"
}

Request      

DELETE timetracking/registrations/{registration_id}/hourbank/{bankRegistration_id}

Headers

Authorization      

Example: Bearer 4ah8gv5acD661bkfZePE3dV

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

registration_id   integer   

The ID of the registration. Example: 1

bankRegistration_id   integer   

The ID of the bankRegistration. Example: 4

TimeTracking Hour Types

GET /timetracking/hourtypes

requires authentication

Example request:
curl --request GET \
    --get "https://api.kvalitetskontroll.no/timetracking/hourtypes" \
    --header "Authorization: Bearer ck3V8fPdEaZ1h4a6De5vgb6" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.kvalitetskontroll.no/timetracking/hourtypes"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/timetracking/hourtypes';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer ck3V8fPdEaZ1h4a6De5vgb6',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/timetracking/hourtypes'
headers = {
  'Authorization': 'Bearer ck3V8fPdEaZ1h4a6De5vgb6',
  '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
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

GET timetracking/hourtypes

Headers

Authorization      

Example: Bearer ck3V8fPdEaZ1h4a6De5vgb6

Content-Type      

Example: application/json

Accept      

Example: application/json

GET /timetracking/hourtypes/{hourType}

requires authentication

Example request:
curl --request GET \
    --get "https://api.kvalitetskontroll.no/timetracking/hourtypes/4" \
    --header "Authorization: Bearer DZ4aP6Vc5bd3fh1vaeEg6k8" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.kvalitetskontroll.no/timetracking/hourtypes/4"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/timetracking/hourtypes/4';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer DZ4aP6Vc5bd3fh1vaeEg6k8',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/timetracking/hourtypes/4'
headers = {
  'Authorization': 'Bearer DZ4aP6Vc5bd3fh1vaeEg6k8',
  '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
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

GET timetracking/hourtypes/{hourType_id}

Headers

Authorization      

Example: Bearer DZ4aP6Vc5bd3fh1vaeEg6k8

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

hourType_id   integer   

The ID of the hourType. Example: 4

GET /timetracking/hourtypes/{hourType}/projects

requires authentication

Example request:
curl --request GET \
    --get "https://api.kvalitetskontroll.no/timetracking/hourtypes/4/projects" \
    --header "Authorization: Bearer ed5v3hacbP6g1DZ86kaVE4f" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.kvalitetskontroll.no/timetracking/hourtypes/4/projects"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/timetracking/hourtypes/4/projects';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer ed5v3hacbP6g1DZ86kaVE4f',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/timetracking/hourtypes/4/projects'
headers = {
  'Authorization': 'Bearer ed5v3hacbP6g1DZ86kaVE4f',
  '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
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

GET timetracking/hourtypes/{hourType_id}/projects

Headers

Authorization      

Example: Bearer ed5v3hacbP6g1DZ86kaVE4f

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

hourType_id   integer   

The ID of the hourType. Example: 4

POST /timetracking/hourtypes

requires authentication

Example request:
curl --request POST \
    "https://api.kvalitetskontroll.no/timetracking/hourtypes" \
    --header "Authorization: Bearer Zh5b14adDeaEVP6kgcfv638" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"title\": \"est\",
    \"is_additions_disabled\": true,
    \"external_id\": \"non\",
    \"is_billable\": true,
    \"is_global\": true,
    \"product\": {
        \"id\": 16
    }
}"

const url = new URL(
    "https://api.kvalitetskontroll.no/timetracking/hourtypes"
);

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

let body = {
    "title": "est",
    "is_additions_disabled": true,
    "external_id": "non",
    "is_billable": true,
    "is_global": true,
    "product": {
        "id": 16
    }
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/timetracking/hourtypes';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer Zh5b14adDeaEVP6kgcfv638',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'title' => 'est',
            'is_additions_disabled' => true,
            'external_id' => 'non',
            'is_billable' => true,
            'is_global' => true,
            'product' => [
                'id' => 16,
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/timetracking/hourtypes'
payload = {
    "title": "est",
    "is_additions_disabled": true,
    "external_id": "non",
    "is_billable": true,
    "is_global": true,
    "product": {
        "id": 16
    }
}
headers = {
  'Authorization': 'Bearer Zh5b14adDeaEVP6kgcfv638',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (200):


{
    "id": 7,
    "self": "https://api.kvalitetskontroll.no/timetracking/hourtypes/7",
    "title": "libero",
    "is_additions_disabled": false,
    "external_id": null,
    "is_billable": false,
    "product": {
        "id": 102,
        "self": "https://api.kvalitetskontroll.no/products/102"
    },
    "created_at": "2021-05-27T12:08:31.000000Z",
    "created_by": {
        "id": 1,
        "self": "https://api.kvalitetskontroll.no/me/1"
    },
    "updated_at": "2021-05-27T12:08:31.000000Z",
    "updated_by": {
        "id": 1,
        "self": "https://api.kvalitetskontroll.no/me/1"
    },
    "deleted_at": null,
    "deleted_by": null
}

Request      

POST timetracking/hourtypes

Headers

Authorization      

Example: Bearer Zh5b14adDeaEVP6kgcfv638

Content-Type      

Example: application/json

Accept      

Example: application/json

Body Parameters

title   string   

Example: est

is_additions_disabled   boolean  optional  

Example: true

external_id   string  optional  

Example: non

is_billable   boolean  optional  

Example: true

is_global   boolean  optional  

Example: true

product   object  optional  
id   integer  optional  

This field is required when is_billable is == or true. Example: 16

PUT /timetracking/hourtypes/{hourType}

requires authentication

Example request:
curl --request PUT \
    "https://api.kvalitetskontroll.no/timetracking/hourtypes/4" \
    --header "Authorization: Bearer E66DfeVdkcgZPb4a5ah381v" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"title\": \"accusantium\",
    \"is_additions_disabled\": false,
    \"external_id\": \"enim\",
    \"is_billable\": false,
    \"is_global\": false,
    \"product\": {
        \"id\": 5
    }
}"

const url = new URL(
    "https://api.kvalitetskontroll.no/timetracking/hourtypes/4"
);

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

let body = {
    "title": "accusantium",
    "is_additions_disabled": false,
    "external_id": "enim",
    "is_billable": false,
    "is_global": false,
    "product": {
        "id": 5
    }
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/timetracking/hourtypes/4';
$response = $client->put(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer E66DfeVdkcgZPb4a5ah381v',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'title' => 'accusantium',
            'is_additions_disabled' => false,
            'external_id' => 'enim',
            'is_billable' => false,
            'is_global' => false,
            'product' => [
                'id' => 5,
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/timetracking/hourtypes/4'
payload = {
    "title": "accusantium",
    "is_additions_disabled": false,
    "external_id": "enim",
    "is_billable": false,
    "is_global": false,
    "product": {
        "id": 5
    }
}
headers = {
  'Authorization': 'Bearer E66DfeVdkcgZPb4a5ah381v',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (200):


{
    "id": 1,
    "self": "https://api.kvalitetskontroll.no/timetracking/hourtypes/1",
    "title": "sunt",
    "is_additions_disabled": false,
    "external_id": null,
    "is_billable": false,
    "product": {
        "id": 102,
        "self": "https://api.kvalitetskontroll.no/products/102"
    },
    "created_at": "2021-05-26T10:48:50.000000Z",
    "created_by": null,
    "updated_at": "2021-05-27T12:05:09.000000Z",
    "updated_by": {
        "id": 1,
        "self": "https://api.kvalitetskontroll.no/me/1"
    },
    "deleted_at": null,
    "deleted_by": null
}

Request      

PUT timetracking/hourtypes/{hourType_id}

Headers

Authorization      

Example: Bearer E66DfeVdkcgZPb4a5ah381v

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

hourType_id   integer   

The ID of the hourType. Example: 4

Body Parameters

title   string   

Example: accusantium

is_additions_disabled   boolean  optional  

Example: false

external_id   string  optional  

Example: enim

is_billable   boolean  optional  

Example: false

is_global   boolean  optional  

Example: false

product   object  optional  
id   integer  optional  

This field is required when is_billable is == or true. Example: 5

DELETE /timetracking/hourtypes/{hourType}

requires authentication

Example request:
curl --request DELETE \
    "https://api.kvalitetskontroll.no/timetracking/hourtypes/4" \
    --header "Authorization: Bearer Zdavh1VPEce6af5463bD8gk" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.kvalitetskontroll.no/timetracking/hourtypes/4"
);

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

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/timetracking/hourtypes/4';
$response = $client->delete(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer Zdavh1VPEce6af5463bD8gk',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/timetracking/hourtypes/4'
headers = {
  'Authorization': 'Bearer Zdavh1VPEce6af5463bD8gk',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

DELETE timetracking/hourtypes/{hourType_id}

Headers

Authorization      

Example: Bearer Zdavh1VPEce6af5463bD8gk

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

hourType_id   integer   

The ID of the hourType. Example: 4

TimeTracking Machine Registrations

GET /timetracking/registrations/{registration}/machines

requires authentication

Example request:
curl --request GET \
    --get "https://api.kvalitetskontroll.no/timetracking/registrations/1/machines" \
    --header "Authorization: Bearer kP61bV5ZDagdv8e4a3Ef6hc" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.kvalitetskontroll.no/timetracking/registrations/1/machines"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/timetracking/registrations/1/machines';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer kP61bV5ZDagdv8e4a3Ef6hc',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/timetracking/registrations/1/machines'
headers = {
  'Authorization': 'Bearer kP61bV5ZDagdv8e4a3Ef6hc',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (200):


[
    {
        "id": 2,
        "registration": {
            "id": 1,
            "self": "https://api.kvalitetskontroll.no/timetracking/registrations/1"
        },
        "machine_type": {
            "id": 1,
            "self": "https://api.kvalitetskontroll.no/timetracking/machinetypes/1"
        },
        "duration": 16,
        "deleted_at": null
    },
    {
        "id": 3,
        "registration": {
            "id": 1,
            "self": "https://api.kvalitetskontroll.no/timetracking/registrations/1"
        },
        "machine_type": {
            "id": 1,
            "self": "https://api.kvalitetskontroll.no/timetracking/machinetypes/1"
        },
        "duration": 16,
        "deleted_at": null
    },
    {
        "id": 4,
        "registration": {
            "id": 1,
            "self": "https://api.kvalitetskontroll.no/timetracking/registrations/1"
        },
        "machine_type": {
            "id": 1,
            "self": "https://api.kvalitetskontroll.no/timetracking/machinetypes/1"
        },
        "duration": 16,
        "deleted_at": null
    }
]

Request      

GET timetracking/registrations/{registration_id}/machines

Headers

Authorization      

Example: Bearer kP61bV5ZDagdv8e4a3Ef6hc

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

registration_id   integer   

The ID of the registration. Example: 1

Display the specified resource.

requires authentication

Display the specified resource.

Example request:
curl --request GET \
    --get "https://api.kvalitetskontroll.no/timetracking/registrations/1/machines/2" \
    --header "Authorization: Bearer dZEDkfv546c16aPb38eVhga" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.kvalitetskontroll.no/timetracking/registrations/1/machines/2"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/timetracking/registrations/1/machines/2';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer dZEDkfv546c16aPb38eVhga',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/timetracking/registrations/1/machines/2'
headers = {
  'Authorization': 'Bearer dZEDkfv546c16aPb38eVhga',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (200):


{
    "id": 2,
    "registration": {
        "id": 1,
        "self": "https://api.kvalitetskontroll.no/timetracking/registrations/1"
    },
    "machine_type": {
        "id": 1,
        "self": "https://api.kvalitetskontroll.no/timetracking/machinetypes/1"
    },
    "duration": 16,
    "deleted_at": null
}

Request      

GET timetracking/registrations/{registration_id}/machines/{machineRegistration_id}

Headers

Authorization      

Example: Bearer dZEDkfv546c16aPb38eVhga

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

registration_id   integer   

The ID of the registration. Example: 1

machineRegistration_id   integer   

The ID of the machineRegistration. Example: 2

Store a newly created resource in storage.

requires authentication

Store a newly created resource in storage.

Example request:
curl --request POST \
    "https://api.kvalitetskontroll.no/timetracking/registrations/1/machines" \
    --header "Authorization: Bearer h6Eaf4aVP6kDcb5Z3vg81ed" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"machine_type\": {
        \"id\": 1
    },
    \"duration\": 4
}"

const url = new URL(
    "https://api.kvalitetskontroll.no/timetracking/registrations/1/machines"
);

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

let body = {
    "machine_type": {
        "id": 1
    },
    "duration": 4
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/timetracking/registrations/1/machines';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer h6Eaf4aVP6kDcb5Z3vg81ed',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'machine_type' => [
                'id' => 1,
            ],
            'duration' => 4,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/timetracking/registrations/1/machines'
payload = {
    "machine_type": {
        "id": 1
    },
    "duration": 4
}
headers = {
  'Authorization': 'Bearer h6Eaf4aVP6kDcb5Z3vg81ed',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

POST timetracking/registrations/{registration_id}/machines

Headers

Authorization      

Example: Bearer h6Eaf4aVP6kDcb5Z3vg81ed

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

registration_id   integer   

The ID of the registration. Example: 1

Body Parameters

machine_type   object  optional  
id   integer  optional  

Example: 1

duration   number   

Must be at least 0. Example: 4

Update the specified resource in storage

requires authentication

Update the specified resource in storage

Example request:
curl --request PUT \
    "https://api.kvalitetskontroll.no/timetracking/registrations/1/machines/2" \
    --header "Authorization: Bearer aV5ehvDfg34kd6cP186baZE" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"machine_type\": {
        \"id\": 4
    },
    \"duration\": 35
}"

const url = new URL(
    "https://api.kvalitetskontroll.no/timetracking/registrations/1/machines/2"
);

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

let body = {
    "machine_type": {
        "id": 4
    },
    "duration": 35
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/timetracking/registrations/1/machines/2';
$response = $client->put(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer aV5ehvDfg34kd6cP186baZE',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'machine_type' => [
                'id' => 4,
            ],
            'duration' => 35,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/timetracking/registrations/1/machines/2'
payload = {
    "machine_type": {
        "id": 4
    },
    "duration": 35
}
headers = {
  'Authorization': 'Bearer aV5ehvDfg34kd6cP186baZE',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (200):


{
    "id": 2,
    "registration": {
        "id": 1,
        "self": "https://api.kvalitetskontroll.no/timetracking/registrations/1"
    },
    "machine_type": {
        "id": 2,
        "self": "https://api.kvalitetskontroll.no/timetracking/machinetypes/2"
    },
    "duration": 5.099714513,
    "deleted_at": null
}

Request      

PUT timetracking/registrations/{registration_id}/machines/{machineRegistration_id}

Headers

Authorization      

Example: Bearer aV5ehvDfg34kd6cP186baZE

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

registration_id   integer   

The ID of the registration. Example: 1

machineRegistration_id   integer   

The ID of the machineRegistration. Example: 2

Body Parameters

machine_type   object  optional  
id   integer   

Example: 4

duration   number   

Must be at least 0. Example: 35

Remove the specified resource from storage.

requires authentication

Remove the specified resource from storage.

Example request:
curl --request DELETE \
    "https://api.kvalitetskontroll.no/timetracking/registrations/1/machines/2" \
    --header "Authorization: Bearer aVg6vchdZae6435EP8Dk1bf" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.kvalitetskontroll.no/timetracking/registrations/1/machines/2"
);

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

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/timetracking/registrations/1/machines/2';
$response = $client->delete(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer aVg6vchdZae6435EP8Dk1bf',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/timetracking/registrations/1/machines/2'
headers = {
  'Authorization': 'Bearer aVg6vchdZae6435EP8Dk1bf',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (200):


{
    "id": 2,
    "registration": {
        "id": 1,
        "self": "https://api.kvalitetskontroll.no/timetracking/registrations/1"
    },
    "machine_type": {
        "id": 2,
        "self": "https://api.kvalitetskontroll.no/timetracking/machinetypes/2"
    },
    "duration": 5,
    "deleted_at": "2021-05-27T12:49:45.000000Z"
}

Request      

DELETE timetracking/registrations/{registration_id}/machines/{machineRegistration_id}

Headers

Authorization      

Example: Bearer aVg6vchdZae6435EP8Dk1bf

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

registration_id   integer   

The ID of the registration. Example: 1

machineRegistration_id   integer   

The ID of the machineRegistration. Example: 2

TimeTracking Machine Types

Returns the awailable MachineTypes for the current company

requires authentication

Returns the awailable MachineTypes for the current company

Example request:
curl --request GET \
    --get "https://api.kvalitetskontroll.no/timetracking/machinetypes" \
    --header "Authorization: Bearer 3a6V6de8bfc4P1DhaZE5kgv" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.kvalitetskontroll.no/timetracking/machinetypes"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/timetracking/machinetypes';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer 3a6V6de8bfc4P1DhaZE5kgv',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/timetracking/machinetypes'
headers = {
  'Authorization': 'Bearer 3a6V6de8bfc4P1DhaZE5kgv',
  '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
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

GET timetracking/machinetypes

Headers

Authorization      

Example: Bearer 3a6V6de8bfc4P1DhaZE5kgv

Content-Type      

Example: application/json

Accept      

Example: application/json

Returns a MachineType by ID

requires authentication

Returns a MachineType by ID

Example request:
curl --request GET \
    --get "https://api.kvalitetskontroll.no/timetracking/machinetypes/1" \
    --header "Authorization: Bearer Pad1vgVakce6bDE835f4hZ6" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.kvalitetskontroll.no/timetracking/machinetypes/1"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/timetracking/machinetypes/1';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer Pad1vgVakce6bDE835f4hZ6',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/timetracking/machinetypes/1'
headers = {
  'Authorization': 'Bearer Pad1vgVakce6bDE835f4hZ6',
  '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
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

GET timetracking/machinetypes/{type_id}

Headers

Authorization      

Example: Bearer Pad1vgVakce6bDE835f4hZ6

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

type_id   integer   

The ID of the type. Example: 1

Stores a new MachineType

requires authentication

Stores a new MachineType

Example request:
curl --request POST \
    "https://api.kvalitetskontroll.no/timetracking/machinetypes" \
    --header "Authorization: Bearer Vg816edb4DPZa3k56hEfcva" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"title\": \"eos\",
    \"is_billable\": false,
    \"product\": {
        \"id\": 4
    },
    \"use_value_from\": \"REGISTRATION_DURATION\"
}"

const url = new URL(
    "https://api.kvalitetskontroll.no/timetracking/machinetypes"
);

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

let body = {
    "title": "eos",
    "is_billable": false,
    "product": {
        "id": 4
    },
    "use_value_from": "REGISTRATION_DURATION"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/timetracking/machinetypes';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer Vg816edb4DPZa3k56hEfcva',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'title' => 'eos',
            'is_billable' => false,
            'product' => [
                'id' => 4,
            ],
            'use_value_from' => 'REGISTRATION_DURATION',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/timetracking/machinetypes'
payload = {
    "title": "eos",
    "is_billable": false,
    "product": {
        "id": 4
    },
    "use_value_from": "REGISTRATION_DURATION"
}
headers = {
  'Authorization': 'Bearer Vg816edb4DPZa3k56hEfcva',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

POST timetracking/machinetypes

Headers

Authorization      

Example: Bearer Vg816edb4DPZa3k56hEfcva

Content-Type      

Example: application/json

Accept      

Example: application/json

Body Parameters

title   string   

Example: eos

is_billable   boolean   

Example: false

product   object  optional  
id   integer  optional  

Example: 4

use_value_from   string  optional  

Example: REGISTRATION_DURATION

Must be one of:
  • REGISTRATION_DURATION

Updates a MachineType

requires authentication

Updates a MachineType

Example request:
curl --request PUT \
    "https://api.kvalitetskontroll.no/timetracking/machinetypes/1" \
    --header "Authorization: Bearer 8D1PZEVe5cfadhk63a46gvb" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"title\": \"non\",
    \"is_billable\": true,
    \"product\": {
        \"id\": 4
    },
    \"use_value_from\": \"REGISTRATION_DURATION\"
}"

const url = new URL(
    "https://api.kvalitetskontroll.no/timetracking/machinetypes/1"
);

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

let body = {
    "title": "non",
    "is_billable": true,
    "product": {
        "id": 4
    },
    "use_value_from": "REGISTRATION_DURATION"
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/timetracking/machinetypes/1';
$response = $client->put(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer 8D1PZEVe5cfadhk63a46gvb',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'title' => 'non',
            'is_billable' => true,
            'product' => [
                'id' => 4,
            ],
            'use_value_from' => 'REGISTRATION_DURATION',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/timetracking/machinetypes/1'
payload = {
    "title": "non",
    "is_billable": true,
    "product": {
        "id": 4
    },
    "use_value_from": "REGISTRATION_DURATION"
}
headers = {
  'Authorization': 'Bearer 8D1PZEVe5cfadhk63a46gvb',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

PUT timetracking/machinetypes/{type_id}

Headers

Authorization      

Example: Bearer 8D1PZEVe5cfadhk63a46gvb

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

type_id   integer   

The ID of the type. Example: 1

Body Parameters

title   string   

Example: non

is_billable   boolean   

Example: true

product   object  optional  
id   integer  optional  

Example: 4

use_value_from   string  optional  

Example: REGISTRATION_DURATION

Must be one of:
  • REGISTRATION_DURATION

Destroys a MachineType

requires authentication

Destroys a MachineType

Example request:
curl --request DELETE \
    "https://api.kvalitetskontroll.no/timetracking/machinetypes/1" \
    --header "Authorization: Bearer a84D6Evfkde5agh61VZcPb3" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.kvalitetskontroll.no/timetracking/machinetypes/1"
);

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

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/timetracking/machinetypes/1';
$response = $client->delete(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer a84D6Evfkde5agh61VZcPb3',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/timetracking/machinetypes/1'
headers = {
  'Authorization': 'Bearer a84D6Evfkde5agh61VZcPb3',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

DELETE timetracking/machinetypes/{type_id}

Headers

Authorization      

Example: Bearer a84D6Evfkde5agh61VZcPb3

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

type_id   integer   

The ID of the type. Example: 1

TimeTracking Overtime Registrations

Returns all overtime registrations associated with a given TimeTrackingRegistration

requires authentication

Returns all overtime registrations associated with a given TimeTrackingRegistration

Example request:
curl --request GET \
    --get "https://api.kvalitetskontroll.no/timetracking/registrations/1/overtimes" \
    --header "Authorization: Bearer d36ED54Vkfa81P6bchagevZ" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.kvalitetskontroll.no/timetracking/registrations/1/overtimes"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/timetracking/registrations/1/overtimes';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer d36ED54Vkfa81P6bchagevZ',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/timetracking/registrations/1/overtimes'
headers = {
  'Authorization': 'Bearer d36ED54Vkfa81P6bchagevZ',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (200):


[
    {
        "id": 2,
        "registration": {
            "id": 1,
            "self": "https://api.kvalitetskontroll.no/timetracking/registrations/1"
        },
        "type": {
            "id": 1,
            "self": "https://api.kvalitetskontroll.no/timetracking/overtimetypes/1"
        },
        "duration": 1,
        "deleted_at": null
    },
    {
        "id": 3,
        "registration": {
            "id": 1,
            "self": "https://api.kvalitetskontroll.no/timetracking/registrations/1"
        },
        "type": {
            "id": 1,
            "self": "https://api.kvalitetskontroll.no/timetracking/overtimetypes/1"
        },
        "duration": 1,
        "deleted_at": null
    }
]

Request      

GET timetracking/registrations/{registration_id}/overtimes

Headers

Authorization      

Example: Bearer d36ED54Vkfa81P6bchagevZ

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

registration_id   integer   

The ID of the registration. Example: 1

Returns a given overtime-registration by id

requires authentication

Returns a given overtime-registration by id

Example request:
curl --request GET \
    --get "https://api.kvalitetskontroll.no/timetracking/registrations/1/overtimes/3" \
    --header "Authorization: Bearer EP4vacVbh1Z8a356edDfkg6" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.kvalitetskontroll.no/timetracking/registrations/1/overtimes/3"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/timetracking/registrations/1/overtimes/3';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer EP4vacVbh1Z8a356edDfkg6',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/timetracking/registrations/1/overtimes/3'
headers = {
  'Authorization': 'Bearer EP4vacVbh1Z8a356edDfkg6',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (200):


{
    "id": 2,
    "registration": {
        "id": 1,
        "self": "https://api.kvalitetskontroll.no/timetracking/registrations/1"
    },
    "type": {
        "id": 1,
        "self": "https://api.kvalitetskontroll.no/timetracking/overtimetypes/1"
    },
    "duration": 1,
    "deleted_at": null
}

Request      

GET timetracking/registrations/{registration_id}/overtimes/{overtimeRegistration_id}

Headers

Authorization      

Example: Bearer EP4vacVbh1Z8a356edDfkg6

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

registration_id   integer   

The ID of the registration. Example: 1

overtimeRegistration_id   integer   

The ID of the overtimeRegistration. Example: 3

Store a new overtime-registration

requires authentication

Store a new overtime-registration

Example request:
curl --request POST \
    "https://api.kvalitetskontroll.no/timetracking/registrations/1/overtimes" \
    --header "Authorization: Bearer 4gbDvc6Zf6aPe31V58Edkha" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"overtime_type\": {
        \"id\": 4
    },
    \"duration\": 64
}"

const url = new URL(
    "https://api.kvalitetskontroll.no/timetracking/registrations/1/overtimes"
);

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

let body = {
    "overtime_type": {
        "id": 4
    },
    "duration": 64
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/timetracking/registrations/1/overtimes';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer 4gbDvc6Zf6aPe31V58Edkha',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'overtime_type' => [
                'id' => 4,
            ],
            'duration' => 64,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/timetracking/registrations/1/overtimes'
payload = {
    "overtime_type": {
        "id": 4
    },
    "duration": 64
}
headers = {
  'Authorization': 'Bearer 4gbDvc6Zf6aPe31V58Edkha',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (200):


{
    "id": 1,
    "registration": {
        "id": 1,
        "user": {
            "id": 1,
            "self": "https://api.kvalitetskontroll.no/employees/1"
        },
        "project": {
            "id": 1,
            "self": "https://api.kvalitetskontroll.no/projects/1"
        },
        "temp_project_label": null,
        "registration_date": "2021-05-20T22:00:00.000000Z",
        "hour_type": {
            "id": 6,
            "self": "https://api.kvalitetskontroll.no/timetracking/hourtypes/6"
        },
        "time_from": "2021-05-21T06:00:00.000000Z",
        "time_to": "2021-05-21T14:00:00.000000Z",
        "break": 30,
        "duration": 442,
        "comment": "Earum odit rerum quo quos.",
        "department": {
            "id": 2,
            "self": "https://api.kvalitetskontroll.no/departments/2"
        },
        "user_efficiency_factor": "0.50000",
        "salary_export_id": null,
        "created_at": "2021-05-26T10:48:50.000000Z",
        "updated_at": "2021-05-27T13:21:12.000000Z",
        "updated_by_admin_at": null,
        "is_approved": false,
        "approved_by": null,
        "is_billed": false,
        "deleted_at": null,
        "billed_by": null,
        "billed_at": null,
        "overtimes": "https://api.kvalitetskontroll.no/timetracking/registrations/1/overtimes",
        "additions": null,
        "machines": null,
        "hourbank": null
    },
    "type": {
        "id": 1,
        "self": "https://api.kvalitetskontroll.no/timetracking/overtimetypes/1",
        "title": "Snekker 100%",
        "overtime_factor": "1.0000",
        "do_add_duration_to_bank": false,
        "external_id": "2000",
        "is_billable": true,
        "product": {
            "id": 1,
            "self": "https://api.kvalitetskontroll.no/products/1"
        },
        "created_at": "2021-05-26T10:48:50.000000Z",
        "created_by": null,
        "updated_at": "2021-05-26T10:48:50.000000Z",
        "updated_by": null,
        "deleted_at": null,
        "deleted_by": null
    },
    "duration": 8,
    "deleted_at": null
}

Request      

POST timetracking/registrations/{registration_id}/overtimes

Headers

Authorization      

Example: Bearer 4gbDvc6Zf6aPe31V58Edkha

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

registration_id   integer   

The ID of the registration. Example: 1

Body Parameters

overtime_type   object  optional  
id   integer   

Example: 4

duration   integer   

Must be at least 0. Example: 64

Updates a existing OvertimeRegistration

requires authentication

Updates a existing OvertimeRegistration

Example request:
curl --request PUT \
    "https://api.kvalitetskontroll.no/timetracking/registrations/1/overtimes/3" \
    --header "Authorization: Bearer evg4kf8hba6E6dDZ1acV5P3" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"overtime_type\": {
        \"id\": 20
    },
    \"duration\": 80
}"

const url = new URL(
    "https://api.kvalitetskontroll.no/timetracking/registrations/1/overtimes/3"
);

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

let body = {
    "overtime_type": {
        "id": 20
    },
    "duration": 80
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/timetracking/registrations/1/overtimes/3';
$response = $client->put(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer evg4kf8hba6E6dDZ1acV5P3',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'overtime_type' => [
                'id' => 20,
            ],
            'duration' => 80,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/timetracking/registrations/1/overtimes/3'
payload = {
    "overtime_type": {
        "id": 20
    },
    "duration": 80
}
headers = {
  'Authorization': 'Bearer evg4kf8hba6E6dDZ1acV5P3',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (200):


{
    "id": 2,
    "registration": {
        "id": 1,
        "user": {
            "id": 1,
            "self": "https://api.kvalitetskontroll.no/employees/1"
        },
        "project": {
            "id": 1,
            "self": "https://api.kvalitetskontroll.no/projects/1"
        },
        "temp_project_label": null,
        "registration_date": "2021-05-20T22:00:00.000000Z",
        "hour_type": {
            "id": 6,
            "self": "https://api.kvalitetskontroll.no/timetracking/hourtypes/6"
        },
        "time_from": "2021-05-21T06:00:00.000000Z",
        "time_to": "2021-05-21T14:00:00.000000Z",
        "break": 30,
        "duration": 430,
        "comment": "Earum odit rerum quo quos.",
        "department": {
            "id": 2,
            "self": "https://api.kvalitetskontroll.no/departments/2"
        },
        "user_efficiency_factor": "0.50000",
        "salary_export_id": null,
        "created_at": "2021-05-26T10:48:50.000000Z",
        "updated_at": "2021-05-27T13:16:21.000000Z",
        "updated_by_admin_at": null,
        "is_approved": false,
        "approved_by": null,
        "is_billed": false,
        "deleted_at": null,
        "billed_by": null,
        "billed_at": null,
        "overtimes": "https://api.kvalitetskontroll.no/timetracking/registrations/1/overtimes",
        "additions": null,
        "machines": null,
        "hourbank": null
    },
    "type": {
        "id": 1,
        "self": "https://api.kvalitetskontroll.no/timetracking/overtimetypes/1",
        "title": "Snekker 100%",
        "overtime_factor": "1.0000",
        "do_add_duration_to_bank": false,
        "external_id": "2000",
        "is_billable": true,
        "product": {
            "id": 1,
            "self": "https://api.kvalitetskontroll.no/products/1"
        },
        "created_at": "2021-05-26T10:48:50.000000Z",
        "created_by": null,
        "updated_at": "2021-05-26T10:48:50.000000Z",
        "updated_by": null,
        "deleted_at": null,
        "deleted_by": null
    },
    "duration": 19,
    "deleted_at": null
}

Request      

PUT timetracking/registrations/{registration_id}/overtimes/{overtimeRegistration_id}

Headers

Authorization      

Example: Bearer evg4kf8hba6E6dDZ1acV5P3

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

registration_id   integer   

The ID of the registration. Example: 1

overtimeRegistration_id   integer   

The ID of the overtimeRegistration. Example: 3

Body Parameters

overtime_type   object  optional  
id   integer   

Example: 20

duration   integer   

Must be at least 0. Example: 80

Remove the specified resource from storage.

requires authentication

Remove the specified resource from storage.

Example request:
curl --request DELETE \
    "https://api.kvalitetskontroll.no/timetracking/registrations/1/overtimes/3" \
    --header "Authorization: Bearer 5Ehga86vZb1kD3e64acVfdP" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.kvalitetskontroll.no/timetracking/registrations/1/overtimes/3"
);

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

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/timetracking/registrations/1/overtimes/3';
$response = $client->delete(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer 5Ehga86vZb1kD3e64acVfdP',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/timetracking/registrations/1/overtimes/3'
headers = {
  'Authorization': 'Bearer 5Ehga86vZb1kD3e64acVfdP',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (200):


{
    "id": 1,
    "registration": {
        "id": 1,
        "user": {
            "id": 1,
            "self": "https://api.kvalitetskontroll.no/employees/1"
        },
        "project": {
            "id": 1,
            "self": "https://api.kvalitetskontroll.no/projects/1"
        },
        "temp_project_label": null,
        "registration_date": "2021-05-20T22:00:00.000000Z",
        "hour_type": {
            "id": 6,
            "self": "https://api.kvalitetskontroll.no/timetracking/hourtypes/6"
        },
        "time_from": "2021-05-21T06:00:00.000000Z",
        "time_to": "2021-05-21T14:00:00.000000Z",
        "break": 30,
        "duration": 450,
        "comment": "Earum odit rerum quo quos.",
        "department": {
            "id": 2,
            "self": "https://api.kvalitetskontroll.no/departments/2"
        },
        "user_efficiency_factor": "0.50000",
        "salary_export_id": null,
        "created_at": "2021-05-26T10:48:50.000000Z",
        "updated_at": "2021-05-27T13:17:55.000000Z",
        "updated_by_admin_at": null,
        "is_approved": false,
        "approved_by": null,
        "is_billed": false,
        "deleted_at": null,
        "billed_by": null,
        "billed_at": null,
        "overtimes": null,
        "additions": null,
        "machines": null,
        "hourbank": null
    },
    "type": {
        "id": 1,
        "self": "https://api.kvalitetskontroll.no/timetracking/overtimetypes/1"
    },
    "duration": 1,
    "deleted_at": "2021-05-27T13:17:55.000000Z"
}

Request      

DELETE timetracking/registrations/{registration_id}/overtimes/{overtimeRegistration_id}

Headers

Authorization      

Example: Bearer 5Ehga86vZb1kD3e64acVfdP

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

registration_id   integer   

The ID of the registration. Example: 1

overtimeRegistration_id   integer   

The ID of the overtimeRegistration. Example: 3

TimeTracking Overtime Types

GET /timetracking/overtimetypes

requires authentication

Example request:
curl --request GET \
    --get "https://api.kvalitetskontroll.no/timetracking/overtimetypes" \
    --header "Authorization: Bearer 85gE6ea3fVkdZvc4DhbP16a" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.kvalitetskontroll.no/timetracking/overtimetypes"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/timetracking/overtimetypes';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer 85gE6ea3fVkdZvc4DhbP16a',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/timetracking/overtimetypes'
headers = {
  'Authorization': 'Bearer 85gE6ea3fVkdZvc4DhbP16a',
  '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
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

GET timetracking/overtimetypes

Headers

Authorization      

Example: Bearer 85gE6ea3fVkdZvc4DhbP16a

Content-Type      

Example: application/json

Accept      

Example: application/json

GET /timetracking/overtimetypes/{type}

requires authentication

Example request:
curl --request GET \
    --get "https://api.kvalitetskontroll.no/timetracking/overtimetypes/3" \
    --header "Authorization: Bearer abDd8cvZ3kfP1V6h65geEa4" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.kvalitetskontroll.no/timetracking/overtimetypes/3"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/timetracking/overtimetypes/3';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer abDd8cvZ3kfP1V6h65geEa4',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/timetracking/overtimetypes/3'
headers = {
  'Authorization': 'Bearer abDd8cvZ3kfP1V6h65geEa4',
  '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
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

GET timetracking/overtimetypes/{type_id}

Headers

Authorization      

Example: Bearer abDd8cvZ3kfP1V6h65geEa4

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

type_id   integer   

The ID of the type. Example: 3

POST /timetracking/overtimetypes

requires authentication

Example request:
curl --request POST \
    "https://api.kvalitetskontroll.no/timetracking/overtimetypes" \
    --header "Authorization: Bearer bDg5Z8aV1k6cdeh6P3Ea4fv" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"title\": \"voluptatem\",
    \"product\": {
        \"id\": 1
    }
}"

const url = new URL(
    "https://api.kvalitetskontroll.no/timetracking/overtimetypes"
);

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

let body = {
    "title": "voluptatem",
    "product": {
        "id": 1
    }
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/timetracking/overtimetypes';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer bDg5Z8aV1k6cdeh6P3Ea4fv',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'title' => 'voluptatem',
            'product' => [
                'id' => 1,
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/timetracking/overtimetypes'
payload = {
    "title": "voluptatem",
    "product": {
        "id": 1
    }
}
headers = {
  'Authorization': 'Bearer bDg5Z8aV1k6cdeh6P3Ea4fv',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (200):


{
    "id": 10,
    "self": "https://api.kvalitetskontroll.no/timetracking/overtimetypes/10",
    "title": "doloribus",
    "overtime_factor": 0,
    "do_add_duration_to_bank": false,
    "external_id": null,
    "is_billable": false,
    "product": {
        "id": 4,
        "self": "https://api.kvalitetskontroll.no/products/4"
    },
    "created_at": "2021-05-27T13:22:30.000000Z",
    "created_by": {
        "id": 1,
        "self": "https://api.kvalitetskontroll.no/me/1"
    },
    "updated_at": "2021-05-27T13:22:30.000000Z",
    "updated_by": {
        "id": 1,
        "self": "https://api.kvalitetskontroll.no/me/1"
    },
    "deleted_at": null,
    "deleted_by": null
}

Request      

POST timetracking/overtimetypes

Headers

Authorization      

Example: Bearer bDg5Z8aV1k6cdeh6P3Ea4fv

Content-Type      

Example: application/json

Accept      

Example: application/json

Body Parameters

title   string   

Example: voluptatem

product   object  optional  
id   integer  optional  

Example: 1

PUT /timetracking/overtimetypes/{type}

requires authentication

Example request:
curl --request PUT \
    "https://api.kvalitetskontroll.no/timetracking/overtimetypes/3" \
    --header "Authorization: Bearer kcah6gbPfZV3EDa45d68ve1" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"title\": \"inventore\",
    \"product\": {
        \"id\": 1
    }
}"

const url = new URL(
    "https://api.kvalitetskontroll.no/timetracking/overtimetypes/3"
);

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

let body = {
    "title": "inventore",
    "product": {
        "id": 1
    }
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/timetracking/overtimetypes/3';
$response = $client->put(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer kcah6gbPfZV3EDa45d68ve1',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'title' => 'inventore',
            'product' => [
                'id' => 1,
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/timetracking/overtimetypes/3'
payload = {
    "title": "inventore",
    "product": {
        "id": 1
    }
}
headers = {
  'Authorization': 'Bearer kcah6gbPfZV3EDa45d68ve1',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (200):


{
    "id": 1,
    "self": "https://api.kvalitetskontroll.no/timetracking/overtimetypes/1",
    "title": "odit",
    "overtime_factor": 0,
    "do_add_duration_to_bank": false,
    "external_id": null,
    "is_billable": false,
    "product": {
        "id": 5,
        "self": "https://api.kvalitetskontroll.no/products/5"
    },
    "created_at": "2021-05-26T10:48:50.000000Z",
    "created_by": null,
    "updated_at": "2021-05-27T13:23:43.000000Z",
    "updated_by": {
        "id": 1,
        "self": "https://api.kvalitetskontroll.no/me/1"
    },
    "deleted_at": null,
    "deleted_by": null
}

Request      

PUT timetracking/overtimetypes/{type_id}

Headers

Authorization      

Example: Bearer kcah6gbPfZV3EDa45d68ve1

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

type_id   integer   

The ID of the type. Example: 3

Body Parameters

title   string   

Example: inventore

product   object  optional  
id   integer  optional  

Example: 1

DELETE /timetracking/overtimetypes/{type}

requires authentication

Example request:
curl --request DELETE \
    "https://api.kvalitetskontroll.no/timetracking/overtimetypes/3" \
    --header "Authorization: Bearer D1eaavc8E3kh4gfZ5bPVd66" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.kvalitetskontroll.no/timetracking/overtimetypes/3"
);

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

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/timetracking/overtimetypes/3';
$response = $client->delete(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer D1eaavc8E3kh4gfZ5bPVd66',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/timetracking/overtimetypes/3'
headers = {
  'Authorization': 'Bearer D1eaavc8E3kh4gfZ5bPVd66',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

DELETE timetracking/overtimetypes/{type_id}

Headers

Authorization      

Example: Bearer D1eaavc8E3kh4gfZ5bPVd66

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

type_id   integer   

The ID of the type. Example: 3

TimeTracking Registrations

GET /timetracking/registrations

requires authentication

Example request:
curl --request GET \
    --get "https://api.kvalitetskontroll.no/timetracking/registrations" \
    --header "Authorization: Bearer 3k6Pa5EV4816achfDgZdebv" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"from_date\": \"2024-03-13T14:59:31\",
    \"to_date\": \"2024-03-13T14:59:31\",
    \"updated_from\": \"2024-03-13T14:59:31\",
    \"updated_to\": \"2024-03-13T14:59:31\",
    \"is_approved\": true,
    \"include_deleted\": true,
    \"offset\": 7,
    \"limit\": 2
}"

const url = new URL(
    "https://api.kvalitetskontroll.no/timetracking/registrations"
);

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

let body = {
    "from_date": "2024-03-13T14:59:31",
    "to_date": "2024-03-13T14:59:31",
    "updated_from": "2024-03-13T14:59:31",
    "updated_to": "2024-03-13T14:59:31",
    "is_approved": true,
    "include_deleted": true,
    "offset": 7,
    "limit": 2
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/timetracking/registrations';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer 3k6Pa5EV4816achfDgZdebv',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'from_date' => '2024-03-13T14:59:31',
            'to_date' => '2024-03-13T14:59:31',
            'updated_from' => '2024-03-13T14:59:31',
            'updated_to' => '2024-03-13T14:59:31',
            'is_approved' => true,
            'include_deleted' => true,
            'offset' => 7,
            'limit' => 2,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/timetracking/registrations'
payload = {
    "from_date": "2024-03-13T14:59:31",
    "to_date": "2024-03-13T14:59:31",
    "updated_from": "2024-03-13T14:59:31",
    "updated_to": "2024-03-13T14:59:31",
    "is_approved": true,
    "include_deleted": true,
    "offset": 7,
    "limit": 2
}
headers = {
  'Authorization': 'Bearer 3k6Pa5EV4816achfDgZdebv',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

GET timetracking/registrations

Headers

Authorization      

Example: Bearer 3k6Pa5EV4816achfDgZdebv

Content-Type      

Example: application/json

Accept      

Example: application/json

Body Parameters

user_ids   object  optional  
from_date   string  optional  

This field is required when updated_from is not present. Must be a valid date. Example: 2024-03-13T14:59:31

to_date   string  optional  

This field is required when updated_to is not present. Must be a valid date. Example: 2024-03-13T14:59:31

updated_from   string  optional  

This field is required when from_date is not present. Must be a valid date. Example: 2024-03-13T14:59:31

updated_to   string  optional  

This field is required when to_date is not present. Must be a valid date. Example: 2024-03-13T14:59:31

is_approved   boolean  optional  

Example: true

include_deleted   boolean  optional  

Example: true

project_ids   object  optional  
offset   integer  optional  

Example: 7

limit   integer  optional  

Example: 2

Display the specified resource.

requires authentication

Display the specified resource.

Example request:
curl --request GET \
    --get "https://api.kvalitetskontroll.no/timetracking/registrations/1" \
    --header "Authorization: Bearer PDf53adaZV8bc14Ehv6gk6e" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.kvalitetskontroll.no/timetracking/registrations/1"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/timetracking/registrations/1';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer PDf53adaZV8bc14Ehv6gk6e',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/timetracking/registrations/1'
headers = {
  'Authorization': 'Bearer PDf53adaZV8bc14Ehv6gk6e',
  '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
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

GET timetracking/registrations/{registration_id}

Headers

Authorization      

Example: Bearer PDf53adaZV8bc14Ehv6gk6e

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

registration_id   integer   

The ID of the registration. Example: 1

Store a newly created resource in storage.

requires authentication

Store a newly created resource in storage.

Example request:
curl --request POST \
    "https://api.kvalitetskontroll.no/timetracking/registrations" \
    --header "Authorization: Bearer Phdfvag6ea18VZ4c5b3DkE6" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"user\": {
        \"id\": 2
    },
    \"project\": {
        \"id\": 1
    },
    \"temp_project_label\": \"ab\",
    \"registration_date\": \"2024-03-13T14:59:34\",
    \"hour_type\": {
        \"id\": 1
    },
    \"time_from\": \"2021-01-01 09:00:00\",
    \"time_to\": \"2021-01-01 13:37:00\",
    \"break\": 3,
    \"comment\": \"ratione\",
    \"department\": {
        \"id\": 1
    }
}"

const url = new URL(
    "https://api.kvalitetskontroll.no/timetracking/registrations"
);

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

let body = {
    "user": {
        "id": 2
    },
    "project": {
        "id": 1
    },
    "temp_project_label": "ab",
    "registration_date": "2024-03-13T14:59:34",
    "hour_type": {
        "id": 1
    },
    "time_from": "2021-01-01 09:00:00",
    "time_to": "2021-01-01 13:37:00",
    "break": 3,
    "comment": "ratione",
    "department": {
        "id": 1
    }
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/timetracking/registrations';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer Phdfvag6ea18VZ4c5b3DkE6',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'user' => [
                'id' => 2,
            ],
            'project' => [
                'id' => 1,
            ],
            'temp_project_label' => 'ab',
            'registration_date' => '2024-03-13T14:59:34',
            'hour_type' => [
                'id' => 1,
            ],
            'time_from' => '2021-01-01 09:00:00',
            'time_to' => '2021-01-01 13:37:00',
            'break' => 3,
            'comment' => 'ratione',
            'department' => [
                'id' => 1,
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/timetracking/registrations'
payload = {
    "user": {
        "id": 2
    },
    "project": {
        "id": 1
    },
    "temp_project_label": "ab",
    "registration_date": "2024-03-13T14:59:34",
    "hour_type": {
        "id": 1
    },
    "time_from": "2021-01-01 09:00:00",
    "time_to": "2021-01-01 13:37:00",
    "break": 3,
    "comment": "ratione",
    "department": {
        "id": 1
    }
}
headers = {
  'Authorization': 'Bearer Phdfvag6ea18VZ4c5b3DkE6',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

POST timetracking/registrations

Headers

Authorization      

Example: Bearer Phdfvag6ea18VZ4c5b3DkE6

Content-Type      

Example: application/json

Accept      

Example: application/json

Body Parameters

user   object  optional  
id   integer  optional  

Example: 2

project   object  optional  
id   integer  optional  

Example: 1

temp_project_label   string  optional  

Example: ab

registration_date   string   

Must be a valid date. Example: 2024-03-13T14:59:34

hour_type   object  optional  
id   integer  optional  

Example: 1

time_from   date  optional  

Example: 2021-01-01 09:00:00

time_to   date  optional  

Example: 2021-01-01 13:37:00

break   integer   

Example: 3

comment   string  optional  

Example: ratione

department   object  optional  
id   integer  optional  

Example: 1

Update the specified resource in storage.

requires authentication

Update the specified resource in storage.

Example request:
curl --request PUT \
    "https://api.kvalitetskontroll.no/timetracking/registrations/1" \
    --header "Authorization: Bearer agfv41hDVk6Pa8ce63bZE5d" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"user\": {
        \"id\": 2
    },
    \"project\": {
        \"id\": 1
    },
    \"temp_project_label\": \"voluptas\",
    \"registration_date\": \"2024-03-13T14:59:34\",
    \"hour_type\": {
        \"id\": 1
    },
    \"time_from\": \"2021-01-01 09:00:00\",
    \"time_to\": \"2021-01-01 13:37:00\",
    \"break\": 16,
    \"comment\": \"est\",
    \"department\": {
        \"id\": 1
    }
}"

const url = new URL(
    "https://api.kvalitetskontroll.no/timetracking/registrations/1"
);

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

let body = {
    "user": {
        "id": 2
    },
    "project": {
        "id": 1
    },
    "temp_project_label": "voluptas",
    "registration_date": "2024-03-13T14:59:34",
    "hour_type": {
        "id": 1
    },
    "time_from": "2021-01-01 09:00:00",
    "time_to": "2021-01-01 13:37:00",
    "break": 16,
    "comment": "est",
    "department": {
        "id": 1
    }
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/timetracking/registrations/1';
$response = $client->put(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer agfv41hDVk6Pa8ce63bZE5d',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'user' => [
                'id' => 2,
            ],
            'project' => [
                'id' => 1,
            ],
            'temp_project_label' => 'voluptas',
            'registration_date' => '2024-03-13T14:59:34',
            'hour_type' => [
                'id' => 1,
            ],
            'time_from' => '2021-01-01 09:00:00',
            'time_to' => '2021-01-01 13:37:00',
            'break' => 16,
            'comment' => 'est',
            'department' => [
                'id' => 1,
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/timetracking/registrations/1'
payload = {
    "user": {
        "id": 2
    },
    "project": {
        "id": 1
    },
    "temp_project_label": "voluptas",
    "registration_date": "2024-03-13T14:59:34",
    "hour_type": {
        "id": 1
    },
    "time_from": "2021-01-01 09:00:00",
    "time_to": "2021-01-01 13:37:00",
    "break": 16,
    "comment": "est",
    "department": {
        "id": 1
    }
}
headers = {
  'Authorization': 'Bearer agfv41hDVk6Pa8ce63bZE5d',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

PUT timetracking/registrations/{registration_id}

Headers

Authorization      

Example: Bearer agfv41hDVk6Pa8ce63bZE5d

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

registration_id   integer   

The ID of the registration. Example: 1

Body Parameters

user   object  optional  
id   integer  optional  

Example: 2

project   object  optional  
id   integer  optional  

Example: 1

temp_project_label   string  optional  

Example: voluptas

registration_date   string   

Must be a valid date. Example: 2024-03-13T14:59:34

hour_type   object  optional  
id   integer  optional  

Example: 1

time_from   date  optional  

Example: 2021-01-01 09:00:00

time_to   date  optional  

Example: 2021-01-01 13:37:00

break   integer   

Example: 16

comment   string  optional  

Example: est

department   object  optional  
id   integer  optional  

Example: 1

Remove the specified resource from storage.

requires authentication

Remove the specified resource from storage.

Example request:
curl --request DELETE \
    "https://api.kvalitetskontroll.no/timetracking/registrations/1" \
    --header "Authorization: Bearer Z6d43EekcDhV5b8fg6Pva1a" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.kvalitetskontroll.no/timetracking/registrations/1"
);

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

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/timetracking/registrations/1';
$response = $client->delete(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer Z6d43EekcDhV5b8fg6Pva1a',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/timetracking/registrations/1'
headers = {
  'Authorization': 'Bearer Z6d43EekcDhV5b8fg6Pva1a',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

DELETE timetracking/registrations/{registration_id}

Headers

Authorization      

Example: Bearer Z6d43EekcDhV5b8fg6Pva1a

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

registration_id   integer   

The ID of the registration. Example: 1

Approves a given time tracking registration

requires authentication

Approves a given time tracking registration

Example request:
curl --request POST \
    "https://api.kvalitetskontroll.no/timetracking/approve" \
    --header "Authorization: Bearer av4hDge3P61cZE8kda6bfV5" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"id\": 1
}"

const url = new URL(
    "https://api.kvalitetskontroll.no/timetracking/approve"
);

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

let body = {
    "id": 1
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/timetracking/approve';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer av4hDge3P61cZE8kda6bfV5',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'id' => 1,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/timetracking/approve'
payload = {
    "id": 1
}
headers = {
  'Authorization': 'Bearer av4hDge3P61cZE8kda6bfV5',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

POST timetracking/approve

Headers

Authorization      

Example: Bearer av4hDge3P61cZE8kda6bfV5

Content-Type      

Example: application/json

Accept      

Example: application/json

Body Parameters

id   integer  optional  

Example: 1

Rejects a given time tracking registration approval

requires authentication

Rejects a given time tracking registration approval

Example request:
curl --request POST \
    "https://api.kvalitetskontroll.no/timetracking/reject" \
    --header "Authorization: Bearer 6DP4efZd635bcgaahvV1kE8" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"id\": 2
}"

const url = new URL(
    "https://api.kvalitetskontroll.no/timetracking/reject"
);

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

let body = {
    "id": 2
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/timetracking/reject';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer 6DP4efZd635bcgaahvV1kE8',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'id' => 2,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/timetracking/reject'
payload = {
    "id": 2
}
headers = {
  'Authorization': 'Bearer 6DP4efZd635bcgaahvV1kE8',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (200):


{
    "rejected": [
        {
            "id": 2,
            "user_id": 1,
            "company_id": 1,
            "project_id": 1,
            "temp_project_label": null,
            "registration_date": "2021-04-05T22:00:00.000000Z",
            "hour_type_id": 4,
            "time_from": "2021-04-06T06:00:00.000000Z",
            "time_to": "2021-04-06T14:00:00.000000Z",
            "break": 30,
            "duration": 450,
            "comment": "Natus autem quas non nostrum voluptatem exercitationem.",
            "created_at": "2021-05-27T12:02:15.000000Z",
            "updated_at": "2021-05-27T12:45:23.000000Z",
            "updated_by_admin_at": null,
            "is_approved": false,
            "approved_by_id": null,
            "approved_at": null,
            "department_id": 2,
            "is_billed": false,
            "billed_by_id": null,
            "billed_at": null,
            "user_efficiency_factor": "0.70000",
            "salary_export_id": null,
            "deleted_at": null,
            "created_by_id": 1,
            "updated_by_id": 1
        }
    ],
    "errors": [],
    "integration_messages": []
}

Request      

POST timetracking/reject

Headers

Authorization      

Example: Bearer 6DP4efZd635bcgaahvV1kE8

Content-Type      

Example: application/json

Accept      

Example: application/json

Body Parameters

id   integer  optional  

Example: 2

VAT Types

GET /vattypes

requires authentication

Example request:
curl --request GET \
    --get "https://api.kvalitetskontroll.no/vattypes" \
    --header "Authorization: Bearer a6EgVkcvDaf361de8Ph4Z5b" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.kvalitetskontroll.no/vattypes"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/vattypes';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer a6EgVkcvDaf361de8Ph4Z5b',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/vattypes'
headers = {
  'Authorization': 'Bearer a6EgVkcvDaf361de8Ph4Z5b',
  '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
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

GET vattypes

Headers

Authorization      

Example: Bearer a6EgVkcvDaf361de8Ph4Z5b

Content-Type      

Example: application/json

Accept      

Example: application/json

GET /vattypes/{vatType}

requires authentication

Example request:
curl --request GET \
    --get "https://api.kvalitetskontroll.no/vattypes/1" \
    --header "Authorization: Bearer 34E6DZeb18avhPkgf6Vacd5" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.kvalitetskontroll.no/vattypes/1"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.kvalitetskontroll.no/vattypes/1';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer 34E6DZeb18avhPkgf6Vacd5',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.kvalitetskontroll.no/vattypes/1'
headers = {
  'Authorization': 'Bearer 34E6DZeb18avhPkgf6Vacd5',
  '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
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

GET vattypes/{vatType_id}

Headers

Authorization      

Example: Bearer 34E6DZeb18avhPkgf6Vacd5

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

vatType_id   integer   

The ID of the vatType. Example: 1