MENU navbar-image

Introduction

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

Authenticating requests

To authenticate requests, include a x-apikey header with the value "{YOUR_APIKEY}".

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

You can retrieve your apikey by visiting your user settings and creating one.

Admin

GET admin/super

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/admin/super',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/admin/super"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/admin/super" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET admin/super

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

GET admin/trics

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/admin/trics',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/admin/trics"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/admin/trics" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET admin/trics

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

POST admin/trics

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/admin/trics',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'namespace' => 'qui',
            'secret' => 'assumenda',
            'version' => 5,
            'name' => 'culpa',
            'type' => 'aliquid',
            'icon' => 'ut',
            'short_description' => 'in',
            'features' => 'aut',
            'description' => 'Molestiae sint tenetur iste consequuntur.',
            'categories' => 'perferendis',
            'images' => 'et',
            'video' => 'voluptates',
            'tags' => 'mollitia',
            'price' => 'qui',
            'status' => 5,
            'activatable' => 11,
            'post-activation' => 'sit',
            'public' => 15,
            'popularity' => 15,
            'featured' => 11,
            'developerid' => 'consequatur',
            'requirements' => 'ipsa',
            'integrations' => 'in',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/admin/trics"
);

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

let body = {
    "namespace": "qui",
    "secret": "assumenda",
    "version": 5,
    "name": "culpa",
    "type": "aliquid",
    "icon": "ut",
    "short_description": "in",
    "features": "aut",
    "description": "Molestiae sint tenetur iste consequuntur.",
    "categories": "perferendis",
    "images": "et",
    "video": "voluptates",
    "tags": "mollitia",
    "price": "qui",
    "status": 5,
    "activatable": 11,
    "post-activation": "sit",
    "public": 15,
    "popularity": 15,
    "featured": 11,
    "developerid": "consequatur",
    "requirements": "ipsa",
    "integrations": "in"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request POST \
    "http://localhost/admin/trics" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"namespace\": \"qui\",
    \"secret\": \"assumenda\",
    \"version\": 5,
    \"name\": \"culpa\",
    \"type\": \"aliquid\",
    \"icon\": \"ut\",
    \"short_description\": \"in\",
    \"features\": \"aut\",
    \"description\": \"Molestiae sint tenetur iste consequuntur.\",
    \"categories\": \"perferendis\",
    \"images\": \"et\",
    \"video\": \"voluptates\",
    \"tags\": \"mollitia\",
    \"price\": \"qui\",
    \"status\": 5,
    \"activatable\": 11,
    \"post-activation\": \"sit\",
    \"public\": 15,
    \"popularity\": 15,
    \"featured\": 11,
    \"developerid\": \"consequatur\",
    \"requirements\": \"ipsa\",
    \"integrations\": \"in\"
}"

Request      

POST admin/trics

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Body Parameters

namespace   string   

Example: qui

secret   string   

Example: assumenda

version   integer  optional  

Example: 5

name   string   

Example: culpa

type   string   

Example: aliquid

icon   string   

Example: ut

short_description   string   

Example: in

features   string   

Example: aut

description   string   

Example: Molestiae sint tenetur iste consequuntur.

categories   string   

Example: perferendis

images   string   

Example: et

video   string   

Example: voluptates

tags   string   

Example: mollitia

price   string   

Example: qui

status   integer   

Example: 5

activatable   integer   

Example: 11

post-activation   string   

Example: sit

public   integer   

Example: 15

popularity   integer   

Example: 15

featured   integer   

Example: 11

developerid   string   

Example: consequatur

requirements   string   

Example: ipsa

integrations   string   

Example: in

GET admin/trics/{tricid}

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/admin/trics/iure',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/admin/trics/iure"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/admin/trics/iure" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET admin/trics/{tricid}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

tricid   string   

Example: iure

PUT admin/trics/{tricid}

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->put(
    'http://localhost/admin/trics/sunt',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'dolores',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/admin/trics/sunt"
);

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

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

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request PUT \
    "http://localhost/admin/trics/sunt" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"dolores\"
}"

Request      

PUT admin/trics/{tricid}

PATCH admin/trics/{tricid}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

tricid   string   

Example: sunt

Body Parameters

name   string   

Example: dolores

DELETE admin/trics/{tricid}

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://localhost/admin/trics/ipsa',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/admin/trics/ipsa"
);

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

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
curl --request DELETE \
    "http://localhost/admin/trics/ipsa" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

DELETE admin/trics/{tricid}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

tricid   string   

Example: ipsa

GET admin/trics/{tric_tricid}/assets

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/admin/trics/ut/assets',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/admin/trics/ut/assets"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/admin/trics/ut/assets" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET admin/trics/{tric_tricid}/assets

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

tric_tricid   string   

Example: ut

POST admin/trics/{tric_tricid}/assets

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/admin/trics/quasi/assets',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'type' => 7,
            'asset' => 'illo',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/admin/trics/quasi/assets"
);

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

let body = {
    "type": 7,
    "asset": "illo"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request POST \
    "http://localhost/admin/trics/quasi/assets" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"type\": 7,
    \"asset\": \"illo\"
}"

Request      

POST admin/trics/{tric_tricid}/assets

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

tric_tricid   string   

Example: quasi

Body Parameters

type   integer   

Example: 7

asset   string   

Example: illo

GET admin/trics/{tric_tricid}/assets/{assetid}

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/admin/trics/exercitationem/assets/18',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/admin/trics/exercitationem/assets/18"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/admin/trics/exercitationem/assets/18" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET admin/trics/{tric_tricid}/assets/{assetid}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

tric_tricid   string   

Example: exercitationem

assetid   integer   

Example: 18

PUT admin/trics/{tric_tricid}/assets/{assetid}

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->put(
    'http://localhost/admin/trics/dolores/assets/11',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'status' => 8,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/admin/trics/dolores/assets/11"
);

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

let body = {
    "status": 8
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request PUT \
    "http://localhost/admin/trics/dolores/assets/11" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"status\": 8
}"

Request      

PUT admin/trics/{tric_tricid}/assets/{assetid}

PATCH admin/trics/{tric_tricid}/assets/{assetid}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

tric_tricid   string   

Example: dolores

assetid   integer   

Example: 11

Body Parameters

status   integer  optional  

Example: 8

asset   string  optional  

DELETE admin/trics/{tric_tricid}/assets/{assetid}

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://localhost/admin/trics/est/assets/20',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/admin/trics/est/assets/20"
);

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

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
curl --request DELETE \
    "http://localhost/admin/trics/est/assets/20" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

DELETE admin/trics/{tric_tricid}/assets/{assetid}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

tric_tricid   string   

Example: est

assetid   integer   

Example: 20

GET admin/templates/positions

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/admin/templates/positions',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'limit' => '10',
            'page' => '1',
            'order' => 'desc',
            'orderBy' => 'datetime',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/admin/templates/positions"
);

const params = {
    "limit": "10",
    "page": "1",
    "order": "desc",
    "orderBy": "datetime",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/admin/templates/positions?limit=10&page=1&order=desc&orderBy=datetime" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET admin/templates/positions

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

limit   integer  optional  

Default: 10. Must not be greater than 100. Example: 10

page   integer  optional  

Must be at least 1. Example: 1

order   string  optional  

Default: desc. Must be one of asc or desc. Example: desc

orderBy   string  optional  

Default: datetime. Example: datetime

POST admin/templates/positions

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/admin/templates/positions',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'tzmfgbqbggxufhabnyqua',
            'type' => 'vvhkxvtjqgzyfmvacaahwszrc',
            'settings' => [],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/admin/templates/positions"
);

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

let body = {
    "name": "tzmfgbqbggxufhabnyqua",
    "type": "vvhkxvtjqgzyfmvacaahwszrc",
    "settings": []
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request POST \
    "http://localhost/admin/templates/positions" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"tzmfgbqbggxufhabnyqua\",
    \"type\": \"vvhkxvtjqgzyfmvacaahwszrc\",
    \"settings\": []
}"

Request      

POST admin/templates/positions

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Body Parameters

name   string   

Must not be greater than 50 characters. Example: tzmfgbqbggxufhabnyqua

type   string   

Must not be greater than 50 characters. Example: vvhkxvtjqgzyfmvacaahwszrc

tags   object  optional  
settings   object   

GET admin/templates/positions/{positionId}

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/admin/templates/positions/2',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/admin/templates/positions/2"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/admin/templates/positions/2" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET admin/templates/positions/{positionId}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

positionId   integer   

Example: 2

PUT admin/templates/positions/{positionId}

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->put(
    'http://localhost/admin/templates/positions/8',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'paixfpetmvnuciawav',
            'type' => 'debxybujeobj',
            'settings' => [],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/admin/templates/positions/8"
);

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

let body = {
    "name": "paixfpetmvnuciawav",
    "type": "debxybujeobj",
    "settings": []
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request PUT \
    "http://localhost/admin/templates/positions/8" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"paixfpetmvnuciawav\",
    \"type\": \"debxybujeobj\",
    \"settings\": []
}"

Request      

PUT admin/templates/positions/{positionId}

PATCH admin/templates/positions/{positionId}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

positionId   integer   

Example: 8

Body Parameters

name   string   

Must not be greater than 50 characters. Example: paixfpetmvnuciawav

type   string   

Must not be greater than 50 characters. Example: debxybujeobj

tags   object  optional  
settings   object   

DELETE admin/templates/positions/{positionId}

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://localhost/admin/templates/positions/15',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/admin/templates/positions/15"
);

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

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
curl --request DELETE \
    "http://localhost/admin/templates/positions/15" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

DELETE admin/templates/positions/{positionId}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

positionId   integer   

Example: 15

GET admin/templates

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/admin/templates',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'limit' => '10',
            'page' => '1',
            'order' => 'desc',
            'orderBy' => 'datetime',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/admin/templates"
);

const params = {
    "limit": "10",
    "page": "1",
    "order": "desc",
    "orderBy": "datetime",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/admin/templates?limit=10&page=1&order=desc&orderBy=datetime" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET admin/templates

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

limit   integer  optional  

Default: 10. Must not be greater than 100. Example: 10

page   integer  optional  

Must be at least 1. Example: 1

order   string  optional  

Default: desc. Must be one of asc or desc. Example: desc

orderBy   string  optional  

Default: datetime. Example: datetime

POST admin/templates

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/admin/templates',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'zfjbqwikho',
            'channel' => 'dolor',
            'settings' => [],
            'is_active' => true,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/admin/templates"
);

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

let body = {
    "name": "zfjbqwikho",
    "channel": "dolor",
    "settings": [],
    "is_active": true
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request POST \
    "http://localhost/admin/templates" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"zfjbqwikho\",
    \"channel\": \"dolor\",
    \"settings\": [],
    \"is_active\": true
}"

Request      

POST admin/templates

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Body Parameters

name   string   

Must not be greater than 255 characters. Example: zfjbqwikho

channel   string   

Example: dolor

tags   object  optional  
settings   object   
is_active   boolean  optional  

Example: true

GET admin/templates/{templateId}

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/admin/templates/15',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/admin/templates/15"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/admin/templates/15" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET admin/templates/{templateId}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

templateId   integer   

Example: 15

PUT admin/templates/{templateId}

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->put(
    'http://localhost/admin/templates/7',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'efnfmozfar',
            'channel' => 'fuga',
            'settings' => [],
            'is_active' => false,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/admin/templates/7"
);

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

let body = {
    "name": "efnfmozfar",
    "channel": "fuga",
    "settings": [],
    "is_active": false
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request PUT \
    "http://localhost/admin/templates/7" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"efnfmozfar\",
    \"channel\": \"fuga\",
    \"settings\": [],
    \"is_active\": false
}"

Request      

PUT admin/templates/{templateId}

PATCH admin/templates/{templateId}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

templateId   integer   

Example: 7

Body Parameters

name   string   

Must not be greater than 255 characters. Example: efnfmozfar

channel   string   

Example: fuga

tags   object  optional  
settings   object   
is_active   boolean  optional  

Example: false

DELETE admin/templates/{templateId}

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://localhost/admin/templates/5',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/admin/templates/5"
);

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

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
curl --request DELETE \
    "http://localhost/admin/templates/5" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

DELETE admin/templates/{templateId}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

templateId   integer   

Example: 5

Buckets

Get bucket fields.

requires authentication

Returns a list of fields. If the new format is requested it will also return the 40th most common values for these fields. Available buckets are: audience, catalog, sales, interactions and behavior.

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/project/12/bucket/catalog.',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'new' => false,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/12/bucket/catalog."
);

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

let body = {
    "new": false
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/project/12/bucket/catalog." \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"new\": false
}"

Request      

GET project/{project_idsite}/bucket/{bucket}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 12

bucket   string  optional  

Example: catalog.

Query Parameters

new   boolean  optional  

Return fields in old or new format. Defaults to 'false'.

Body Parameters

new   boolean  optional  

Example: false

Campaigns

POST project/{project_idsite}/campaigns/{campaign_campaignid}/copy

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/project/1/campaigns/ducimus/copy',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'projectId' => 'vel',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/1/campaigns/ducimus/copy"
);

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

let body = {
    "projectId": "vel"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request POST \
    "http://localhost/project/1/campaigns/ducimus/copy" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"projectId\": \"vel\"
}"

Request      

POST project/{project_idsite}/campaigns/{campaign_campaignid}/copy

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 1

campaign_campaignid   string   

Example: ducimus

Body Parameters

projectId   string   

Example: vel

GET project/{project_idsite}/campaign

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/project/10/campaign',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'limit' => '10',
            'page' => '1',
            'order' => 'desc',
            'orderBy' => 'datetime',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/10/campaign"
);

const params = {
    "limit": "10",
    "page": "1",
    "order": "desc",
    "orderBy": "datetime",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/project/10/campaign?limit=10&page=1&order=desc&orderBy=datetime" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET project/{project_idsite}/campaign

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 10

Query Parameters

limit   integer  optional  

Default: 10. Must not be greater than 100. Example: 10

page   integer  optional  

Must be at least 1. Example: 1

order   string  optional  

Default: desc. Must be one of asc or desc. Example: desc

orderBy   string  optional  

Default: datetime. Example: datetime

POST project/{project_idsite}/campaign

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/project/2/campaign',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'hic',
            'status' => 'et',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/2/campaign"
);

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

let body = {
    "name": "hic",
    "status": "et"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request POST \
    "http://localhost/project/2/campaign" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"hic\",
    \"status\": \"et\"
}"

Request      

POST project/{project_idsite}/campaign

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 2

Body Parameters

name   string   

Example: hic

status   string   

Example: et

targeting   object  optional  
settings   object  optional  

GET project/{project_idsite}/campaign/{campaignid}

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/project/2/campaign/qui',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'limit' => '10',
            'page' => '1',
            'order' => 'desc',
            'orderBy' => 'datetime',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/2/campaign/qui"
);

const params = {
    "limit": "10",
    "page": "1",
    "order": "desc",
    "orderBy": "datetime",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/project/2/campaign/qui?limit=10&page=1&order=desc&orderBy=datetime" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET project/{project_idsite}/campaign/{campaignid}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 2

campaignid   string   

Example: qui

Query Parameters

limit   integer  optional  

Default: 10. Must not be greater than 100. Example: 10

page   integer  optional  

Must be at least 1. Example: 1

order   string  optional  

Default: desc. Must be one of asc or desc. Example: desc

orderBy   string  optional  

Default: datetime. Example: datetime

PUT project/{project_idsite}/campaign/{campaignid}

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->put(
    'http://localhost/project/3/campaign/assumenda',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'quos',
            'description' => 'Facere rem velit nesciunt dicta hic aut nesciunt.',
            'status' => 'quisquam',
            'start' => 'quas',
            'end' => 'in',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/3/campaign/assumenda"
);

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

let body = {
    "name": "quos",
    "description": "Facere rem velit nesciunt dicta hic aut nesciunt.",
    "status": "quisquam",
    "start": "quas",
    "end": "in"
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request PUT \
    "http://localhost/project/3/campaign/assumenda" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"quos\",
    \"description\": \"Facere rem velit nesciunt dicta hic aut nesciunt.\",
    \"status\": \"quisquam\",
    \"start\": \"quas\",
    \"end\": \"in\"
}"

Request      

PUT project/{project_idsite}/campaign/{campaignid}

PATCH project/{project_idsite}/campaign/{campaignid}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 3

campaignid   string   

Example: assumenda

Body Parameters

name   string  optional  

Example: quos

description   string  optional  

Example: Facere rem velit nesciunt dicta hic aut nesciunt.

status   string  optional  

Example: quisquam

start   string  optional  

Example: quas

end   string  optional  

Example: in

targeting   object  optional  
settings   object  optional  
goals   object  optional  
segments   object  optional  

Flush hybrid campaign.

requires authentication

Removes all profiles from a hybrid flow and resets the stats.

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/project/17/campaign/20170303122300200/flush',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/17/campaign/20170303122300200/flush"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/project/17/campaign/20170303122300200/flush" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET project/{project_idsite}/campaign/{campaign}/flush

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 17

campaign   string  optional  

Example: 20170303122300200

Categories

GET project/{project_idsite}/categories

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/project/3/categories',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'limit' => '25',
            'page' => '1',
            'order' => 'updated',
            'orderBy' => 'asc',
            'search' => 'nihil',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/3/categories"
);

const params = {
    "limit": "25",
    "page": "1",
    "order": "updated",
    "orderBy": "asc",
    "search": "nihil",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/project/3/categories?limit=25&page=1&order=updated&orderBy=asc&search=nihil" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET project/{project_idsite}/categories

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 3

Query Parameters

limit   integer  optional  

Must not be greater than 100. Example: 25

page   integer  optional  

Example: 1

order   string  optional  

Example: updated

orderBy   string  optional  

Must be one of desc or asc. Example: asc

search   string  optional  

Example: nihil

GET project/{project_idsite}/categories/{id}

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/project/11/categories/hic',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/11/categories/hic"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/project/11/categories/hic" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET project/{project_idsite}/categories/{id}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 11

id   string   

The ID of the category. Example: hic

DELETE project/{project_idsite}/categories/{source}

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://localhost/project/16/categories/mollitia',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/16/categories/mollitia"
);

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

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
curl --request DELETE \
    "http://localhost/project/16/categories/mollitia" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

DELETE project/{project_idsite}/categories/{source}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 16

source   string   

Example: mollitia

Channels

GET channels

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/channels',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/channels"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/channels" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET channels

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

GET channels/{id}

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/channels/qui',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/channels/qui"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/channels/qui" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET channels/{id}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

id   string   

The ID of the channel. Example: qui

PUT

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->put(
    'http://localhost/',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/"
);

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

fetch(url, {
    method: "PUT",
    headers,
}).then(response => response.json());
curl --request PUT \
    "http://localhost/" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

PUT

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

GET channels/{channel_channel}/projects

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/channels/qui/projects',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/channels/qui/projects"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/channels/qui/projects" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET channels/{channel_channel}/projects

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

channel_channel   string   

Example: qui

GET channels/{channel_channel}/article/{articleId}/{lang?}

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/channels/esse/article/et/pariatur',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/channels/esse/article/et/pariatur"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/channels/esse/article/et/pariatur" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET channels/{channel_channel}/article/{articleId}/{lang?}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

channel_channel   string   

Example: esse

articleId   string   

Example: et

lang   string  optional  

Example: pariatur

GET channels/{channel_id}/images

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/channels/quo/images',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/channels/quo/images"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/channels/quo/images" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET channels/{channel_id}/images

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

channel_id   string   

The ID of the channel. Example: quo

POST channels/{channel}/images

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/channels/veniam/images',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'multipart/form-data',
            'Accept' => 'application/json',
        ],
        'multipart' => [
            [
                'name' => 'image',
                'contents' => fopen('/tmp/phphnkDpG', 'r')
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/channels/veniam/images"
);

const headers = {
    "x-apikey": "{YOUR_APIKEY}",
    "Content-Type": "multipart/form-data",
    "Accept": "application/json",
};

const body = new FormData();
body.append('image', document.querySelector('input[name="image"]').files[0]);

fetch(url, {
    method: "POST",
    headers,
    body,
}).then(response => response.json());
curl --request POST \
    "http://localhost/channels/veniam/images" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: multipart/form-data" \
    --header "Accept: application/json" \
    --form "image=@/tmp/phphnkDpG"

Request      

POST channels/{channel}/images

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: multipart/form-data

Accept      

Example: application/json

URL Parameters

channel   string   

The channel. Example: veniam

Body Parameters

image   file   

Must be a file. Example: /tmp/phphnkDpG

GET channels/{channel_id}/images/{file}

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/channels/optio/images/eaque',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/channels/optio/images/eaque"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/channels/optio/images/eaque" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET channels/{channel_id}/images/{file}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

channel_id   string   

The ID of the channel. Example: optio

file   string   

Example: eaque

DELETE channels/{channel_id}/images/{file}

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://localhost/channels/non/images/iste',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/channels/non/images/iste"
);

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

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
curl --request DELETE \
    "http://localhost/channels/non/images/iste" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

DELETE channels/{channel_id}/images/{file}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

channel_id   string   

The ID of the channel. Example: non

file   string   

Example: iste

Content

GET project/{project_idsite}/content/filter

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/project/7/content/filter',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/7/content/filter"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/project/7/content/filter" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET project/{project_idsite}/content/filter

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 7

GET project/{project_idsite}/content/search

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/project/8/content/search',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/8/content/search"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/project/8/content/search" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET project/{project_idsite}/content/search

POST project/{project_idsite}/content/search

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 8

GET project/{project_idsite}/content/{source}/{item}/stats

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/project/8/content/LtL=//=/stats)/stats',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'limit' => 25,
            'page' => 12,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/8/content/LtL=//=/stats)/stats"
);

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

let body = {
    "limit": 25,
    "page": 12
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/project/8/content/LtL=//=/stats)/stats" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"limit\": 25,
    \"page\": 12
}"

Request      

GET project/{project_idsite}/content/{source}/{item}/stats

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 8

source   string   

Example: LtL=/

item   string   

Example: =/stats)

Body Parameters

limit   integer  optional  

Must not be greater than 100. Example: 25

page   integer  optional  

Must be at least 1. Example: 12

GET project/{project_idsite}/content/{source}/{item}

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/project/9/content/K,5?=//ipsum',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/9/content/K,5?=//ipsum"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/project/9/content/K,5?=//ipsum" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET project/{project_idsite}/content/{source}/{item}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 9

source   string   

Example: K,5?=/

item   string   

Example: ipsum

PUT project/{project_idsite}/content/{source}/{item}

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->put(
    'http://localhost/project/7/content/~=/)/velit',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'source' => 'alias',
            'itemid' => 'fuga',
            'itemtype' => 'sint',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/7/content/~=/)/velit"
);

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

let body = {
    "source": "alias",
    "itemid": "fuga",
    "itemtype": "sint"
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request PUT \
    "http://localhost/project/7/content/~=/)/velit" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"source\": \"alias\",
    \"itemid\": \"fuga\",
    \"itemtype\": \"sint\"
}"

Request      

PUT project/{project_idsite}/content/{source}/{item}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 7

source   string   

Example: ~=/)

item   string   

Example: velit

Body Parameters

source   string  optional  

Example: alias

itemid   string  optional  

Example: fuga

itemtype   string  optional  

Example: sint

item   object  optional  

POST project/{project_idsite}/content

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/project/7/content',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'source' => 'et',
            'itemid' => 'voluptas',
            'itemtype' => 'illo',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/7/content"
);

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

let body = {
    "source": "et",
    "itemid": "voluptas",
    "itemtype": "illo"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request POST \
    "http://localhost/project/7/content" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"source\": \"et\",
    \"itemid\": \"voluptas\",
    \"itemtype\": \"illo\"
}"

Request      

POST project/{project_idsite}/content

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 7

Body Parameters

source   string  optional  

Example: et

itemid   string  optional  

Example: voluptas

itemtype   string  optional  

Example: illo

item   object  optional  

DELETE project/{project_idsite}/content/{source}

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://localhost/project/20/content/amet',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/20/content/amet"
);

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

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
curl --request DELETE \
    "http://localhost/project/20/content/amet" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

DELETE project/{project_idsite}/content/{source}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 20

source   string   

Example: amet

Content collections

GET project/{project_idsite}/collections

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/project/5/collections',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/5/collections"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/project/5/collections" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET project/{project_idsite}/collections

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 5

POST project/{project_idsite}/collections

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/project/2/collections',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'ut',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/2/collections"
);

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

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

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request POST \
    "http://localhost/project/2/collections" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"ut\"
}"

Request      

POST project/{project_idsite}/collections

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 2

Body Parameters

name   string   

Example: ut

filter   object  optional  
query   object  optional  

GET project/{project_idsite}/collections/{collectionid}

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/project/13/collections/12',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/13/collections/12"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/project/13/collections/12" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET project/{project_idsite}/collections/{collectionid}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 13

collectionid   integer   

Example: 12

PUT project/{project_idsite}/collections/{collectionid}

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->put(
    'http://localhost/project/10/collections/11',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'voluptas',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/10/collections/11"
);

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

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

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request PUT \
    "http://localhost/project/10/collections/11" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"voluptas\"
}"

Request      

PUT project/{project_idsite}/collections/{collectionid}

PATCH project/{project_idsite}/collections/{collectionid}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 10

collectionid   integer   

Example: 11

Body Parameters

name   string  optional  

Example: voluptas

filter   object  optional  
query   object  optional  

DELETE project/{project_idsite}/collections/{collectionid}

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://localhost/project/16/collections/8',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/16/collections/8"
);

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

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
curl --request DELETE \
    "http://localhost/project/16/collections/8" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

DELETE project/{project_idsite}/collections/{collectionid}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 16

collectionid   integer   

Example: 8

Conversion

GET project/{project}/conversions

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/project/quidem/conversions',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'limit' => '10',
            'page' => '1',
            'order' => 'desc',
            'orderBy' => 'datetime',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/quidem/conversions"
);

const params = {
    "limit": "10",
    "page": "1",
    "order": "desc",
    "orderBy": "datetime",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/project/quidem/conversions?limit=10&page=1&order=desc&orderBy=datetime" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET project/{project}/conversions

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project   string   

The project. Example: quidem

Query Parameters

limit   integer  optional  

Default: 10. Must not be greater than 100. Example: 10

page   integer  optional  

Must be at least 1. Example: 1

order   string  optional  

Default: desc. Must be one of asc or desc. Example: desc

orderBy   string  optional  

Default: datetime. Example: datetime

POST project/{project_idsite}/conversions

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/project/1/conversions',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'ip' => '9.95.231.241',
            'id' => 'dolore',
            'source' => 'et',
            'phone' => 'cumque',
            'profileid' => 'recusandae',
            'conversionid' => 'adipisci',
            'conversion' => [
                'email' => 'williamson.caitlyn@example.org',
                'total' => 'excepturi',
                'items' => [
                    'voluptas',
                ],
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/1/conversions"
);

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

let body = {
    "ip": "9.95.231.241",
    "id": "dolore",
    "source": "et",
    "phone": "cumque",
    "profileid": "recusandae",
    "conversionid": "adipisci",
    "conversion": {
        "email": "williamson.caitlyn@example.org",
        "total": "excepturi",
        "items": [
            "voluptas"
        ]
    }
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request POST \
    "http://localhost/project/1/conversions" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"ip\": \"9.95.231.241\",
    \"id\": \"dolore\",
    \"source\": \"et\",
    \"phone\": \"cumque\",
    \"profileid\": \"recusandae\",
    \"conversionid\": \"adipisci\",
    \"conversion\": {
        \"email\": \"williamson.caitlyn@example.org\",
        \"total\": \"excepturi\",
        \"items\": [
            \"voluptas\"
        ]
    }
}"

Request      

POST project/{project_idsite}/conversions

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 1

Body Parameters

ip   string  optional  

Must be a valid IP address. Example: 9.95.231.241

id   string  optional  

Example: dolore

source   string  optional  

Example: et

phone   string  optional  

Example: cumque

profileid   string  optional  

Example: recusandae

conversionid   string  optional  

Example: adipisci

conversion   object   
email   string  optional  

Must be a valid email address. Example: williamson.caitlyn@example.org

total   string   

Example: excepturi

items   string[]  optional  
itemid   string   

Example: accusamus

price   string   

Example: incidunt

quantity   number   

Example: 1183814.6337692

name   string  optional  

Example: iusto

master_profile_id   string  optional  

GET project/{project_idsite}/conversions/{id}

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/project/11/conversions/quis',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'source' => 'aliquid',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/11/conversions/quis"
);

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

let body = {
    "source": "aliquid"
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/project/11/conversions/quis" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"source\": \"aliquid\"
}"

Request      

GET project/{project_idsite}/conversions/{id}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 11

id   string   

The ID of the conversion. Example: quis

Body Parameters

source   string  optional  

Example: aliquid

PUT project/{project_idsite}/conversions/{id}

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->put(
    'http://localhost/project/11/conversions/maiores',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'ip' => '154.216.243.144',
            'id' => 'qui',
            'source' => 'facere',
            'phone' => 'ullam',
            'profileid' => 'esse',
            'conversionid' => 'sunt',
            'conversion' => [
                'email' => 'elliott.emmerich@example.net',
                'total' => 'laborum',
                'items' => [
                    'odio',
                ],
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/11/conversions/maiores"
);

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

let body = {
    "ip": "154.216.243.144",
    "id": "qui",
    "source": "facere",
    "phone": "ullam",
    "profileid": "esse",
    "conversionid": "sunt",
    "conversion": {
        "email": "elliott.emmerich@example.net",
        "total": "laborum",
        "items": [
            "odio"
        ]
    }
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request PUT \
    "http://localhost/project/11/conversions/maiores" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"ip\": \"154.216.243.144\",
    \"id\": \"qui\",
    \"source\": \"facere\",
    \"phone\": \"ullam\",
    \"profileid\": \"esse\",
    \"conversionid\": \"sunt\",
    \"conversion\": {
        \"email\": \"elliott.emmerich@example.net\",
        \"total\": \"laborum\",
        \"items\": [
            \"odio\"
        ]
    }
}"

Request      

PUT project/{project_idsite}/conversions/{id}

PATCH project/{project_idsite}/conversions/{id}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 11

id   string   

The ID of the conversion. Example: maiores

Body Parameters

ip   string  optional  

Must be a valid IP address. Example: 154.216.243.144

id   string  optional  

Example: qui

source   string  optional  

Example: facere

phone   string  optional  

Example: ullam

profileid   string  optional  

Example: esse

conversionid   string  optional  

Example: sunt

conversion   object   
email   string  optional  

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

total   string   

Example: laborum

items   string[]  optional  
itemid   string   

Example: in

price   string   

Example: harum

quantity   number   

Example: 145.959

name   string  optional  

Example: sunt

master_profile_id   string  optional  

DELETE project/{project_idsite}/conversions/{id}

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://localhost/project/13/conversions/ipsum',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'source' => 'non',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/13/conversions/ipsum"
);

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

let body = {
    "source": "non"
};

fetch(url, {
    method: "DELETE",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request DELETE \
    "http://localhost/project/13/conversions/ipsum" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"source\": \"non\"
}"

Request      

DELETE project/{project_idsite}/conversions/{id}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 13

id   string   

The ID of the conversion. Example: ipsum

Body Parameters

source   string  optional  

Example: non

POST project/{project_idsite}/conversions/bulk

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/project/15/conversions/bulk',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'items' => [
                [
                    'conversion' => [
                        'email' => 'jorge75@example.org',
                        'total' => 'facere',
                        'items' => [
                            'ad',
                        ],
                    ],
                ],
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/15/conversions/bulk"
);

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

let body = {
    "items": [
        {
            "conversion": {
                "email": "jorge75@example.org",
                "total": "facere",
                "items": [
                    "ad"
                ]
            }
        }
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request POST \
    "http://localhost/project/15/conversions/bulk" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"items\": [
        {
            \"conversion\": {
                \"email\": \"jorge75@example.org\",
                \"total\": \"facere\",
                \"items\": [
                    \"ad\"
                ]
            }
        }
    ]
}"

Request      

POST project/{project_idsite}/conversions/bulk

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 15

Body Parameters

items   string  optional  
conversionid   string  optional  

Example: qui

conversion   object   
email   string  optional  

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

total   string   

Example: facere

items   string[]  optional  
itemid   string   

Example: perspiciatis

price   string   

Example: commodi

quantity   number   

Example: 58.62

name   string  optional  

Example: sed

source   string  optional  

Example: quos

ip   string  optional  

Must be a valid IP address. Example: 72.84.142.203

phone   string  optional  

Example: aut

id   string  optional  

Example: iste

created   string  optional  
updated   string  optional  

Custom Conversion

GET project/{project_idsite}/custom-conversions

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/project/4/custom-conversions',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'limit' => '10',
            'page' => '1',
            'order' => 'desc',
            'orderBy' => 'datetime',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/4/custom-conversions"
);

const params = {
    "limit": "10",
    "page": "1",
    "order": "desc",
    "orderBy": "datetime",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/project/4/custom-conversions?limit=10&page=1&order=desc&orderBy=datetime" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET project/{project_idsite}/custom-conversions

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 4

Query Parameters

limit   integer  optional  

Default: 10. Must not be greater than 100. Example: 10

page   integer  optional  

Must be at least 1. Example: 1

order   string  optional  

Default: desc. Must be one of asc or desc. Example: desc

orderBy   string  optional  

Default: datetime. Example: datetime

POST project/{project_idsite}/custom-conversions

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/project/13/custom-conversions',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'error',
            'match_attribute' => 'occaecati',
            'pattern' => 'voluptates',
            'pattern_type' => 'est',
            'case_sensitive' => 2,
            'allow_multiple' => 11,
            'revenue' => 5391.033439021,
            'deleted' => 14,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/13/custom-conversions"
);

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

let body = {
    "name": "error",
    "match_attribute": "occaecati",
    "pattern": "voluptates",
    "pattern_type": "est",
    "case_sensitive": 2,
    "allow_multiple": 11,
    "revenue": 5391.033439021,
    "deleted": 14
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request POST \
    "http://localhost/project/13/custom-conversions" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"error\",
    \"match_attribute\": \"occaecati\",
    \"pattern\": \"voluptates\",
    \"pattern_type\": \"est\",
    \"case_sensitive\": 2,
    \"allow_multiple\": 11,
    \"revenue\": 5391.033439021,
    \"deleted\": 14
}"

Request      

POST project/{project_idsite}/custom-conversions

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 13

Body Parameters

name   string   

Example: error

match_attribute   string   

Example: occaecati

pattern   string  optional  

Example: voluptates

pattern_type   string  optional  

Example: est

case_sensitive   integer  optional  

Example: 2

allow_multiple   integer  optional  

Example: 11

revenue   number  optional  

Example: 5391.033439021

deleted   integer  optional  

Example: 14

GET project/{project_idsite}/custom-conversions/{id}

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/project/6/custom-conversions/debitis',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/6/custom-conversions/debitis"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/project/6/custom-conversions/debitis" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET project/{project_idsite}/custom-conversions/{id}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 6

id   string   

The ID of the custom conversion. Example: debitis

PUT project/{project_idsite}/custom-conversions/{id}

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->put(
    'http://localhost/project/9/custom-conversions/numquam',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'animi',
            'match_attribute' => 'magni',
            'pattern' => 'dolor',
            'pattern_type' => 'tempore',
            'case_sensitive' => 20,
            'allow_multiple' => 9,
            'revenue' => 3046.181378591,
            'deleted' => 8,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/9/custom-conversions/numquam"
);

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

let body = {
    "name": "animi",
    "match_attribute": "magni",
    "pattern": "dolor",
    "pattern_type": "tempore",
    "case_sensitive": 20,
    "allow_multiple": 9,
    "revenue": 3046.181378591,
    "deleted": 8
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request PUT \
    "http://localhost/project/9/custom-conversions/numquam" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"animi\",
    \"match_attribute\": \"magni\",
    \"pattern\": \"dolor\",
    \"pattern_type\": \"tempore\",
    \"case_sensitive\": 20,
    \"allow_multiple\": 9,
    \"revenue\": 3046.181378591,
    \"deleted\": 8
}"

Request      

PUT project/{project_idsite}/custom-conversions/{id}

PATCH project/{project_idsite}/custom-conversions/{id}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 9

id   string   

The ID of the custom conversion. Example: numquam

Body Parameters

name   string   

Example: animi

match_attribute   string   

Example: magni

pattern   string  optional  

Example: dolor

pattern_type   string  optional  

Example: tempore

case_sensitive   integer  optional  

Example: 20

allow_multiple   integer  optional  

Example: 9

revenue   number  optional  

Example: 3046.181378591

deleted   integer  optional  

Example: 8

DELETE project/{project_idsite}/custom-conversions/{id}

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://localhost/project/9/custom-conversions/quas',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/9/custom-conversions/quas"
);

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

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
curl --request DELETE \
    "http://localhost/project/9/custom-conversions/quas" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

DELETE project/{project_idsite}/custom-conversions/{id}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 9

id   string   

The ID of the custom conversion. Example: quas

Custom Rows

GET project/{project_idsite}/templates/custom-rows

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/project/5/templates/custom-rows',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'limit' => '10',
            'page' => '1',
            'order' => 'desc',
            'orderBy' => 'datetime',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/5/templates/custom-rows"
);

const params = {
    "limit": "10",
    "page": "1",
    "order": "desc",
    "orderBy": "datetime",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/project/5/templates/custom-rows?limit=10&page=1&order=desc&orderBy=datetime" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET project/{project_idsite}/templates/custom-rows

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 5

Query Parameters

limit   integer  optional  

Default: 10. Must not be greater than 100. Example: 10

page   integer  optional  

Must be at least 1. Example: 1

order   string  optional  

Default: desc. Must be one of asc or desc. Example: desc

orderBy   string  optional  

Default: datetime. Example: datetime

POST project/{project_idsite}/templates/custom-rows

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/project/5/templates/custom-rows',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'data' => [
                'metadata' => [
                    'name' => 'minus',
                ],
            ],
            'rowId' => 'aliquid',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/5/templates/custom-rows"
);

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

let body = {
    "data": {
        "metadata": {
            "name": "minus"
        }
    },
    "rowId": "aliquid"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request POST \
    "http://localhost/project/5/templates/custom-rows" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"data\": {
        \"metadata\": {
            \"name\": \"minus\"
        }
    },
    \"rowId\": \"aliquid\"
}"

Request      

POST project/{project_idsite}/templates/custom-rows

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 5

Body Parameters

data   object  optional  
metadata   object  optional  
name   string   

Example: minus

rowId   string   

Example: aliquid

GET project/{project_idsite}/templates/custom-rows/{rowId}

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/project/10/templates/custom-rows/10',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/10/templates/custom-rows/10"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/project/10/templates/custom-rows/10" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET project/{project_idsite}/templates/custom-rows/{rowId}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 10

rowId   integer   

Example: 10

DELETE project/{project_idsite}/templates/custom-rows/{rowId}

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://localhost/project/4/templates/custom-rows/20',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/4/templates/custom-rows/20"
);

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

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
curl --request DELETE \
    "http://localhost/project/4/templates/custom-rows/20" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

DELETE project/{project_idsite}/templates/custom-rows/{rowId}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 4

rowId   integer   

Example: 20

Endpoints

GET admin/mongo/{output?}

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/admin/mongo/distinctio',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/admin/mongo/distinctio"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/admin/mongo/distinctio" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET admin/mongo/{output?}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

output   string  optional  

Example: distinctio

GET admin/mongo/internal/{output?}

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/admin/mongo/internal/dolor',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/admin/mongo/internal/dolor"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/admin/mongo/internal/dolor" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET admin/mongo/internal/{output?}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

output   string  optional  

Example: dolor

PUT admin/trics/{tric_tricid}/assets/{asset_assetid}/project/{project_idsite}/queue

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->put(
    'http://localhost/admin/trics/ipsam/assets/13/project/1/queue',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'priority' => 14,
            'timeout' => 3,
            'memory' => 15,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/admin/trics/ipsam/assets/13/project/1/queue"
);

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

let body = {
    "priority": 14,
    "timeout": 3,
    "memory": 15
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request PUT \
    "http://localhost/admin/trics/ipsam/assets/13/project/1/queue" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"priority\": 14,
    \"timeout\": 3,
    \"memory\": 15
}"

Request      

PUT admin/trics/{tric_tricid}/assets/{asset_assetid}/project/{project_idsite}/queue

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

tric_tricid   string   

Example: ipsam

asset_assetid   integer   

Example: 13

project_idsite   integer   

Example: 1

Body Parameters

priority   integer  optional  

Example: 14

timeout   integer  optional  

Example: 3

memory   integer  optional  

Example: 15

GET admin/queue/{taskid}

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/admin/queue/11',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/admin/queue/11"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/admin/queue/11" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET admin/queue/{taskid}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

taskid   integer   

Example: 11

GET admin/project/{project_idsite}/workbench

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/admin/project/18/workbench',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/admin/project/18/workbench"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/admin/project/18/workbench" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET admin/project/{project_idsite}/workbench

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 18

POST admin/project/{project_idsite}/workbench

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/admin/project/4/workbench',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'function' => 'dolorem',
            'priority' => 3,
            'workload' => '["temporibus","unde"]',
            'workbench' => 'exercitationem',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/admin/project/4/workbench"
);

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

let body = {
    "function": "dolorem",
    "priority": 3,
    "workload": "[\"temporibus\",\"unde\"]",
    "workbench": "exercitationem"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request POST \
    "http://localhost/admin/project/4/workbench" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"function\": \"dolorem\",
    \"priority\": 3,
    \"workload\": \"[\\\"temporibus\\\",\\\"unde\\\"]\",
    \"workbench\": \"exercitationem\"
}"

Request      

POST admin/project/{project_idsite}/workbench

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 4

Body Parameters

function   string  optional  

Example: dolorem

priority   integer   

Example: 3

workload   string   

Must be a valid JSON string. Example: ["temporibus","unde"]

workbench   string  optional  

Example: exercitationem

GET admin/performance

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/admin/performance',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/admin/performance"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/admin/performance" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET admin/performance

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

GET apikeys

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/apikeys',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'limit' => '10',
            'page' => '1',
            'order' => 'desc',
            'orderBy' => 'datetime',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/apikeys"
);

const params = {
    "limit": "10",
    "page": "1",
    "order": "desc",
    "orderBy": "datetime",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/apikeys?limit=10&page=1&order=desc&orderBy=datetime" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET apikeys

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

limit   integer  optional  

Default: 10. Must not be greater than 100. Example: 10

page   integer  optional  

Must be at least 1. Example: 1

order   string  optional  

Default: desc. Must be one of asc or desc. Example: desc

orderBy   string  optional  

Default: datetime. Example: datetime

POST apikeys

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/apikeys',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'aliasof' => 'consequuntur',
            'ipadress' => 'eum',
            'description' => 'Hic quisquam aspernatur quisquam rerum.',
            'code' => 'sed',
            'validto' => '2024-03-07T12:00:49',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/apikeys"
);

const params = {
    "aliasof": "consequuntur",
    "ipadress": "eum",
    "description": "Hic quisquam aspernatur quisquam rerum.",
    "code": "sed",
    "validto": "2024-03-07T12:00:49",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

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

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());
curl --request POST \
    "http://localhost/apikeys?aliasof=consequuntur&ipadress=eum&description=Hic+quisquam+aspernatur+quisquam+rerum.&code=sed&validto=2024-03-07T12%3A00%3A49" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

POST apikeys

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

aliasof   string  optional  

Example: consequuntur

ipadress   string  optional  

Example: eum

description   string  optional  

Example: Hic quisquam aspernatur quisquam rerum.

code   string  optional  

Example: sed

validto   string  optional  

Must be a valid date. Example: 2024-03-07T12:00:49

GET apikeys/{id}

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/apikeys/porro',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/apikeys/porro"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/apikeys/porro" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET apikeys/{id}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

id   string   

The ID of the apikey. Example: porro

PUT apikeys/{api_key}

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->put(
    'http://localhost/apikeys/et',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'aliasof' => 'est',
            'ipadress' => 'voluptas',
            'description' => 'Nam aliquid consequatur in qui iste est.',
            'code' => 'autem',
            'validto' => '2024-03-07T12:00:49',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/apikeys/et"
);

const params = {
    "aliasof": "est",
    "ipadress": "voluptas",
    "description": "Nam aliquid consequatur in qui iste est.",
    "code": "autem",
    "validto": "2024-03-07T12:00:49",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

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

fetch(url, {
    method: "PUT",
    headers,
}).then(response => response.json());
curl --request PUT \
    "http://localhost/apikeys/et?aliasof=est&ipadress=voluptas&description=Nam+aliquid+consequatur+in+qui+iste+est.&code=autem&validto=2024-03-07T12%3A00%3A49" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

PUT apikeys/{api_key}

PATCH apikeys/{api_key}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

api_key   string   

Example: et

Query Parameters

aliasof   string  optional  

Example: est

ipadress   string  optional  

Example: voluptas

description   string  optional  

Example: Nam aliquid consequatur in qui iste est.

code   string  optional  

Example: autem

validto   string  optional  

Must be a valid date. Example: 2024-03-07T12:00:49

DELETE apikeys/{id}

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://localhost/apikeys/officia',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/apikeys/officia"
);

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

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
curl --request DELETE \
    "http://localhost/apikeys/officia" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

DELETE apikeys/{id}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

id   string   

The ID of the apikey. Example: officia

GET database

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/database',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/database"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/database" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET database

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

GET database/projects

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/database/projects',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'mongodb' => 4,
            'sqldb' => 20,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/database/projects"
);

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

let body = {
    "mongodb": 4,
    "sqldb": 20
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/database/projects" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"mongodb\": 4,
    \"sqldb\": 20
}"

Request      

GET database/projects

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Body Parameters

mongodb   integer  optional  

Example: 4

sqldb   integer  optional  

Example: 20

GET project/{project_idsite}/limits

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/project/15/limits',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/15/limits"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/project/15/limits" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET project/{project_idsite}/limits

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 15

POST project/{project_idsite}/integrations/woocommerce/connect

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/project/17/integrations/woocommerce/connect',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'consumer_key' => 'et',
            'consumer_secret' => 'omnis',
            'url' => 'http://grimes.biz/quaerat-facere-qui-eum-sunt',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/17/integrations/woocommerce/connect"
);

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

let body = {
    "consumer_key": "et",
    "consumer_secret": "omnis",
    "url": "http:\/\/grimes.biz\/quaerat-facere-qui-eum-sunt"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request POST \
    "http://localhost/project/17/integrations/woocommerce/connect" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"consumer_key\": \"et\",
    \"consumer_secret\": \"omnis\",
    \"url\": \"http:\\/\\/grimes.biz\\/quaerat-facere-qui-eum-sunt\"
}"

Request      

POST project/{project_idsite}/integrations/woocommerce/connect

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 17

Body Parameters

consumer_key   string   

Example: et

consumer_secret   string   

Example: omnis

url   string   

Must be a valid URL. Example: http://grimes.biz/quaerat-facere-qui-eum-sunt

GET project/{project_idsite}/flowcache/{campaignid}

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/project/7/flowcache/enim',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/7/flowcache/enim"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/project/7/flowcache/enim" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET project/{project_idsite}/flowcache/{campaignid}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 7

campaignid   string   

Example: enim

GET project/{project_idsite}/flowcache/{campaignid}/{visitorid}

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/project/11/flowcache/accusantium/officia',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/11/flowcache/accusantium/officia"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/project/11/flowcache/accusantium/officia" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET project/{project_idsite}/flowcache/{campaignid}/{visitorid}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 11

campaignid   string   

Example: accusantium

visitorid   string   

Example: officia

GET project/{project_idsite}/dns

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/project/1/dns',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/1/dns"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/project/1/dns" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET project/{project_idsite}/dns

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 1

POST project/{project_idsite}/dns

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/project/3/dns',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'fugiat',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/3/dns"
);

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

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

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request POST \
    "http://localhost/project/3/dns" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"fugiat\"
}"

Request      

POST project/{project_idsite}/dns

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 3

Body Parameters

name   string   

Example: fugiat

PUT project/{project_idsite}/dns/{domainId}/verify

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->put(
    'http://localhost/project/13/dns/cupiditate/verify',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/13/dns/cupiditate/verify"
);

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

fetch(url, {
    method: "PUT",
    headers,
}).then(response => response.json());
curl --request PUT \
    "http://localhost/project/13/dns/cupiditate/verify" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

PUT project/{project_idsite}/dns/{domainId}/verify

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 13

domainId   string   

Example: cupiditate

DELETE project/{project_idsite}/dns/{domainId}

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://localhost/project/7/dns/libero',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/7/dns/libero"
);

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

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
curl --request DELETE \
    "http://localhost/project/7/dns/libero" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

DELETE project/{project_idsite}/dns/{domainId}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 7

domainId   string   

Example: libero

GET project/{project_idsite}/subscription

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/project/3/subscription',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/3/subscription"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/project/3/subscription" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET project/{project_idsite}/subscription

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 3

PUT project/{project_idsite}/subscription

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->put(
    'http://localhost/project/18/subscription',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'productId' => 7,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/18/subscription"
);

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

let body = {
    "productId": 7
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request PUT \
    "http://localhost/project/18/subscription" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"productId\": 7
}"

Request      

PUT project/{project_idsite}/subscription

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 18

Body Parameters

productId   integer   

Example: 7

GET project/{project_idsite}/touchpoint/queues

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/project/14/touchpoint/queues',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'limit' => '10',
            'page' => '1',
            'order' => 'desc',
            'orderBy' => 'datetime',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/14/touchpoint/queues"
);

const params = {
    "limit": "10",
    "page": "1",
    "order": "desc",
    "orderBy": "datetime",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/project/14/touchpoint/queues?limit=10&page=1&order=desc&orderBy=datetime" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET project/{project_idsite}/touchpoint/queues

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 14

Query Parameters

limit   integer  optional  

Default: 10. Must not be greater than 100. Example: 10

page   integer  optional  

Must be at least 1. Example: 1

order   string  optional  

Default: desc. Must be one of asc or desc. Example: desc

orderBy   string  optional  

Default: datetime. Example: datetime

GET project/{project_idsite}/touchpoint/queues/{id}

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/project/20/touchpoint/queues/sapiente',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/20/touchpoint/queues/sapiente"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/project/20/touchpoint/queues/sapiente" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET project/{project_idsite}/touchpoint/queues/{id}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 20

id   string   

The ID of the queue. Example: sapiente

POST user/create-verification

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/user/create-verification',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'action' => 'quia',
            'email' => 'awolff@example.net',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/user/create-verification"
);

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

let body = {
    "action": "quia",
    "email": "awolff@example.net"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request POST \
    "http://localhost/user/create-verification" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"action\": \"quia\",
    \"email\": \"awolff@example.net\"
}"

Request      

POST user/create-verification

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Body Parameters

action   string   

Example: quia

email   string   

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

POST user/verify/{hash}

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/user/verify/qui',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'action' => 'molestiae',
            'verification_code' => 'qvhn',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/user/verify/qui"
);

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

let body = {
    "action": "molestiae",
    "verification_code": "qvhn"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request POST \
    "http://localhost/user/verify/qui" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"action\": \"molestiae\",
    \"verification_code\": \"qvhn\"
}"

Request      

POST user/verify/{hash}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

hash   string   

Example: qui

Body Parameters

action   string   

Example: molestiae

verification_code   string   

Must not be greater than 6 characters. Example: qvhn

PUT password/change

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->put(
    'http://localhost/password/change',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'password_new' => 'rjuqnbznmhfumsbxgybhyee',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/password/change"
);

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

let body = {
    "password_new": "rjuqnbznmhfumsbxgybhyee"
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request PUT \
    "http://localhost/password/change" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"password_new\": \"rjuqnbznmhfumsbxgybhyee\"
}"

Request      

PUT password/change

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Body Parameters

password_new   string   

Must be at least 8 characters. Example: rjuqnbznmhfumsbxgybhyee

GET project/{project_idsite}/access

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/project/14/access',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/14/access"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/project/14/access" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET project/{project_idsite}/access

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 14

POST partners/{partner_partnerid}/projects/{project_idsite}

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/partners/17/projects/19',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/partners/17/projects/19"
);

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

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());
curl --request POST \
    "http://localhost/partners/17/projects/19" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

POST partners/{partner_partnerid}/projects/{project_idsite}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

partner_partnerid   integer   

Example: 17

project_idsite   integer   

Example: 19

PUT partners/{partner_partnerid}/projects/{project_idsite}

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->put(
    'http://localhost/partners/18/projects/3',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'status' => 'active',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/partners/18/projects/3"
);

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

let body = {
    "status": "active"
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request PUT \
    "http://localhost/partners/18/projects/3" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"status\": \"active\"
}"

Request      

PUT partners/{partner_partnerid}/projects/{project_idsite}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

partner_partnerid   integer   

Example: 18

project_idsite   integer   

Example: 3

Body Parameters

status   string  optional  

Must be one of active, declined, or invited. Example: active

POST partners/{partner_partnerid}/projects/{project_idsite}/primary

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/partners/5/projects/14/primary',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/partners/5/projects/14/primary"
);

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

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());
curl --request POST \
    "http://localhost/partners/5/projects/14/primary" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

POST partners/{partner_partnerid}/projects/{project_idsite}/primary

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

partner_partnerid   integer   

Example: 5

project_idsite   integer   

Example: 14

Authorize a client to access the user's account.

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/token',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/token"
);

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

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());
curl --request POST \
    "http://localhost/token" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

POST token

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Authorize a client to access the user's account.

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/authorize',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/authorize"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/authorize" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET authorize

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Get a fresh transient token cookie for the authenticated user.

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/token/refresh',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/token/refresh"
);

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

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());
curl --request POST \
    "http://localhost/token/refresh" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

POST token/refresh

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Approve the authorization request.

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/authorize',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/authorize"
);

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

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());
curl --request POST \
    "http://localhost/authorize" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

POST authorize

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Deny the authorization request.

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://localhost/authorize',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/authorize"
);

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

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
curl --request DELETE \
    "http://localhost/authorize" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

DELETE authorize

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Get all of the authorized tokens for the authenticated user.

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/tokens',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/tokens"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/tokens" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET tokens

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Delete the given token.

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://localhost/tokens/non',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/tokens/non"
);

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

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
curl --request DELETE \
    "http://localhost/tokens/non" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

DELETE tokens/{token_id}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

token_id   string   

The ID of the token. Example: non

Get all of the clients for the authenticated user.

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/clients',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/clients"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/clients" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET clients

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Store a new client.

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/clients',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/clients"
);

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

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());
curl --request POST \
    "http://localhost/clients" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

POST clients

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Update the given client.

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->put(
    'http://localhost/clients/facilis',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/clients/facilis"
);

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

fetch(url, {
    method: "PUT",
    headers,
}).then(response => response.json());
curl --request PUT \
    "http://localhost/clients/facilis" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

PUT clients/{client_id}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

client_id   string   

The ID of the client. Example: facilis

Delete the given client.

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://localhost/clients/quis',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/clients/quis"
);

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

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
curl --request DELETE \
    "http://localhost/clients/quis" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

DELETE clients/{client_id}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

client_id   string   

The ID of the client. Example: quis

Get all of the available scopes for the application.

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/scopes',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/scopes"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/scopes" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET scopes

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Get all of the personal access tokens for the authenticated user.

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/personal-access-tokens',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/personal-access-tokens"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/personal-access-tokens" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET personal-access-tokens

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Create a new personal access token for the user.

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/personal-access-tokens',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/personal-access-tokens"
);

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

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());
curl --request POST \
    "http://localhost/personal-access-tokens" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

POST personal-access-tokens

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Delete the given token.

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://localhost/personal-access-tokens/autem',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/personal-access-tokens/autem"
);

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

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
curl --request DELETE \
    "http://localhost/personal-access-tokens/autem" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

DELETE personal-access-tokens/{token_id}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

token_id   string   

The ID of the token. Example: autem

Import

Validate a file or url before importing.

requires authentication

Validates a file or url before further importing the data.

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/project/15/import/validate',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'multipart/form-data',
            'Accept' => 'application/json',
        ],
        'multipart' => [
            [
                'name' => 'type',
                'contents' => 'est'
            ],
            [
                'name' => 'csv_delimiter',
                'contents' => 'culpa'
            ],
            [
                'name' => 'url',
                'contents' => 'http://douglas.com/'
            ],
            [
                'name' => 'xml_element',
                'contents' => 'accusantium'
            ],
            [
                'name' => 'document',
                'contents' => fopen('/tmp/phpJecjGd', 'r')
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/15/import/validate"
);

const headers = {
    "x-apikey": "{YOUR_APIKEY}",
    "Content-Type": "multipart/form-data",
    "Accept": "application/json",
};

const body = new FormData();
body.append('type', 'est');
body.append('csv_delimiter', 'culpa');
body.append('url', 'http://douglas.com/');
body.append('xml_element', 'accusantium');
body.append('document', document.querySelector('input[name="document"]').files[0]);

fetch(url, {
    method: "POST",
    headers,
    body,
}).then(response => response.json());
curl --request POST \
    "http://localhost/project/15/import/validate" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: multipart/form-data" \
    --header "Accept: application/json" \
    --form "type=est"\
    --form "csv_delimiter=culpa"\
    --form "url=http://douglas.com/"\
    --form "xml_element=accusantium"\
    --form "document=@/tmp/phpJecjGd"

Example response (200, success):


{
    "url": "The url of the imported data",
    "record": "An associative array of the first record"
}

Request      

POST project/{project_idsite}/import/validate

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: multipart/form-data

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 15

Body Parameters

type   string  optional  

The type of document you want to validate (url or file) Example: est

document   file   

The CSV file that needs to be uploaded Example: /tmp/phpJecjGd

csv_delimiter   string  optional  

The character that separates the data fields for the CSV, comma by default, for file validations Example: culpa

url   string  optional  

The location of the XML file, must be publicly accessible Example: http://douglas.com/

xml_element   string  optional  

The XML element name which indicates a record when type is url Example: accusantium

Start an import process.

requires authentication

This creates an integration and adds the request to the queue to be started.

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/project/13/import/process',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'importer_name' => 'qui',
            'url_data' => 'et',
            'file_type' => 'minima',
            'frequency' => 'exercitationem',
            'item_type' => 'tempora',
            'object_type' => 'officia',
            'mapped_format' => [],
            'element' => 'minus',
            'itemid' => 'autem',
            'item_name' => 'atque',
            'channelid' => 'qui',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/13/import/process"
);

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

let body = {
    "importer_name": "qui",
    "url_data": "et",
    "file_type": "minima",
    "frequency": "exercitationem",
    "item_type": "tempora",
    "object_type": "officia",
    "mapped_format": [],
    "element": "minus",
    "itemid": "autem",
    "item_name": "atque",
    "channelid": "qui"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request POST \
    "http://localhost/project/13/import/process" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"importer_name\": \"qui\",
    \"url_data\": \"et\",
    \"file_type\": \"minima\",
    \"frequency\": \"exercitationem\",
    \"item_type\": \"tempora\",
    \"object_type\": \"officia\",
    \"mapped_format\": [],
    \"element\": \"minus\",
    \"itemid\": \"autem\",
    \"item_name\": \"atque\",
    \"channelid\": \"qui\"
}"

Example response (200, success):


{
 "channelid":"The id of the created integration",
 "channel":"The identifier of the channel"
 "channelname":"The name of the channel"
 "settings" : "The integration settings
}

Request      

POST project/{project_idsite}/import/process

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 13

Body Parameters

importer_name   string   

Example: qui

url_data   string   

Example: et

file_type   string   

Example: minima

frequency   string  optional  

This field is required when file_type is url. Example: exercitationem

item_type   string  optional  

Example: tempora

object_type   string  optional  

Example: officia

mapped_format   object   
element   string  optional  

Example: minus

itemid   string  optional  

This field is required when item_type is content. Example: autem

item_name   string  optional  

Example: atque

channelid   string  optional  

Example: qui

Integrations

GET project/{project_idsite}/integrations

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/project/19/integrations',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'status' => '0',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/19/integrations"
);

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

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/project/19/integrations?status=" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET project/{project_idsite}/integrations

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 19

Query Parameters

status   boolean  optional  

Example: false

POST project/{project_idsite}/integrations/{channel_channel}

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/project/9/integrations/repellat',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/9/integrations/repellat"
);

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

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());
curl --request POST \
    "http://localhost/project/9/integrations/repellat" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \

Request      

POST project/{project_idsite}/integrations/{channel_channel}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 9

channel_channel   string   

Example: repellat

Body Parameters

settings   object  optional  

GET project/{project_idsite}/integrations/validations

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/project/6/integrations/validations',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/6/integrations/validations"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/project/6/integrations/validations" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET project/{project_idsite}/integrations/validations

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 6

GET project/{project_idsite}/integrations/{channelid}

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/project/19/integrations/autem',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/19/integrations/autem"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/project/19/integrations/autem" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET project/{project_idsite}/integrations/{channelid}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 19

channelid   string   

Example: autem

PUT project/{project_idsite}/integrations/{channelid}

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->put(
    'http://localhost/project/10/integrations/dolor',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'settings' => [],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/10/integrations/dolor"
);

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

let body = {
    "settings": []
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request PUT \
    "http://localhost/project/10/integrations/dolor" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"settings\": []
}"

Request      

PUT project/{project_idsite}/integrations/{channelid}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 10

channelid   string   

Example: dolor

Body Parameters

settings   object   

DELETE project/{project_idsite}/integrations/{integration_channelid}

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://localhost/project/12/integrations/error',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/12/integrations/error"
);

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

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
curl --request DELETE \
    "http://localhost/project/12/integrations/error" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

DELETE project/{project_idsite}/integrations/{integration_channelid}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 12

integration_channelid   string   

Example: error

GET project/{project_idsite}/integrations/{integration_channelid}/validate

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/project/8/integrations/voluptas/validate',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/8/integrations/voluptas/validate"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/project/8/integrations/voluptas/validate" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET project/{project_idsite}/integrations/{integration_channelid}/validate

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 8

integration_channelid   string   

Example: voluptas

DELETE project/{project_idsite}/integrations/{integration_channelid}/validate

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://localhost/project/1/integrations/magni/validate',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/1/integrations/magni/validate"
);

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

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
curl --request DELETE \
    "http://localhost/project/1/integrations/magni/validate" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

DELETE project/{project_idsite}/integrations/{integration_channelid}/validate

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 1

integration_channelid   string   

Example: magni

POST project/{project_idsite}/integrations/{integration_channelid}/validate

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/project/9/integrations/perferendis/validate',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            [
                'name' => 'Authentication',
                'status' => true,
                'cta' => [
                    'label' => 'Check authentication settings',
                    'url' => '/integration/settings',
                ],
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/9/integrations/perferendis/validate"
);

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

let body = [
    {
        "name": "Authentication",
        "status": true,
        "cta": {
            "label": "Check authentication settings",
            "url": "\/integration\/settings"
        }
    }
];

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request POST \
    "http://localhost/project/9/integrations/perferendis/validate" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "[
    {
        \"name\": \"Authentication\",
        \"status\": true,
        \"cta\": {
            \"label\": \"Check authentication settings\",
            \"url\": \"\\/integration\\/settings\"
        }
    }
]"

Request      

POST project/{project_idsite}/integrations/{integration_channelid}/validate

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 9

integration_channelid   string   

Example: perferendis

Body Parameters

The request body is an array (object[]`), representing list of validations. Each item has the following properties:

name   string   

Example: Authentication

status   boolean   

Example: true

cta   object  optional  

POST project/{project_idsite}/integrations/{integration_channelid}/warning-ignore

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/project/8/integrations/optio/warning-ignore',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'disabled' => 'temporarily',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/8/integrations/optio/warning-ignore"
);

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

let body = {
    "disabled": "temporarily"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request POST \
    "http://localhost/project/8/integrations/optio/warning-ignore" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"disabled\": \"temporarily\"
}"

Request      

POST project/{project_idsite}/integrations/{integration_channelid}/warning-ignore

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 8

integration_channelid   string   

Example: optio

Body Parameters

disabled   string   

Must be one of indefinite or temporarily. Example: temporarily

Journeys

POST project/{project_idsite}/journeys/{journey_journeyid}/copy

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/project/20/journeys/dolorem/copy',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'projectId' => 'voluptates',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/20/journeys/dolorem/copy"
);

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

let body = {
    "projectId": "voluptates"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request POST \
    "http://localhost/project/20/journeys/dolorem/copy" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"projectId\": \"voluptates\"
}"

Request      

POST project/{project_idsite}/journeys/{journey_journeyid}/copy

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 20

journey_journeyid   string   

Example: dolorem

Body Parameters

projectId   string   

Example: voluptates

GET project/{project_idsite}/journeys

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/project/13/journeys',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'limit' => '10',
            'page' => '1',
            'order' => 'desc',
            'orderBy' => 'datetime',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/13/journeys"
);

const params = {
    "limit": "10",
    "page": "1",
    "order": "desc",
    "orderBy": "datetime",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/project/13/journeys?limit=10&page=1&order=desc&orderBy=datetime" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET project/{project_idsite}/journeys

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 13

Query Parameters

limit   integer  optional  

Default: 10. Must not be greater than 100. Example: 10

page   integer  optional  

Must be at least 1. Example: 1

order   string  optional  

Default: desc. Must be one of asc or desc. Example: desc

orderBy   string  optional  

Default: datetime. Example: datetime

POST project/{project_idsite}/journeys

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/project/4/journeys',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'et',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/4/journeys"
);

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

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

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request POST \
    "http://localhost/project/4/journeys" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"et\"
}"

Request      

POST project/{project_idsite}/journeys

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 4

Body Parameters

name   string   

Example: et

GET project/{project_idsite}/journeys/{journeyid}

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/project/8/journeys/corrupti',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/8/journeys/corrupti"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/project/8/journeys/corrupti" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET project/{project_idsite}/journeys/{journeyid}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 8

journeyid   string   

Example: corrupti

PUT project/{project_idsite}/journeys/{journeyid}

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->put(
    'http://localhost/project/6/journeys/aspernatur',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'dolorum',
            'description' => 'Quaerat pariatur ipsam ducimus ratione.',
            'status' => 'mollitia',
            'start' => 'quasi',
            'end' => 'atque',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/6/journeys/aspernatur"
);

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

let body = {
    "name": "dolorum",
    "description": "Quaerat pariatur ipsam ducimus ratione.",
    "status": "mollitia",
    "start": "quasi",
    "end": "atque"
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request PUT \
    "http://localhost/project/6/journeys/aspernatur" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"dolorum\",
    \"description\": \"Quaerat pariatur ipsam ducimus ratione.\",
    \"status\": \"mollitia\",
    \"start\": \"quasi\",
    \"end\": \"atque\"
}"

Request      

PUT project/{project_idsite}/journeys/{journeyid}

PATCH project/{project_idsite}/journeys/{journeyid}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 6

journeyid   string   

Example: aspernatur

Body Parameters

name   string  optional  

Example: dolorum

description   string  optional  

Example: Quaerat pariatur ipsam ducimus ratione.

status   string  optional  

Example: mollitia

start   string  optional  

Example: quasi

end   string  optional  

Example: atque

targeting   object  optional  
settings   object  optional  
goals   object  optional  
segments   object  optional  

DELETE project/{project_idsite}/journeys/{journeyid}

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://localhost/project/12/journeys/minus',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/12/journeys/minus"
);

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

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
curl --request DELETE \
    "http://localhost/project/12/journeys/minus" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

DELETE project/{project_idsite}/journeys/{journeyid}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 12

journeyid   string   

Example: minus

Logs

GET project/{project}/logs/email

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/project/est/logs/email',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'from' => '2024-03-07 12:00:50',
            'to' => '1995-08-26',
            'campaignid' => 'awddssnlketvgziat',
            'limit' => '11',
            'page' => '17',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/est/logs/email"
);

const params = {
    "from": "2024-03-07 12:00:50",
    "to": "1995-08-26",
    "campaignid": "awddssnlketvgziat",
    "limit": "11",
    "page": "17",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/project/est/logs/email?from=2024-03-07+12%3A00%3A50&to=1995-08-26&campaignid=awddssnlketvgziat&limit=11&page=17" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET project/{project}/logs/email

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project   string   

The project. Example: est

Query Parameters

from   string  optional  

This field is required when to is present. Must be a valid date in the format Y-m-d H:i:s. Example: 2024-03-07 12:00:50

to   string  optional  

Must be a valid date in the format Y-m-d H:i:s. Must be a date after or equal to from. Must be a date before now. Example: 1995-08-26

campaignid   string  optional  

Must be 17 characters. Example: awddssnlketvgziat

limit   integer  optional  

Must be between 10 and 100. Example: 11

page   integer  optional  

Example: 17

GET project/{project_idsite}/activity/logs

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/project/9/activity/logs',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'limit' => '20',
            'page' => '4',
            'objectid' => 'illo',
            'object' => 'accusamus',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/9/activity/logs"
);

const params = {
    "limit": "20",
    "page": "4",
    "objectid": "illo",
    "object": "accusamus",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/project/9/activity/logs?limit=20&page=4&objectid=illo&object=accusamus" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET project/{project_idsite}/activity/logs

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 9

Query Parameters

limit   integer  optional  

Must not be greater than 100. Example: 20

page   integer  optional  

Example: 4

objectid   string  optional  

Example: illo

object   string  optional  

Example: accusamus

Magmodules

POST project/{project_idsite}/integrations/magmodules/connect

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/project/18/integrations/magmodules/connect',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'magento_token' => 'ducimus',
            'magento_url' => 'aut',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/18/integrations/magmodules/connect"
);

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

let body = {
    "magento_token": "ducimus",
    "magento_url": "aut"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request POST \
    "http://localhost/project/18/integrations/magmodules/connect" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"magento_token\": \"ducimus\",
    \"magento_url\": \"aut\"
}"

Request      

POST project/{project_idsite}/integrations/magmodules/connect

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 18

Body Parameters

magento_token   string   

Example: ducimus

magento_url   string   

Example: aut

GET project/{project_idsite}/integrations/magmodules/{integration_channelid}/magmodules

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/project/4/integrations/magmodules/totam/magmodules',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/4/integrations/magmodules/totam/magmodules"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/project/4/integrations/magmodules/totam/magmodules" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET project/{project_idsite}/integrations/magmodules/{integration_channelid}/magmodules

POST project/{project_idsite}/integrations/magmodules/{integration_channelid}/magmodules

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 4

integration_channelid   string   

Example: totam

Oauth endpoints

GET oauth/connect

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/oauth/connect',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'state' => 'eum',
            'code' => 'qui',
            'oauth_token' => 'laudantium',
            'oauth_verifier' => 'qui',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/oauth/connect"
);

const params = {
    "state": "eum",
    "code": "qui",
    "oauth_token": "laudantium",
    "oauth_verifier": "qui",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/oauth/connect?state=eum&code=qui&oauth_token=laudantium&oauth_verifier=qui" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET oauth/connect

Headers

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

state   string   

Example: eum

code   string  optional  

This field is required when oauth_token or oauth_verifier is not present. Example: qui

oauth_token   string  optional  

This field is required when code is not present. Example: laudantium

oauth_verifier   string  optional  

This field is required when code is not present. Example: qui

GET ccvshop/handshake

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/ccvshop/handshake',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'api_public' => 'hic',
            'api_secret' => 'atque',
            'api_root' => 'cum',
            'return_url' => 'https://www.gaylord.com/sunt-minima-rerum-nihil-laboriosam-aut',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/ccvshop/handshake"
);

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

let body = {
    "api_public": "hic",
    "api_secret": "atque",
    "api_root": "cum",
    "return_url": "https:\/\/www.gaylord.com\/sunt-minima-rerum-nihil-laboriosam-aut"
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/ccvshop/handshake" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"api_public\": \"hic\",
    \"api_secret\": \"atque\",
    \"api_root\": \"cum\",
    \"return_url\": \"https:\\/\\/www.gaylord.com\\/sunt-minima-rerum-nihil-laboriosam-aut\"
}"

Request      

GET ccvshop/handshake

POST ccvshop/handshake

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Body Parameters

api_public   string   

Example: hic

api_secret   string   

Example: atque

api_root   string   

Example: cum

return_url   string   

Example: https://www.gaylord.com/sunt-minima-rerum-nihil-laboriosam-aut

GET ccvshop/uninstall

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/ccvshop/uninstall',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'api_public' => 'debitis',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/ccvshop/uninstall"
);

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

let body = {
    "api_public": "debitis"
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/ccvshop/uninstall" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"api_public\": \"debitis\"
}"

Request      

GET ccvshop/uninstall

POST ccvshop/uninstall

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Body Parameters

api_public   string   

Example: debitis

GET ccvshop/success

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/ccvshop/success',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'api_public' => 'illum',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/ccvshop/success"
);

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

let body = {
    "api_public": "illum"
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/ccvshop/success" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"api_public\": \"illum\"
}"

Request      

GET ccvshop/success

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Body Parameters

api_public   string   

Example: illum

GET project/{project_idsite}/integrations/{integration_channelid}/getUrl

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/project/3/integrations/unde/getUrl',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/3/integrations/unde/getUrl"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/project/3/integrations/unde/getUrl" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET project/{project_idsite}/integrations/{integration_channelid}/getUrl

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 3

integration_channelid   string   

Example: unde

GET project/{project_idsite}/integrations/{integration_channelid}/choices

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/project/20/integrations/dicta/choices',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/20/integrations/dicta/choices"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/project/20/integrations/dicta/choices" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET project/{project_idsite}/integrations/{integration_channelid}/choices

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 20

integration_channelid   string   

Example: dicta

Partner

GET partners

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/partners',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'limit' => '10',
            'page' => '1',
            'order' => 'desc',
            'orderBy' => 'datetime',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/partners"
);

const params = {
    "limit": "10",
    "page": "1",
    "order": "desc",
    "orderBy": "datetime",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/partners?limit=10&page=1&order=desc&orderBy=datetime" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET partners

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

limit   integer  optional  

Default: 10. Must not be greater than 100. Example: 10

page   integer  optional  

Must be at least 1. Example: 1

order   string  optional  

Default: desc. Must be one of asc or desc. Example: desc

orderBy   string  optional  

Default: datetime. Example: datetime

GET partners/{partnerid}

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/partners/10',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/partners/10"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/partners/10" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET partners/{partnerid}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

partnerid   integer   

Example: 10

PUT partners/{partnerid}

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->put(
    'http://localhost/partners/8',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'company_name' => 'ut',
            'address' => 'pariatur',
            'city' => 'beatae',
            'country' => 'iure',
            'phone_number' => 'consequatur',
            'zipcode' => 'quos',
            'email' => 'nakia.runte@example.com',
            'status' => 'maiores',
            'type' => 'dolore',
            'website' => 'rerum',
            'company_icon' => 'veritatis',
            'min_price' => '',
            'max_price' => '',
            'description' => 'Vel quam consequatur temporibus ea non asperiores.',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/partners/8"
);

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

let body = {
    "company_name": "ut",
    "address": "pariatur",
    "city": "beatae",
    "country": "iure",
    "phone_number": "consequatur",
    "zipcode": "quos",
    "email": "nakia.runte@example.com",
    "status": "maiores",
    "type": "dolore",
    "website": "rerum",
    "company_icon": "veritatis",
    "min_price": "",
    "max_price": "",
    "description": "Vel quam consequatur temporibus ea non asperiores."
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request PUT \
    "http://localhost/partners/8" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"company_name\": \"ut\",
    \"address\": \"pariatur\",
    \"city\": \"beatae\",
    \"country\": \"iure\",
    \"phone_number\": \"consequatur\",
    \"zipcode\": \"quos\",
    \"email\": \"nakia.runte@example.com\",
    \"status\": \"maiores\",
    \"type\": \"dolore\",
    \"website\": \"rerum\",
    \"company_icon\": \"veritatis\",
    \"min_price\": \"\",
    \"max_price\": \"\",
    \"description\": \"Vel quam consequatur temporibus ea non asperiores.\"
}"

Request      

PUT partners/{partnerid}

PATCH partners/{partnerid}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

partnerid   integer   

Example: 8

Body Parameters

company_name   string   

Example: ut

address   string   

Example: pariatur

city   string   

Example: beatae

country   string   

Example: iure

phone_number   string   

Example: consequatur

zipcode   string   

Example: quos

email   string   

Example: nakia.runte@example.com

status   string   

Example: maiores

type   string   

Example: dolore

services   object  optional  
website   string  optional  

Example: rerum

company_icon   string  optional  

Example: veritatis

min_price   string  optional  

Must match the regex /^\d*(.\d{1,2})?$/.

max_price   string  optional  

Must match the regex /^\d*(.\d{1,2})?$/.

description   string  optional  

Example: Vel quam consequatur temporibus ea non asperiores.

Partner Invite

GET partners/{partner_partnerid}/invite

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/partners/2/invite',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'limit' => '10',
            'page' => '1',
            'order' => 'desc',
            'orderBy' => 'datetime',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/partners/2/invite"
);

const params = {
    "limit": "10",
    "page": "1",
    "order": "desc",
    "orderBy": "datetime",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/partners/2/invite?limit=10&page=1&order=desc&orderBy=datetime" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET partners/{partner_partnerid}/invite

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

partner_partnerid   integer   

Example: 2

Query Parameters

limit   integer  optional  

Default: 10. Must not be greater than 100. Example: 10

page   integer  optional  

Must be at least 1. Example: 1

order   string  optional  

Default: desc. Must be one of asc or desc. Example: desc

orderBy   string  optional  

Default: datetime. Example: datetime

POST partners/{partner_partnerid}/invite

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/partners/5/invite',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'login' => 'asperiores',
            'access' => 'eaque',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/partners/5/invite"
);

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

let body = {
    "login": "asperiores",
    "access": "eaque"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request POST \
    "http://localhost/partners/5/invite" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"login\": \"asperiores\",
    \"access\": \"eaque\"
}"

Request      

POST partners/{partner_partnerid}/invite

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

partner_partnerid   integer   

Example: 5

Body Parameters

login   string   

Must be a valid email address. Example: asperiores

access   string   

Example: eaque

GET partners/{partner_partnerid}/invite/{id}

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/partners/19/invite/fuga',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/partners/19/invite/fuga"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/partners/19/invite/fuga" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET partners/{partner_partnerid}/invite/{id}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

partner_partnerid   integer   

Example: 19

id   string   

The ID of the invite. Example: fuga

PUT partners/{partner_partnerid}/invite/{id}

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->put(
    'http://localhost/partners/16/invite/sunt',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'access' => 'amet',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/partners/16/invite/sunt"
);

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

let body = {
    "access": "amet"
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request PUT \
    "http://localhost/partners/16/invite/sunt" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"access\": \"amet\"
}"

Request      

PUT partners/{partner_partnerid}/invite/{id}

PATCH partners/{partner_partnerid}/invite/{id}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

partner_partnerid   integer   

Example: 16

id   string   

The ID of the invite. Example: sunt

Body Parameters

access   string   

Example: amet

DELETE partners/{partner_partnerid}/invite/{id}

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://localhost/partners/1/invite/quidem',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/partners/1/invite/quidem"
);

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

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
curl --request DELETE \
    "http://localhost/partners/1/invite/quidem" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

DELETE partners/{partner_partnerid}/invite/{id}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

partner_partnerid   integer   

Example: 1

id   string   

The ID of the invite. Example: quidem

PartnerProject

GET partners/{partner_partnerid}/projects

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/partners/17/projects',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'limit' => '10',
            'page' => '1',
            'order' => 'desc',
            'orderBy' => 'datetime',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/partners/17/projects"
);

const params = {
    "limit": "10",
    "page": "1",
    "order": "desc",
    "orderBy": "datetime",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/partners/17/projects?limit=10&page=1&order=desc&orderBy=datetime" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET partners/{partner_partnerid}/projects

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

partner_partnerid   integer   

Example: 17

Query Parameters

limit   integer  optional  

Default: 10. Must not be greater than 100. Example: 10

page   integer  optional  

Must be at least 1. Example: 1

order   string  optional  

Default: desc. Must be one of asc or desc. Example: desc

orderBy   string  optional  

Default: datetime. Example: datetime

GET partners/{partner_partnerid}/projects/{idsite}

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/partners/8/projects/13',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/partners/8/projects/13"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/partners/8/projects/13" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET partners/{partner_partnerid}/projects/{idsite}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

partner_partnerid   integer   

Example: 8

idsite   integer   

Example: 13

DELETE partners/{partner_partnerid}/projects/{idsite}

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://localhost/partners/18/projects/15',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/partners/18/projects/15"
);

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

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
curl --request DELETE \
    "http://localhost/partners/18/projects/15" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

DELETE partners/{partner_partnerid}/projects/{idsite}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

partner_partnerid   integer   

Example: 18

idsite   integer   

Example: 15

Partner Team

GET partners/{partner_partnerid}/team

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/partners/5/team',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/partners/5/team"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/partners/5/team" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET partners/{partner_partnerid}/team

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

partner_partnerid   integer   

Example: 5

POST partners/{partner_partnerid}/team

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/partners/6/team',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'email' => 'block.abbie@example.com',
            'access' => 'expedita',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/partners/6/team"
);

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

let body = {
    "email": "block.abbie@example.com",
    "access": "expedita"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request POST \
    "http://localhost/partners/6/team" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"email\": \"block.abbie@example.com\",
    \"access\": \"expedita\"
}"

Request      

POST partners/{partner_partnerid}/team

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

partner_partnerid   integer   

Example: 6

Body Parameters

email   string   

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

access   string   

Example: expedita

PUT partners/{partner_partnerid}/team/{id}

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->put(
    'http://localhost/partners/20/team/excepturi',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'email' => 'kfritsch@example.net',
            'access' => 'repellendus',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/partners/20/team/excepturi"
);

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

let body = {
    "email": "kfritsch@example.net",
    "access": "repellendus"
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request PUT \
    "http://localhost/partners/20/team/excepturi" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"email\": \"kfritsch@example.net\",
    \"access\": \"repellendus\"
}"

Request      

PUT partners/{partner_partnerid}/team/{id}

PATCH partners/{partner_partnerid}/team/{id}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

partner_partnerid   integer   

Example: 20

id   string   

The ID of the team. Example: excepturi

Body Parameters

email   string   

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

access   string   

Example: repellendus

DELETE partners/{partner_partnerid}/team/{id}

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://localhost/partners/13/team/suscipit',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/partners/13/team/suscipit"
);

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

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
curl --request DELETE \
    "http://localhost/partners/13/team/suscipit" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

DELETE partners/{partner_partnerid}/team/{id}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

partner_partnerid   integer   

Example: 13

id   string   

The ID of the team. Example: suscipit

Profiles

GET project/{project}/profiles

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/project/accusantium/profiles',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'limit' => '5739902522586555179154367592120646723612516219697429793287358582992306405180',
            'page' => 'hzadjtsxhfxgxwikuhomxaptetgmswaehafpxmxtcuenfirgcndvrchmmqulbobocrpjnzqwvocyngcibggzypoz',
            'source' => 'qui',
            'orderBy' => 'mollitia',
            'full' => false,
            'activities' => true,
            'includeTotal' => false,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/accusantium/profiles"
);

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

let body = {
    "limit": "5739902522586555179154367592120646723612516219697429793287358582992306405180",
    "page": "hzadjtsxhfxgxwikuhomxaptetgmswaehafpxmxtcuenfirgcndvrchmmqulbobocrpjnzqwvocyngcibggzypoz",
    "source": "qui",
    "orderBy": "mollitia",
    "full": false,
    "activities": true,
    "includeTotal": false
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/project/accusantium/profiles" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"limit\": \"5739902522586555179154367592120646723612516219697429793287358582992306405180\",
    \"page\": \"hzadjtsxhfxgxwikuhomxaptetgmswaehafpxmxtcuenfirgcndvrchmmqulbobocrpjnzqwvocyngcibggzypoz\",
    \"source\": \"qui\",
    \"orderBy\": \"mollitia\",
    \"full\": false,
    \"activities\": true,
    \"includeTotal\": false
}"

Request      

GET project/{project}/profiles

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project   string   

The project. Example: accusantium

Body Parameters

limit   string  optional  

Must be between 1 and 100 digits. Example: 5739902522586555179154367592120646723612516219697429793287358582992306405180

page   string  optional  

Must be at least 1 character. Example: hzadjtsxhfxgxwikuhomxaptetgmswaehafpxmxtcuenfirgcndvrchmmqulbobocrpjnzqwvocyngcibggzypoz

source   string  optional  

Example: qui

fields   object  optional  
order   string  optional  
orderBy   string  optional  

Example: mollitia

full   boolean  optional  

Example: false

q   object  optional  
activities   boolean  optional  

Example: true

includeTotal   boolean  optional  

Example: false

GET project/{project_idsite}/profiles/{id}

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/project/5/profiles/maiores',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'full' => '0',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/5/profiles/maiores"
);

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

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/project/5/profiles/maiores?full=" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET project/{project_idsite}/profiles/{id}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 5

id   string   

The ID of the profile. Example: maiores

Query Parameters

full   boolean  optional  

Example: false

DELETE project/{project_idsite}/profiles/{id}

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://localhost/project/6/profiles/quis',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/6/profiles/quis"
);

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

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
curl --request DELETE \
    "http://localhost/project/6/profiles/quis" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

DELETE project/{project_idsite}/profiles/{id}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 6

id   string   

The ID of the profile. Example: quis

GET project/{project_idsite}/profiles/{profile_id}/timeline

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/project/18/profiles/quae/timeline',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/18/profiles/quae/timeline"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/project/18/profiles/quae/timeline" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET project/{project_idsite}/profiles/{profile_id}/timeline

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 18

profile_id   string   

The ID of the profile. Example: quae

GET project/{project_idsite}/profiles/alias/{source}/{profileid}

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/project/15/profiles/alias/sunt/ullam',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/15/profiles/alias/sunt/ullam"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/project/15/profiles/alias/sunt/ullam" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET project/{project_idsite}/profiles/alias/{source}/{profileid}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 15

source   string   

Example: sunt

profileid   string   

Example: ullam

POST project/{project_idsite}/profiles/alias

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/project/17/profiles/alias',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'profileid' => 'ipsa',
            'source' => 'maxime',
            'profile' => [
                'email' => 'xfunk@example.net',
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/17/profiles/alias"
);

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

let body = {
    "profileid": "ipsa",
    "source": "maxime",
    "profile": {
        "email": "xfunk@example.net"
    }
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request POST \
    "http://localhost/project/17/profiles/alias" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"profileid\": \"ipsa\",
    \"source\": \"maxime\",
    \"profile\": {
        \"email\": \"xfunk@example.net\"
    }
}"

Request      

POST project/{project_idsite}/profiles/alias

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 17

Body Parameters

profileid   string   

Example: ipsa

source   string   

Example: maxime

profile   object  optional  
name   string  optional  
email   string   

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

DELETE project/{project_idsite}/profiles/alias/{source}/{profileid}

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://localhost/project/18/profiles/alias/qui/deleniti',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/18/profiles/alias/qui/deleniti"
);

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

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
curl --request DELETE \
    "http://localhost/project/18/profiles/alias/qui/deleniti" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

DELETE project/{project_idsite}/profiles/alias/{source}/{profileid}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 18

source   string   

Example: qui

profileid   string   

Example: deleniti

PUT project/{project_idsite}/profiles/alias/{source}/{profileid}

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->put(
    'http://localhost/project/2/profiles/alias/ut/numquam',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'profile' => [
                'email' => 'branson01@example.com',
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/2/profiles/alias/ut/numquam"
);

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

let body = {
    "profile": {
        "email": "branson01@example.com"
    }
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request PUT \
    "http://localhost/project/2/profiles/alias/ut/numquam" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"profile\": {
        \"email\": \"branson01@example.com\"
    }
}"

Request      

PUT project/{project_idsite}/profiles/alias/{source}/{profileid}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 2

source   string   

Example: ut

profileid   string   

Example: numquam

Body Parameters

profile   object   
email   string  optional  

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

POST project/{project_idsite}/profiles/bulk

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/project/19/profiles/bulk',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'profiles' => [
                [
                    'profile' => [
                        'email' => 'stark.henriette@example.com',
                    ],
                ],
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/19/profiles/bulk"
);

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

let body = {
    "profiles": [
        {
            "profile": {
                "email": "stark.henriette@example.com"
            }
        }
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request POST \
    "http://localhost/project/19/profiles/bulk" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"profiles\": [
        {
            \"profile\": {
                \"email\": \"stark.henriette@example.com\"
            }
        }
    ]
}"

Request      

POST project/{project_idsite}/profiles/bulk

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 19

Body Parameters

profiles   string  optional  
profileid   string   

Example: alias

source   string   

Example: voluptates

profile   object  optional  
name   string  optional  
email   string   

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

Get Master Profile UUID.

requires authentication

Get a Master Profile from a visitorid.

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/project/12/visitors/nobis',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/12/visitors/nobis"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/project/12/visitors/nobis" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET project/{project_idsite}/visitors/{visitorid}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 12

visitorid   string   

Example: nobis

projectId   integer   

example: 123456 Example: 11

visitorId   string   

Example: c320e050fadafa84

DELETE project/{project_idsite}/visitors/{visitorid}

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://localhost/project/5/visitors/est',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/5/visitors/est"
);

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

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
curl --request DELETE \
    "http://localhost/project/5/visitors/est" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

DELETE project/{project_idsite}/visitors/{visitorid}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 5

visitorid   string   

Example: est

Project

GET project/{project_idsite}/sessions

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/project/18/sessions',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'period' => '2018-09-11',
            'cache' => '0',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/18/sessions"
);

const params = {
    "period": "2018-09-11",
    "cache": "0",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/project/18/sessions?period=2018-09-11&cache=" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET project/{project_idsite}/sessions

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 18

Query Parameters

period   string  optional  

Must be a valid date in the format Y-m. Must be a date before or equal to now. Example: 2018-09-11

cache   boolean  optional  

Example: false

GET project/{project_idsite}/stats

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/project/17/stats',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'from' => '2008-04-01',
            'to' => '2084-12-27',
            'cache' => '0',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/17/stats"
);

const params = {
    "from": "2008-04-01",
    "to": "2084-12-27",
    "cache": "0",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/project/17/stats?from=2008-04-01&to=2084-12-27&cache=" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET project/{project_idsite}/stats

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 17

Query Parameters

from   string   

Must be a valid date in the format Y-m-d. Must be a date before or equal to now. Example: 2008-04-01

to   string  optional  

Must be a valid date in the format Y-m-d. Must be a date after or equal to from. Example: 2084-12-27

cache   boolean  optional  

Example: false

POST project/{project_idsite}/churn

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/project/5/churn',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'type' => 'omnis',
            'restart' => 'placeat',
            'reason' => 'architecto',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/5/churn"
);

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

let body = {
    "type": "omnis",
    "restart": "placeat",
    "reason": "architecto"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request POST \
    "http://localhost/project/5/churn" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"type\": \"omnis\",
    \"restart\": \"placeat\",
    \"reason\": \"architecto\"
}"

Request      

POST project/{project_idsite}/churn

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 5

Body Parameters

type   string   

Example: omnis

restart   string   

Example: placeat

reason   string   

Example: architecto

GET project/{project_idsite}/source_priority

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/project/18/source_priority',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/18/source_priority"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/project/18/source_priority" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET project/{project_idsite}/source_priority

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 18

PUT project/{project_idsite}/source_priority

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->put(
    'http://localhost/project/2/source_priority',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'priority' => [],
            'enabled' => false,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/2/source_priority"
);

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

let body = {
    "priority": [],
    "enabled": false
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request PUT \
    "http://localhost/project/2/source_priority" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"priority\": [],
    \"enabled\": false
}"

Request      

PUT project/{project_idsite}/source_priority

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 2

Body Parameters

priority   object   
enabled   boolean   

Example: false

GET project/{project_idsite}/paymentmethod

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/project/20/paymentmethod',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/20/paymentmethod"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/project/20/paymentmethod" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET project/{project_idsite}/paymentmethod

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 20

PUT project/{project_idsite}/paymentmethod

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->put(
    'http://localhost/project/8/paymentmethod',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'IBAN' => 'voluptas',
            'accountName' => 'ut',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/8/paymentmethod"
);

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

let body = {
    "IBAN": "voluptas",
    "accountName": "ut"
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request PUT \
    "http://localhost/project/8/paymentmethod" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"IBAN\": \"voluptas\",
    \"accountName\": \"ut\"
}"

Request      

PUT project/{project_idsite}/paymentmethod

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 8

Body Parameters

IBAN   string   

Example: voluptas

accountName   string   

Example: ut

GET project/{id}

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/project/sed',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/sed"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/project/sed" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET project/{id}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

id   string   

The ID of the project. Example: sed

PUT project/{idsite}

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->put(
    'http://localhost/project/2',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'status' => 'harum',
            'mode' => 'tempore',
            'db_deleted' => 10,
            'theme' => '["consequuntur","est"]',
            'terms' => 15,
            'terms_sign_date' => '2024-03-07 12:00:52',
            'terms_sign_username' => 'llakin@example.net',
            'terms_sign_ip' => '180.215.132.194',
            'industry' => 'voluptatibus',
            'pixel_placed_date' => '2024-03-07 12:00:52',
            'teamleader_id' => 10,
            'ecommerce' => true,
            'name' => 'molestias',
            'main_url' => 'http://beier.info/possimus-rerum-qui-maxime-quis-enim.html',
            'timezone' => 'Asia/Kuching',
            'currency' => 'magni',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/2"
);

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

let body = {
    "status": "harum",
    "mode": "tempore",
    "db_deleted": 10,
    "theme": "[\"consequuntur\",\"est\"]",
    "terms": 15,
    "terms_sign_date": "2024-03-07 12:00:52",
    "terms_sign_username": "llakin@example.net",
    "terms_sign_ip": "180.215.132.194",
    "industry": "voluptatibus",
    "pixel_placed_date": "2024-03-07 12:00:52",
    "teamleader_id": 10,
    "ecommerce": true,
    "name": "molestias",
    "main_url": "http:\/\/beier.info\/possimus-rerum-qui-maxime-quis-enim.html",
    "timezone": "Asia\/Kuching",
    "currency": "magni"
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request PUT \
    "http://localhost/project/2" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"status\": \"harum\",
    \"mode\": \"tempore\",
    \"db_deleted\": 10,
    \"theme\": \"[\\\"consequuntur\\\",\\\"est\\\"]\",
    \"terms\": 15,
    \"terms_sign_date\": \"2024-03-07 12:00:52\",
    \"terms_sign_username\": \"llakin@example.net\",
    \"terms_sign_ip\": \"180.215.132.194\",
    \"industry\": \"voluptatibus\",
    \"pixel_placed_date\": \"2024-03-07 12:00:52\",
    \"teamleader_id\": 10,
    \"ecommerce\": true,
    \"name\": \"molestias\",
    \"main_url\": \"http:\\/\\/beier.info\\/possimus-rerum-qui-maxime-quis-enim.html\",
    \"timezone\": \"Asia\\/Kuching\",
    \"currency\": \"magni\"
}"

Request      

PUT project/{idsite}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

idsite   integer   

Example: 2

Body Parameters

settings   object  optional  
status   string  optional  

Example: harum

mode   string  optional  

Example: tempore

db_deleted   integer  optional  

Example: 10

theme   string  optional  

Must be a valid JSON string. Example: ["consequuntur","est"]

terms   integer  optional  

Example: 15

terms_sign_date   string  optional  

Must be a valid date in the format Y-m-d H:i:s. Example: 2024-03-07 12:00:52

terms_sign_username   string  optional  

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

terms_sign_ip   string  optional  

Must be a valid IP address. Example: 180.215.132.194

industry   string  optional  

Example: voluptatibus

pixel_placed_date   string  optional  

Must be a valid date in the format Y-m-d H:i:s. Example: 2024-03-07 12:00:52

teamleader_id   integer  optional  

Example: 10

ecommerce   boolean  optional  

Example: true

name   string  optional  

Example: molestias

main_url   string  optional  

Must be a valid URL. Example: http://beier.info/possimus-rerum-qui-maxime-quis-enim.html

timezone   string  optional  

Example: Asia/Kuching

currency   string  optional  

Example: magni

GET project/{project_idsite}/theme

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/project/2/theme',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/2/theme"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/project/2/theme" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET project/{project_idsite}/theme

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 2

PUT project/{project_idsite}/theme

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->put(
    'http://localhost/project/1/theme',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'theme' => [
                'settings' => [
                    'borderRadius' => 20,
                    'fontFamily' => 'rerum',
                    'colors' => [
                        'primary' => 'quidem',
                        'secondary' => 'explicabo',
                    ],
                ],
                'js' => 'vel',
                'css' => 'aliquid',
                'useSettings' => false,
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/1/theme"
);

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

let body = {
    "theme": {
        "settings": {
            "borderRadius": 20,
            "fontFamily": "rerum",
            "colors": {
                "primary": "quidem",
                "secondary": "explicabo"
            }
        },
        "js": "vel",
        "css": "aliquid",
        "useSettings": false
    }
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request PUT \
    "http://localhost/project/1/theme" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"theme\": {
        \"settings\": {
            \"borderRadius\": 20,
            \"fontFamily\": \"rerum\",
            \"colors\": {
                \"primary\": \"quidem\",
                \"secondary\": \"explicabo\"
            }
        },
        \"js\": \"vel\",
        \"css\": \"aliquid\",
        \"useSettings\": false
    }
}"

Request      

PUT project/{project_idsite}/theme

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 1

Body Parameters

theme   object  optional  
settings   object   
borderRadius   integer   

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

fontFamily   string   

Example: rerum

colors   object  optional  
primary   string   

Example: quidem

secondary   string   

Example: explicabo

js   string  optional  

Example: vel

css   string  optional  

Example: aliquid

useSettings   boolean  optional  

Example: false

PUT project/{project_idsite}/privacy

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->put(
    'http://localhost/project/13/privacy',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'privacy' => [],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/13/privacy"
);

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

let body = {
    "privacy": []
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request PUT \
    "http://localhost/project/13/privacy" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"privacy\": []
}"

Request      

PUT project/{project_idsite}/privacy

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 13

Body Parameters

privacy   object   

GET project/{project_idsite}/privacy

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/project/18/privacy',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/18/privacy"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/project/18/privacy" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET project/{project_idsite}/privacy

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 18

GET project

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/project',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'limit' => '10',
            'page' => '1',
            'order' => 'desc',
            'orderBy' => 'datetime',
            'filter[status]' => 'fugiat',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project"
);

const params = {
    "limit": "10",
    "page": "1",
    "order": "desc",
    "orderBy": "datetime",
    "filter[status]": "fugiat",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/project?limit=10&page=1&order=desc&orderBy=datetime&filter[status]=fugiat" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET project

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

limit   integer  optional  

Default: 10. Must not be greater than 100. Example: 10

page   integer  optional  

Must be at least 1. Example: 1

order   string  optional  

Default: desc. Must be one of asc or desc. Example: desc

orderBy   string  optional  

Default: datetime. Example: datetime

filter   object  optional  
filter.status   string  optional  

Example: fugiat

POST project

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/project',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'itaque',
            'main_url' => 'consequatur',
            'timezone' => 'Europe/Vaduz',
            'currency' => 'consequatur',
            'status' => 'pariatur',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project"
);

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

let body = {
    "name": "itaque",
    "main_url": "consequatur",
    "timezone": "Europe\/Vaduz",
    "currency": "consequatur",
    "status": "pariatur"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request POST \
    "http://localhost/project" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"itaque\",
    \"main_url\": \"consequatur\",
    \"timezone\": \"Europe\\/Vaduz\",
    \"currency\": \"consequatur\",
    \"status\": \"pariatur\"
}"

Request      

POST project

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Body Parameters

name   string   

Example: itaque

main_url   string   

Example: consequatur

timezone   string  optional  

Must be a valid time zone, such as Africa/Accra. Example: Europe/Vaduz

currency   string  optional  

Example: consequatur

status   string  optional  

Example: pariatur

settings   object  optional  

GET project/default

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/project/default',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/default"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/project/default" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET project/default

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

DELETE project/{project_idsite}

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://localhost/project/1',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/1"
);

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

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
curl --request DELETE \
    "http://localhost/project/1" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

DELETE project/{project_idsite}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 1

Remove a profile source.

requires authentication

Removes a given source from all master profiles. Also removes master profiles when only from this source. (async).

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://localhost/project/1/sources/et',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'source_validated' => 'eos',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/1/sources/et"
);

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

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

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
curl --request DELETE \
    "http://localhost/project/1/sources/et?source_validated=eos" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Example response (200, success):


{
 "message":"Profile source delete has been requested",
 "status":"200",
}

Request      

DELETE project/{project_idsite}/sources/{source}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 1

source   string   

The source. Example: et

Query Parameters

source_validated   string   

MD5 hash of the source, used for manual validation before deletion. Example: eos

ProjectBilling

GET project/{project_idsite}/billing

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/project/2/billing',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/2/billing"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/project/2/billing" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET project/{project_idsite}/billing

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 2

PUT project/{project_idsite}/billing

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->put(
    'http://localhost/project/10/billing',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'firstname' => 'enim',
            'lastname' => 'qui',
            'email' => 'breitenberg.patience@example.net',
            'phone' => 'fuga',
            'company_name' => 'dolor',
            'vat' => 'natus',
            'address_1' => 'autem',
            'postal_code' => 'quia',
            'city' => 'doloremque',
            'region' => 'ut',
            'country' => 'et',
            'zuoraId' => 'doloribus',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/10/billing"
);

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

let body = {
    "firstname": "enim",
    "lastname": "qui",
    "email": "breitenberg.patience@example.net",
    "phone": "fuga",
    "company_name": "dolor",
    "vat": "natus",
    "address_1": "autem",
    "postal_code": "quia",
    "city": "doloremque",
    "region": "ut",
    "country": "et",
    "zuoraId": "doloribus"
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request PUT \
    "http://localhost/project/10/billing" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"firstname\": \"enim\",
    \"lastname\": \"qui\",
    \"email\": \"breitenberg.patience@example.net\",
    \"phone\": \"fuga\",
    \"company_name\": \"dolor\",
    \"vat\": \"natus\",
    \"address_1\": \"autem\",
    \"postal_code\": \"quia\",
    \"city\": \"doloremque\",
    \"region\": \"ut\",
    \"country\": \"et\",
    \"zuoraId\": \"doloribus\"
}"

Request      

PUT project/{project_idsite}/billing

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 10

Body Parameters

firstname   string   

Example: enim

lastname   string   

Example: qui

email   string   

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

phone   string  optional  

Example: fuga

company_name   string   

Example: dolor

vat   string   

Example: natus

address_1   string   

Example: autem

postal_code   string   

Example: quia

city   string   

Example: doloremque

region   string  optional  

Example: ut

country   string   

Example: et

zuoraId   string  optional  

Example: doloribus

ProjectFieldsFunction

GET project/{project_idsite}/fieldFunctions

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/project/12/fieldFunctions',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'limit' => '10',
            'page' => '1',
            'order' => 'desc',
            'orderBy' => 'datetime',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/12/fieldFunctions"
);

const params = {
    "limit": "10",
    "page": "1",
    "order": "desc",
    "orderBy": "datetime",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/project/12/fieldFunctions?limit=10&page=1&order=desc&orderBy=datetime" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET project/{project_idsite}/fieldFunctions

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 12

Query Parameters

limit   integer  optional  

Default: 10. Must not be greater than 100. Example: 10

page   integer  optional  

Must be at least 1. Example: 1

order   string  optional  

Default: desc. Must be one of asc or desc. Example: desc

orderBy   string  optional  

Default: datetime. Example: datetime

POST project/{project_idsite}/fieldFunctions

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/project/18/fieldFunctions',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'ut',
            'function' => 'tempora',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/18/fieldFunctions"
);

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

let body = {
    "name": "ut",
    "function": "tempora"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request POST \
    "http://localhost/project/18/fieldFunctions" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"ut\",
    \"function\": \"tempora\"
}"

Request      

POST project/{project_idsite}/fieldFunctions

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 18

Body Parameters

name   string   

Example: ut

function   string   

Example: tempora

GET project/{project_idsite}/fieldFunctions/{id}

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/project/18/fieldFunctions/repellendus',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/18/fieldFunctions/repellendus"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/project/18/fieldFunctions/repellendus" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET project/{project_idsite}/fieldFunctions/{id}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 18

id   string   

The ID of the fieldFunction. Example: repellendus

PUT project/{project_idsite}/fieldFunctions/{id}

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->put(
    'http://localhost/project/12/fieldFunctions/dolorem',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'in',
            'function' => 'magnam',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/12/fieldFunctions/dolorem"
);

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

let body = {
    "name": "in",
    "function": "magnam"
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request PUT \
    "http://localhost/project/12/fieldFunctions/dolorem" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"in\",
    \"function\": \"magnam\"
}"

Request      

PUT project/{project_idsite}/fieldFunctions/{id}

PATCH project/{project_idsite}/fieldFunctions/{id}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 12

id   string   

The ID of the fieldFunction. Example: dolorem

Body Parameters

name   string   

Example: in

function   string  optional  

Example: magnam

DELETE project/{project_idsite}/fieldFunctions/{id}

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://localhost/project/6/fieldFunctions/quos',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/6/fieldFunctions/quos"
);

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

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
curl --request DELETE \
    "http://localhost/project/6/fieldFunctions/quos" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

DELETE project/{project_idsite}/fieldFunctions/{id}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 6

id   string   

The ID of the fieldFunction. Example: quos

ProjectInteraction

GET project/{project_idsite}/interactions

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/project/16/interactions',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'limit' => '10',
            'page' => '1',
            'order' => 'desc',
            'orderBy' => 'datetime',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/16/interactions"
);

const params = {
    "limit": "10",
    "page": "1",
    "order": "desc",
    "orderBy": "datetime",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/project/16/interactions?limit=10&page=1&order=desc&orderBy=datetime" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET project/{project_idsite}/interactions

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 16

Query Parameters

limit   integer  optional  

Default: 10. Must not be greater than 100. Example: 10

page   integer  optional  

Must be at least 1. Example: 1

order   string  optional  

Default: desc. Must be one of asc or desc. Example: desc

orderBy   string  optional  

Default: datetime. Example: datetime

POST project/{project_idsite}/interactions

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/project/15/interactions',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'interaction' => [],
            'interactionid' => 'dolore',
            'source' => 'omnis',
            'created' => '2024-03-07 12:00:54',
            'updated' => '2024-03-07 12:00:54',
            'dt_updated' => '2024-03-07 12:00:54',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/15/interactions"
);

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

let body = {
    "interaction": [],
    "interactionid": "dolore",
    "source": "omnis",
    "created": "2024-03-07 12:00:54",
    "updated": "2024-03-07 12:00:54",
    "dt_updated": "2024-03-07 12:00:54"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request POST \
    "http://localhost/project/15/interactions" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"interaction\": [],
    \"interactionid\": \"dolore\",
    \"source\": \"omnis\",
    \"created\": \"2024-03-07 12:00:54\",
    \"updated\": \"2024-03-07 12:00:54\",
    \"dt_updated\": \"2024-03-07 12:00:54\"
}"

Request      

POST project/{project_idsite}/interactions

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 15

Body Parameters

interaction   object   
interactionid   string  optional  

Example: dolore

source   string  optional  

Example: omnis

created   string  optional  

Must be a valid date in the format Y-m-d H:i:s. Example: 2024-03-07 12:00:54

updated   string  optional  

Must be a valid date in the format Y-m-d H:i:s. Example: 2024-03-07 12:00:54

dt_updated   string  optional  

Must be a valid date in the format Y-m-d H:i:s. Example: 2024-03-07 12:00:54

GET project/{project_idsite}/interactions/{id}

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/project/2/interactions/vero',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'source' => 'nam',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/2/interactions/vero"
);

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

let body = {
    "source": "nam"
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/project/2/interactions/vero" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"source\": \"nam\"
}"

Request      

GET project/{project_idsite}/interactions/{id}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 2

id   string   

The ID of the interaction. Example: vero

Body Parameters

source   string   

Example: nam

PUT project/{project_idsite}/interactions/{id}

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->put(
    'http://localhost/project/20/interactions/quod',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'interaction' => [],
            'objecttype' => 'accusamus',
            'source' => 'rerum',
            'interactionid' => 'inventore',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/20/interactions/quod"
);

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

let body = {
    "interaction": [],
    "objecttype": "accusamus",
    "source": "rerum",
    "interactionid": "inventore"
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request PUT \
    "http://localhost/project/20/interactions/quod" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"interaction\": [],
    \"objecttype\": \"accusamus\",
    \"source\": \"rerum\",
    \"interactionid\": \"inventore\"
}"

Request      

PUT project/{project_idsite}/interactions/{id}

PATCH project/{project_idsite}/interactions/{id}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 20

id   string   

The ID of the interaction. Example: quod

Body Parameters

interaction   object   
objecttype   string  optional  

Example: accusamus

source   string  optional  

Example: rerum

interactionid   string  optional  

Example: inventore

DELETE project/{project_idsite}/interactions/{id}

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://localhost/project/16/interactions/at',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'source' => 'magnam',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/16/interactions/at"
);

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

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

fetch(url, {
    method: "DELETE",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request DELETE \
    "http://localhost/project/16/interactions/at" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"source\": \"magnam\"
}"

Request      

DELETE project/{project_idsite}/interactions/{id}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 16

id   string   

The ID of the interaction. Example: at

Body Parameters

source   string   

Example: magnam

POST project/{project_idsite}/interactions/bulk

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/project/7/interactions/bulk',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'source' => 'perspiciatis',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/7/interactions/bulk"
);

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

let body = {
    "source": "perspiciatis"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request POST \
    "http://localhost/project/7/interactions/bulk" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"source\": \"perspiciatis\"
}"

Request      

POST project/{project_idsite}/interactions/bulk

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 7

Body Parameters

source   string  optional  

Example: perspiciatis

items   object  optional  

Reporting

GET project/{project_idsite}/reporting

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/project/3/reporting',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'from' => '2042-12-13',
            'to' => '2001-10-20',
            'period' => 'week',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/3/reporting"
);

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

let body = {
    "from": "2042-12-13",
    "to": "2001-10-20",
    "period": "week"
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/project/3/reporting" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"from\": \"2042-12-13\",
    \"to\": \"2001-10-20\",
    \"period\": \"week\"
}"

Request      

GET project/{project_idsite}/reporting

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 3

Body Parameters

from   string  optional  

This field is required when to is present. Must be a valid date in the format Y-m-d. Must be a date after -90 days. Example: 2042-12-13

to   string  optional  

This field is required when from is present. Must be a valid date in the format Y-m-d. Must be a date after or equal to from. Must be a date before tomorrow. Example: 2001-10-20

period   string  optional  

Must be one of week, month, or quarter. Example: week

GET project/{project_idsite}/reporting/touchpoints

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/project/13/reporting/touchpoints',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'from' => '2024-03-07',
            'to' => '2024-04-24',
            'status' => 'active',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/13/reporting/touchpoints"
);

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

let body = {
    "from": "2024-03-07",
    "to": "2024-04-24",
    "status": "active"
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/project/13/reporting/touchpoints" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"from\": \"2024-03-07\",
    \"to\": \"2024-04-24\",
    \"status\": \"active\"
}"

Request      

GET project/{project_idsite}/reporting/touchpoints

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 13

Body Parameters

from   string  optional  

This field is required when to is present. Must be a valid date in the format Y-m-d. Example: 2024-03-07

to   string  optional  

This field is required when from is present. Must be a valid date in the format Y-m-d. Must be a date before tomorrow. Must be a date after or equal to from. Example: 2024-04-24

status   string  optional  

Must be one of active or draft. Example: active

GET project/{project_idsite}/reporting/unsubscribed

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/project/8/reporting/unsubscribed',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'from' => '2024-03-07',
            'to' => '2038-02-08',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/8/reporting/unsubscribed"
);

const params = {
    "from": "2024-03-07",
    "to": "2038-02-08",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/project/8/reporting/unsubscribed?from=2024-03-07&to=2038-02-08" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET project/{project_idsite}/reporting/unsubscribed

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 8

Query Parameters

from   string  optional  

This field is required when to is present. Must be a valid date in the format Y-m-d. Example: 2024-03-07

to   string  optional  

This field is required when from is present. Must be a valid date in the format Y-m-d. Must be a date before tomorrow. Must be a date after or equal to from. Example: 2038-02-08

Scorecards

POST project/{project_idsite}/scorecard/bulk

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/project/19/scorecard/bulk',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/19/scorecard/bulk"
);

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

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());
curl --request POST \
    "http://localhost/project/19/scorecard/bulk" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \

Request      

POST project/{project_idsite}/scorecard/bulk

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 19

Body Parameters

items   string  optional  
source   string  optional  

Example: debitis

scorecardkey   string  optional  

Example: consequatur

scorecardtype   string  optional  

Example: voluptate

data   object  optional  

Get an overview of scorecards.

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/project/13/scorecard',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'limit' => '100',
            'page' => '5',
            'sort' => 'updated',
            'order' => 'desc or asc',
            'period' => 'daily or weekly',
            'date[0]' => '2024-03-07',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/13/scorecard"
);

const params = {
    "limit": "100",
    "page": "5",
    "sort": "updated",
    "order": "desc or asc",
    "period": "daily or weekly",
    "date[0]": "2024-03-07",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/project/13/scorecard?limit=100&page=5&sort=updated&order=desc+or+asc&period=daily+or+weekly&date[]=2024-03-07" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET project/{project_idsite}/scorecard

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 13

Query Parameters

limit   integer  optional  

The max amount of items that will be returned, default 500 Example: 100

page   integer  optional  

The current page number Example: 5

sort   string  optional  

The default field which is used to sort the result set, default date Example: updated

order   string  optional  

The order value that we want to use Example: desc or asc

period   string  optional  

The identifier for the period that you are looking for Example: daily or weekly

date   string[]  optional  

Must be a valid date in the format Y-m-d.

date.gte   string  optional  

The gte date that is used to filter the scorecard results Example: ['date' => ['gte' => '2023-06-12']]

date.lte   string  optional  

The lte date that is used to filter the scorecard results Example: ['date' => ['lte' => '2023-06-18']]

POST project/{project_idsite}/scorecard

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/project/5/scorecard',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'source' => 'maiores',
            'scorecardkey' => 'et',
            'scorecardtype' => 'quia',
            'period' => 'voluptatum',
            'date' => '2024-03-07 12:00:53',
            'updated' => '2024-03-07 12:00:53',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/5/scorecard"
);

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

let body = {
    "source": "maiores",
    "scorecardkey": "et",
    "scorecardtype": "quia",
    "period": "voluptatum",
    "date": "2024-03-07 12:00:53",
    "updated": "2024-03-07 12:00:53"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request POST \
    "http://localhost/project/5/scorecard" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"source\": \"maiores\",
    \"scorecardkey\": \"et\",
    \"scorecardtype\": \"quia\",
    \"period\": \"voluptatum\",
    \"date\": \"2024-03-07 12:00:53\",
    \"updated\": \"2024-03-07 12:00:53\"
}"

Request      

POST project/{project_idsite}/scorecard

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 5

Body Parameters

source   string  optional  

Example: maiores

scorecardkey   string  optional  

Example: et

scorecardtype   string  optional  

Example: quia

period   string  optional  

Example: voluptatum

date   string  optional  

Must be a valid date in the format Y-m-d H:i:s. Example: 2024-03-07 12:00:53

updated   string  optional  

Must be a valid date in the format Y-m-d H:i:s. Example: 2024-03-07 12:00:53

data   object  optional  

GET project/{project_idsite}/scorecard/{scorecardkey}

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/project/1/scorecard/mollitia',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/1/scorecard/mollitia"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/project/1/scorecard/mollitia" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET project/{project_idsite}/scorecard/{scorecardkey}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 1

scorecardkey   string   

Example: mollitia

DELETE project/{project_idsite}/scorecard/{scorecardkey}

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://localhost/project/18/scorecard/quia',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/18/scorecard/quia"
);

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

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
curl --request DELETE \
    "http://localhost/project/18/scorecard/quia" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

DELETE project/{project_idsite}/scorecard/{scorecardkey}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 18

scorecardkey   string   

Example: quia

Segments

GET project/{project_idsite}/segments/{segment_segmentid}/status

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/project/14/segments/rerum/status',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/14/segments/rerum/status"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/project/14/segments/rerum/status" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET project/{project_idsite}/segments/{segment_segmentid}/status

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 14

segment_segmentid   string   

Example: rerum

GET project/{project_idsite}/segments/{segment_segmentid}/profiles

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/project/11/segments/eos/profiles',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'limit' => '10',
            'page' => '1',
            'order' => 'desc',
            'orderBy' => 'datetime',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/11/segments/eos/profiles"
);

const params = {
    "limit": "10",
    "page": "1",
    "order": "desc",
    "orderBy": "datetime",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/project/11/segments/eos/profiles?limit=10&page=1&order=desc&orderBy=datetime" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET project/{project_idsite}/segments/{segment_segmentid}/profiles

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 11

segment_segmentid   string   

Example: eos

Query Parameters

limit   integer  optional  

Default: 10. Must not be greater than 100. Example: 10

page   integer  optional  

Must be at least 1. Example: 1

order   string  optional  

Default: desc. Must be one of asc or desc. Example: desc

orderBy   string  optional  

Default: datetime. Example: datetime

q   object  optional  

POST project/{project_idsite}/segments/{segment_segmentid}/rebuild

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/project/17/segments/qui/rebuild',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/17/segments/qui/rebuild"
);

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

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());
curl --request POST \
    "http://localhost/project/17/segments/qui/rebuild" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

POST project/{project_idsite}/segments/{segment_segmentid}/rebuild

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 17

segment_segmentid   string   

Example: qui

GET project/{project_idsite}/segments

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/project/6/segments',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'include_default' => '1',
            'cache' => '1',
            'stats' => '1',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/6/segments"
);

const params = {
    "include_default": "1",
    "cache": "1",
    "stats": "1",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/project/6/segments?include_default=1&cache=1&stats=1" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET project/{project_idsite}/segments

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 6

Query Parameters

include_default   boolean  optional  

Example: true

cache   boolean  optional  

Example: true

stats   boolean  optional  

Example: true

GET project/{project_idsite}/segments/{segmentid}

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/project/10/segments/quas',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/10/segments/quas"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/project/10/segments/quas" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET project/{project_idsite}/segments/{segmentid}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 10

segmentid   string   

Example: quas

Update a segment.

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->put(
    'http://localhost/project/14/segments/nihil',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'quo',
            'source' => 'dignissimos',
            'status' => false,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/14/segments/nihil"
);

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

let body = {
    "name": "quo",
    "source": "dignissimos",
    "status": false
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request PUT \
    "http://localhost/project/14/segments/nihil" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"quo\",
    \"source\": \"dignissimos\",
    \"status\": false
}"

Request      

PUT project/{project_idsite}/segments/{segmentid}

PATCH project/{project_idsite}/segments/{segmentid}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 14

segmentid   string   

Example: nihil

Body Parameters

name   string   

Example: quo

source   string  optional  

Example: dignissimos

status   boolean  optional  

Example: false

settings   object  optional  
rules   object  optional  

DELETE project/{project_idsite}/segments/{segmentid}

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://localhost/project/12/segments/ad',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/12/segments/ad"
);

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

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
curl --request DELETE \
    "http://localhost/project/12/segments/ad" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

DELETE project/{project_idsite}/segments/{segmentid}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 12

segmentid   string   

Example: ad

GET project/{project_idsite}/segment/stats

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/project/7/segment/stats',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'segmentid' => 'ex',
            'fields' => 'et',
            'timeout' => 'et',
            'removecache' => '0',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/7/segment/stats"
);

const params = {
    "segmentid": "ex",
    "fields": "et",
    "timeout": "et",
    "removecache": "0",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/project/7/segment/stats?segmentid=ex&fields=et&timeout=et&removecache=" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET project/{project_idsite}/segment/stats

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 7

Query Parameters

segmentid   string  optional  

Example: ex

fields   string  optional  

Example: et

timeout   string  optional  

Example: et

removecache   boolean  optional  

Example: false

GET project/{project_idsite}/segment/stats/history

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/project/1/segment/stats/history',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'from' => '2024-03-07',
            'to' => '2060-03-29',
            'segment' => 'voluptas',
            'current' => '1',
            'removecache' => '1',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/1/segment/stats/history"
);

const params = {
    "from": "2024-03-07",
    "to": "2060-03-29",
    "segment": "voluptas",
    "current": "1",
    "removecache": "1",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/project/1/segment/stats/history?from=2024-03-07&to=2060-03-29&segment=voluptas&current=1&removecache=1" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET project/{project_idsite}/segment/stats/history

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 1

Query Parameters

from   string  optional  

Must be a valid date in the format Y-m-d. Example: 2024-03-07

to   string  optional  

Must be a valid date in the format Y-m-d. Must be a date after from. Example: 2060-03-29

segment   string  optional  

Example: voluptas

current   boolean  optional  

Example: true

removecache   boolean  optional  

Example: true

Create a new segment.

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/project/5/segments',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'sapiente',
            'source' => 'officia',
            'status' => true,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/5/segments"
);

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

let body = {
    "name": "sapiente",
    "source": "officia",
    "status": true
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request POST \
    "http://localhost/project/5/segments" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"sapiente\",
    \"source\": \"officia\",
    \"status\": true
}"

Request      

POST project/{project_idsite}/segments

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 5

Body Parameters

name   string   

Example: sapiente

source   string  optional  

Example: officia

status   boolean  optional  

Example: true

settings   object  optional  
rules   object  optional  

Teams

GET project/{project_idsite}/team

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/project/18/team',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'limit' => '10',
            'page' => '1',
            'order' => 'desc',
            'orderBy' => 'datetime',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/18/team"
);

const params = {
    "limit": "10",
    "page": "1",
    "order": "desc",
    "orderBy": "datetime",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/project/18/team?limit=10&page=1&order=desc&orderBy=datetime" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET project/{project_idsite}/team

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 18

Query Parameters

limit   integer  optional  

Default: 10. Must not be greater than 100. Example: 10

page   integer  optional  

Must be at least 1. Example: 1

order   string  optional  

Default: desc. Must be one of asc or desc. Example: desc

orderBy   string  optional  

Default: datetime. Example: datetime

POST project/{project_idsite}/team

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/project/8/team',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'email' => 'mandy.wuckert@example.org',
            'access' => 'nam',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/8/team"
);

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

let body = {
    "email": "mandy.wuckert@example.org",
    "access": "nam"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request POST \
    "http://localhost/project/8/team" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"email\": \"mandy.wuckert@example.org\",
    \"access\": \"nam\"
}"

Request      

POST project/{project_idsite}/team

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 8

Body Parameters

email   string   

Example: mandy.wuckert@example.org

access   string  optional  

Example: nam

GET project/{project_idsite}/team/{id}

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/project/4/team/aliquam',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/4/team/aliquam"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/project/4/team/aliquam" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET project/{project_idsite}/team/{id}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 4

id   string   

The ID of the team. Example: aliquam

PUT project/{project_idsite}/team/{id}

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->put(
    'http://localhost/project/3/team/eos',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'access' => 'placeat',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/3/team/eos"
);

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

let body = {
    "access": "placeat"
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request PUT \
    "http://localhost/project/3/team/eos" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"access\": \"placeat\"
}"

Request      

PUT project/{project_idsite}/team/{id}

PATCH project/{project_idsite}/team/{id}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 3

id   string   

The ID of the team. Example: eos

Body Parameters

access   string  optional  

Example: placeat

DELETE project/{project_idsite}/team/{id}

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://localhost/project/14/team/explicabo',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/14/team/explicabo"
);

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

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
curl --request DELETE \
    "http://localhost/project/14/team/explicabo" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

DELETE project/{project_idsite}/team/{id}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 14

id   string   

The ID of the team. Example: explicabo

Template Carousel

GET project/{project_idsite}/templates/carousel

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/project/3/templates/carousel',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'limit' => '10',
            'page' => '1',
            'order' => 'desc',
            'orderBy' => 'datetime',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/3/templates/carousel"
);

const params = {
    "limit": "10",
    "page": "1",
    "order": "desc",
    "orderBy": "datetime",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/project/3/templates/carousel?limit=10&page=1&order=desc&orderBy=datetime" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET project/{project_idsite}/templates/carousel

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 3

Query Parameters

limit   integer  optional  

Default: 10. Must not be greater than 100. Example: 10

page   integer  optional  

Must be at least 1. Example: 1

order   string  optional  

Default: desc. Must be one of asc or desc. Example: desc

orderBy   string  optional  

Default: datetime. Example: datetime

POST project/{project_idsite}/templates/carousel

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/project/11/templates/carousel',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'deserunt',
            'settings' => [
                'second' => 0.79,
                'type' => 'ut',
                'slide' => 'laudantium',
                'arrow_position' => 'facilis',
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/11/templates/carousel"
);

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

let body = {
    "name": "deserunt",
    "settings": {
        "second": 0.79,
        "type": "ut",
        "slide": "laudantium",
        "arrow_position": "facilis"
    }
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request POST \
    "http://localhost/project/11/templates/carousel" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"deserunt\",
    \"settings\": {
        \"second\": 0.79,
        \"type\": \"ut\",
        \"slide\": \"laudantium\",
        \"arrow_position\": \"facilis\"
    }
}"

Request      

POST project/{project_idsite}/templates/carousel

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 11

Body Parameters

name   string   

Example: deserunt

settings   object  optional  
second   number  optional  

Example: 0.79

type   string   

Example: ut

slide   string  optional  

Example: laudantium

arrow_position   string  optional  

Example: facilis

GET project/{project_idsite}/templates/carousel/{id}

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/project/9/templates/carousel/2',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/9/templates/carousel/2"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/project/9/templates/carousel/2" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET project/{project_idsite}/templates/carousel/{id}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 9

id   integer   

The ID of the carousel. Example: 2

PUT project/{project_idsite}/templates/carousel/{id}

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->put(
    'http://localhost/project/16/templates/carousel/5',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'cupiditate',
            'settings' => [
                'second' => 342741.7383293,
                'type' => 'deleniti',
                'slide' => 'totam',
                'arrow_position' => 'quo',
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/16/templates/carousel/5"
);

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

let body = {
    "name": "cupiditate",
    "settings": {
        "second": 342741.7383293,
        "type": "deleniti",
        "slide": "totam",
        "arrow_position": "quo"
    }
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request PUT \
    "http://localhost/project/16/templates/carousel/5" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"cupiditate\",
    \"settings\": {
        \"second\": 342741.7383293,
        \"type\": \"deleniti\",
        \"slide\": \"totam\",
        \"arrow_position\": \"quo\"
    }
}"

Request      

PUT project/{project_idsite}/templates/carousel/{id}

PATCH project/{project_idsite}/templates/carousel/{id}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 16

id   integer   

The ID of the carousel. Example: 5

Body Parameters

name   string   

Example: cupiditate

settings   object  optional  
second   number  optional  

Example: 342741.7383293

type   string   

Example: deleniti

slide   string  optional  

Example: totam

arrow_position   string  optional  

Example: quo

DELETE project/{project_idsite}/templates/carousel/{id}

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://localhost/project/10/templates/carousel/7',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/10/templates/carousel/7"
);

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

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
curl --request DELETE \
    "http://localhost/project/10/templates/carousel/7" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

DELETE project/{project_idsite}/templates/carousel/{id}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 10

id   integer   

The ID of the carousel. Example: 7

Template Conversational

GET project/{project_idsite}/templates/conversational

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/project/10/templates/conversational',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'limit' => '10',
            'page' => '1',
            'order' => 'desc',
            'orderBy' => 'datetime',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/10/templates/conversational"
);

const params = {
    "limit": "10",
    "page": "1",
    "order": "desc",
    "orderBy": "datetime",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/project/10/templates/conversational?limit=10&page=1&order=desc&orderBy=datetime" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET project/{project_idsite}/templates/conversational

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 10

Query Parameters

limit   integer  optional  

Default: 10. Must not be greater than 100. Example: 10

page   integer  optional  

Must be at least 1. Example: 1

order   string  optional  

Default: desc. Must be one of asc or desc. Example: desc

orderBy   string  optional  

Default: datetime. Example: datetime

POST project/{project_idsite}/templates/conversational

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/project/10/templates/conversational',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'repudiandae',
            'settings' => [
                'name' => 'repellat',
                'type' => 'rerum',
                'color' => 'rerum',
                'style' => 'perferendis',
                'size' => 'labore',
                'image' => 'est',
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/10/templates/conversational"
);

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

let body = {
    "name": "repudiandae",
    "settings": {
        "name": "repellat",
        "type": "rerum",
        "color": "rerum",
        "style": "perferendis",
        "size": "labore",
        "image": "est"
    }
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request POST \
    "http://localhost/project/10/templates/conversational" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"repudiandae\",
    \"settings\": {
        \"name\": \"repellat\",
        \"type\": \"rerum\",
        \"color\": \"rerum\",
        \"style\": \"perferendis\",
        \"size\": \"labore\",
        \"image\": \"est\"
    }
}"

Request      

POST project/{project_idsite}/templates/conversational

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 10

Body Parameters

name   string   

Example: repudiandae

settings   object   
name   string   

Example: repellat

type   string   

Example: rerum

color   string  optional  

Example: rerum

style   string  optional  

Example: perferendis

size   string  optional  

Example: labore

image   string  optional  

Example: est

GET project/{project_idsite}/templates/conversational/{id}

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/project/8/templates/conversational/19',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/8/templates/conversational/19"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/project/8/templates/conversational/19" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET project/{project_idsite}/templates/conversational/{id}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 8

id   integer   

The ID of the conversational. Example: 19

PUT project/{project_idsite}/templates/conversational/{id}

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->put(
    'http://localhost/project/12/templates/conversational/7',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'deleniti',
            'settings' => [
                'name' => 'libero',
                'type' => 'non',
                'color' => 'laborum',
                'style' => 'illo',
                'size' => 'omnis',
                'image' => 'eos',
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/12/templates/conversational/7"
);

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

let body = {
    "name": "deleniti",
    "settings": {
        "name": "libero",
        "type": "non",
        "color": "laborum",
        "style": "illo",
        "size": "omnis",
        "image": "eos"
    }
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request PUT \
    "http://localhost/project/12/templates/conversational/7" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"deleniti\",
    \"settings\": {
        \"name\": \"libero\",
        \"type\": \"non\",
        \"color\": \"laborum\",
        \"style\": \"illo\",
        \"size\": \"omnis\",
        \"image\": \"eos\"
    }
}"

Request      

PUT project/{project_idsite}/templates/conversational/{id}

PATCH project/{project_idsite}/templates/conversational/{id}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 12

id   integer   

The ID of the conversational. Example: 7

Body Parameters

name   string   

Example: deleniti

settings   object   
name   string   

Example: libero

type   string   

Example: non

color   string  optional  

Example: laborum

style   string  optional  

Example: illo

size   string  optional  

Example: omnis

image   string  optional  

Example: eos

DELETE project/{project_idsite}/templates/conversational/{id}

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://localhost/project/3/templates/conversational/14',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/3/templates/conversational/14"
);

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

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
curl --request DELETE \
    "http://localhost/project/3/templates/conversational/14" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

DELETE project/{project_idsite}/templates/conversational/{id}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 3

id   integer   

The ID of the conversational. Example: 14

Template Positions

POST project/{project_idsite}/positions/{position_positionId}/copy

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/project/12/positions/16/copy',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'projectId' => 'rerum',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/12/positions/16/copy"
);

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

let body = {
    "projectId": "rerum"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request POST \
    "http://localhost/project/12/positions/16/copy" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"projectId\": \"rerum\"
}"

Request      

POST project/{project_idsite}/positions/{position_positionId}/copy

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 12

position_positionId   integer   

Example: 16

Body Parameters

projectId   string   

Example: rerum

GET project/{project_idsite}/templates/positions

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/project/2/templates/positions',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'limit' => '7208724661126846783166215251597857657906509608529352341575775136061976424894235354655963373210430792959259294399537675567569317848195406936218797323822969323998998239679558312633852001807061274870451629367764952470190762767284157968930094127879537153555876517997212230574416944787452204523654825685123112614399660150971242077113221764130202750874300863081181896867162000744080827555411921952885141210571720387498886794925492639414191619964195018589433537383729885639728921432807869124641542917281706948064797406958530184453774276884278160685496230079972777888959818518314315172857335869797787077056344119438421760105897687620715862089377239819307829321877101581518449595006816261154139106502062957926255365608547971647094202839745586294020308151262399870284006545383990911696592155709084482424552891078',
            'page' => 58,
            'order' => 'desc',
            'orderBy' => 'created',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/2/templates/positions"
);

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

let body = {
    "limit": "7208724661126846783166215251597857657906509608529352341575775136061976424894235354655963373210430792959259294399537675567569317848195406936218797323822969323998998239679558312633852001807061274870451629367764952470190762767284157968930094127879537153555876517997212230574416944787452204523654825685123112614399660150971242077113221764130202750874300863081181896867162000744080827555411921952885141210571720387498886794925492639414191619964195018589433537383729885639728921432807869124641542917281706948064797406958530184453774276884278160685496230079972777888959818518314315172857335869797787077056344119438421760105897687620715862089377239819307829321877101581518449595006816261154139106502062957926255365608547971647094202839745586294020308151262399870284006545383990911696592155709084482424552891078",
    "page": 58,
    "order": "desc",
    "orderBy": "created"
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/project/2/templates/positions" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"limit\": \"7208724661126846783166215251597857657906509608529352341575775136061976424894235354655963373210430792959259294399537675567569317848195406936218797323822969323998998239679558312633852001807061274870451629367764952470190762767284157968930094127879537153555876517997212230574416944787452204523654825685123112614399660150971242077113221764130202750874300863081181896867162000744080827555411921952885141210571720387498886794925492639414191619964195018589433537383729885639728921432807869124641542917281706948064797406958530184453774276884278160685496230079972777888959818518314315172857335869797787077056344119438421760105897687620715862089377239819307829321877101581518449595006816261154139106502062957926255365608547971647094202839745586294020308151262399870284006545383990911696592155709084482424552891078\",
    \"page\": 58,
    \"order\": \"desc\",
    \"orderBy\": \"created\"
}"

Request      

GET project/{project_idsite}/templates/positions

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 2

Body Parameters

limit   string  optional  

Must be between 1 and 1000 digits. Example: 7208724661126846783166215251597857657906509608529352341575775136061976424894235354655963373210430792959259294399537675567569317848195406936218797323822969323998998239679558312633852001807061274870451629367764952470190762767284157968930094127879537153555876517997212230574416944787452204523654825685123112614399660150971242077113221764130202750874300863081181896867162000744080827555411921952885141210571720387498886794925492639414191619964195018589433537383729885639728921432807869124641542917281706948064797406958530184453774276884278160685496230079972777888959818518314315172857335869797787077056344119438421760105897687620715862089377239819307829321877101581518449595006816261154139106502062957926255365608547971647094202839745586294020308151262399870284006545383990911696592155709084482424552891078

page   integer  optional  

Must be at least 1. Example: 58

order   string  optional  

Must be one of asc or desc. Example: desc

orderBy   string  optional  

Must be one of created, updated, name, or type. Example: created

POST project/{project_idsite}/templates/positions

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/project/19/templates/positions',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'toaylnpptk',
            'type' => 'crq',
            'settings' => [],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/19/templates/positions"
);

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

let body = {
    "name": "toaylnpptk",
    "type": "crq",
    "settings": []
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request POST \
    "http://localhost/project/19/templates/positions" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"toaylnpptk\",
    \"type\": \"crq\",
    \"settings\": []
}"

Request      

POST project/{project_idsite}/templates/positions

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 19

Body Parameters

name   string   

Must not be greater than 50 characters. Example: toaylnpptk

type   string   

Must not be greater than 50 characters. Example: crq

tags   object  optional  
settings   object   

GET project/{project_idsite}/templates/positions/{positionId}

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/project/20/templates/positions/18',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/20/templates/positions/18"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/project/20/templates/positions/18" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET project/{project_idsite}/templates/positions/{positionId}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 20

positionId   integer   

Example: 18

PUT project/{project_idsite}/templates/positions/{positionId}

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->put(
    'http://localhost/project/13/templates/positions/4',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'swcxehhacjuomtinmoi',
            'type' => 'nfxkfdrpfqllmsywuwrzoob',
            'settings' => [],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/13/templates/positions/4"
);

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

let body = {
    "name": "swcxehhacjuomtinmoi",
    "type": "nfxkfdrpfqllmsywuwrzoob",
    "settings": []
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request PUT \
    "http://localhost/project/13/templates/positions/4" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"swcxehhacjuomtinmoi\",
    \"type\": \"nfxkfdrpfqllmsywuwrzoob\",
    \"settings\": []
}"

Request      

PUT project/{project_idsite}/templates/positions/{positionId}

PATCH project/{project_idsite}/templates/positions/{positionId}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 13

positionId   integer   

Example: 4

Body Parameters

name   string   

Must not be greater than 50 characters. Example: swcxehhacjuomtinmoi

type   string   

Must not be greater than 50 characters. Example: nfxkfdrpfqllmsywuwrzoob

tags   object  optional  
settings   object   

DELETE project/{project_idsite}/templates/positions/{positionId}

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://localhost/project/12/templates/positions/7',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/12/templates/positions/7"
);

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

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
curl --request DELETE \
    "http://localhost/project/12/templates/positions/7" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

DELETE project/{project_idsite}/templates/positions/{positionId}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 12

positionId   integer   

Example: 7

Template Settings

GET project/{project_idsite}/templates/defaults

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/project/1/templates/defaults',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/1/templates/defaults"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/project/1/templates/defaults" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET project/{project_idsite}/templates/defaults

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 1

PUT project/{project_idsite}/templates/defaults

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->put(
    'http://localhost/project/4/templates/defaults',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'profileId' => 'd',
            'productId' => 'ut',
            'product_source' => 'non',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/4/templates/defaults"
);

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

let body = {
    "profileId": "d",
    "productId": "ut",
    "product_source": "non"
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request PUT \
    "http://localhost/project/4/templates/defaults" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"profileId\": \"d\",
    \"productId\": \"ut\",
    \"product_source\": \"non\"
}"

Request      

PUT project/{project_idsite}/templates/defaults

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 4

Body Parameters

profileId   string  optional  

This field is required when none of productId and product_source are present. Must not be greater than 36 characters. Example: d

productId   string  optional  

This field is required when profileId is not present. This field is required when product_source is present. Example: ut

product_source   string  optional  

This field is required when profileId is not present. This field is required when productId is present. Example: non

Templates

POST project/{project_idsite}/templates/{template_templateId}/copy

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/project/19/templates/19/copy',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'projectId' => 'molestias',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/19/templates/19/copy"
);

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

let body = {
    "projectId": "molestias"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request POST \
    "http://localhost/project/19/templates/19/copy" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"projectId\": \"molestias\"
}"

Request      

POST project/{project_idsite}/templates/{template_templateId}/copy

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 19

template_templateId   integer   

Example: 19

Body Parameters

projectId   string   

Example: molestias

GET project/{project_idsite}/templates

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/project/7/templates',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'limit' => '10',
            'page' => '1',
            'order' => 'desc',
            'orderBy' => 'datetime',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/7/templates"
);

const params = {
    "limit": "10",
    "page": "1",
    "order": "desc",
    "orderBy": "datetime",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/project/7/templates?limit=10&page=1&order=desc&orderBy=datetime" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET project/{project_idsite}/templates

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 7

Query Parameters

limit   string  optional  

Default: 10. Must be between 1 and 1000 digits. Example: 10

page   string  optional  

Must be at least 1 character. Example: 1

order   string  optional  

Default: desc. Must be one of asc or desc. Example: desc

orderBy   string  optional  

Default: datetime. Example: datetime

POST project/{project_idsite}/templates

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/project/7/templates',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'rsoivmrmci',
            'channel' => 'qui',
            'settings' => [],
            'is_active' => false,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/7/templates"
);

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

let body = {
    "name": "rsoivmrmci",
    "channel": "qui",
    "settings": [],
    "is_active": false
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request POST \
    "http://localhost/project/7/templates" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"rsoivmrmci\",
    \"channel\": \"qui\",
    \"settings\": [],
    \"is_active\": false
}"

Request      

POST project/{project_idsite}/templates

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 7

Body Parameters

name   string   

Must not be greater than 255 characters. Example: rsoivmrmci

channel   string   

Example: qui

tags   object  optional  
settings   object   
is_active   boolean  optional  

Example: false

GET project/{project_idsite}/templates/{}

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/project/6/templates/praesentium',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/6/templates/praesentium"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/project/6/templates/praesentium" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET project/{project_idsite}/templates/{}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 6

   string   

Example: praesentium

PUT project/{project_idsite}/templates/{}

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->put(
    'http://localhost/project/15/templates/nisi',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'zy',
            'channel' => 'explicabo',
            'settings' => [],
            'is_active' => true,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/15/templates/nisi"
);

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

let body = {
    "name": "zy",
    "channel": "explicabo",
    "settings": [],
    "is_active": true
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request PUT \
    "http://localhost/project/15/templates/nisi" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"zy\",
    \"channel\": \"explicabo\",
    \"settings\": [],
    \"is_active\": true
}"

Request      

PUT project/{project_idsite}/templates/{}

PATCH project/{project_idsite}/templates/{}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 15

   string   

Example: nisi

Body Parameters

name   string   

Must not be greater than 255 characters. Example: zy

channel   string   

Example: explicabo

tags   object  optional  
settings   object   
is_active   boolean  optional  

Example: true

DELETE project/{project_idsite}/templates/{}

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://localhost/project/4/templates/necessitatibus',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/4/templates/necessitatibus"
);

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

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
curl --request DELETE \
    "http://localhost/project/4/templates/necessitatibus" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

DELETE project/{project_idsite}/templates/{}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 4

   string   

Example: necessitatibus

GET project/{project_idsite}/templates/{templateId}

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/project/13/templates/19',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/13/templates/19"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/project/13/templates/19" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET project/{project_idsite}/templates/{templateId}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 13

templateId   integer   

Example: 19

PUT project/{project_idsite}/templates/{templateId}

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->put(
    'http://localhost/project/13/templates/1',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'hxhkiplqvjlqowtle',
            'channel' => 'qui',
            'settings' => [],
            'is_active' => false,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/13/templates/1"
);

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

let body = {
    "name": "hxhkiplqvjlqowtle",
    "channel": "qui",
    "settings": [],
    "is_active": false
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request PUT \
    "http://localhost/project/13/templates/1" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"hxhkiplqvjlqowtle\",
    \"channel\": \"qui\",
    \"settings\": [],
    \"is_active\": false
}"

Request      

PUT project/{project_idsite}/templates/{templateId}

PATCH project/{project_idsite}/templates/{templateId}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 13

templateId   integer   

Example: 1

Body Parameters

name   string   

Must not be greater than 255 characters. Example: hxhkiplqvjlqowtle

channel   string   

Example: qui

tags   object  optional  
settings   object   
is_active   boolean  optional  

Example: false

DELETE project/{project_idsite}/templates/{templateId}

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://localhost/project/8/templates/10',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/8/templates/10"
);

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

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
curl --request DELETE \
    "http://localhost/project/8/templates/10" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

DELETE project/{project_idsite}/templates/{templateId}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 8

templateId   integer   

Example: 10

Template search

GET project/{project_idsite}/templates/search

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/project/8/templates/search',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'limit' => '10',
            'page' => '1',
            'order' => 'desc',
            'orderBy' => 'datetime',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/8/templates/search"
);

const params = {
    "limit": "10",
    "page": "1",
    "order": "desc",
    "orderBy": "datetime",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/project/8/templates/search?limit=10&page=1&order=desc&orderBy=datetime" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET project/{project_idsite}/templates/search

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 8

Query Parameters

limit   integer  optional  

Default: 10. Must not be greater than 100. Example: 10

page   integer  optional  

Must be at least 1. Example: 1

order   string  optional  

Default: desc. Must be one of asc or desc. Example: desc

orderBy   string  optional  

Default: datetime. Example: datetime

POST project/{project_idsite}/templates/search

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/project/12/templates/search',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'quas',
            'settings' => [
                'name' => 'pariatur',
                'offset' => 2,
                'align' => 'molestiae',
                'accentColor' => 'veritatis',
                'empty_state_text' => 'fuga',
                'loading_text' => 'dolores',
                'placeholder' => 'similique',
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/12/templates/search"
);

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

let body = {
    "name": "quas",
    "settings": {
        "name": "pariatur",
        "offset": 2,
        "align": "molestiae",
        "accentColor": "veritatis",
        "empty_state_text": "fuga",
        "loading_text": "dolores",
        "placeholder": "similique"
    }
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request POST \
    "http://localhost/project/12/templates/search" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"quas\",
    \"settings\": {
        \"name\": \"pariatur\",
        \"offset\": 2,
        \"align\": \"molestiae\",
        \"accentColor\": \"veritatis\",
        \"empty_state_text\": \"fuga\",
        \"loading_text\": \"dolores\",
        \"placeholder\": \"similique\"
    }
}"

Request      

POST project/{project_idsite}/templates/search

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 12

Body Parameters

name   string   

Example: quas

settings   object   
name   string  optional  

Example: pariatur

offset   integer   

Example: 2

align   string   

Example: molestiae

accentColor   string   

Example: veritatis

empty_state_text   string   

Example: fuga

loading_text   string   

Example: dolores

placeholder   string   

Example: similique

GET project/{project_idsite}/templates/search/{id}

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/project/7/templates/search/10',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/7/templates/search/10"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/project/7/templates/search/10" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET project/{project_idsite}/templates/search/{id}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 7

id   integer   

The ID of the search. Example: 10

PUT project/{project_idsite}/templates/search/{id}

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->put(
    'http://localhost/project/5/templates/search/13',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'temporibus',
            'settings' => [
                'name' => 'nihil',
                'offset' => 7,
                'align' => 'nulla',
                'accentColor' => 'distinctio',
                'empty_state_text' => 'odio',
                'loading_text' => 'autem',
                'placeholder' => 'nihil',
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/5/templates/search/13"
);

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

let body = {
    "name": "temporibus",
    "settings": {
        "name": "nihil",
        "offset": 7,
        "align": "nulla",
        "accentColor": "distinctio",
        "empty_state_text": "odio",
        "loading_text": "autem",
        "placeholder": "nihil"
    }
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request PUT \
    "http://localhost/project/5/templates/search/13" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"temporibus\",
    \"settings\": {
        \"name\": \"nihil\",
        \"offset\": 7,
        \"align\": \"nulla\",
        \"accentColor\": \"distinctio\",
        \"empty_state_text\": \"odio\",
        \"loading_text\": \"autem\",
        \"placeholder\": \"nihil\"
    }
}"

Request      

PUT project/{project_idsite}/templates/search/{id}

PATCH project/{project_idsite}/templates/search/{id}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 5

id   integer   

The ID of the search. Example: 13

Body Parameters

name   string   

Example: temporibus

settings   object   
name   string  optional  

Example: nihil

offset   integer   

Example: 7

align   string   

Example: nulla

accentColor   string   

Example: distinctio

empty_state_text   string   

Example: odio

loading_text   string   

Example: autem

placeholder   string   

Example: nihil

DELETE project/{project_idsite}/templates/search/{id}

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://localhost/project/16/templates/search/20',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/16/templates/search/20"
);

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

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
curl --request DELETE \
    "http://localhost/project/16/templates/search/20" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

DELETE project/{project_idsite}/templates/search/{id}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 16

id   integer   

The ID of the search. Example: 20

Touchpoint Coupon

GET project/{project_idsite}/touchpoints/{touchpointid}/coupons

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/project/8/touchpoints/aut/coupons',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'limit' => '10',
            'page' => '1',
            'order' => 'desc',
            'orderBy' => 'datetime',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/8/touchpoints/aut/coupons"
);

const params = {
    "limit": "10",
    "page": "1",
    "order": "desc",
    "orderBy": "datetime",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/project/8/touchpoints/aut/coupons?limit=10&page=1&order=desc&orderBy=datetime" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET project/{project_idsite}/touchpoints/{touchpointid}/coupons

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 8

touchpointid   string   

Example: aut

Query Parameters

limit   integer  optional  

Default: 10. Must not be greater than 100. Example: 10

page   integer  optional  

Must be at least 1. Example: 1

order   string  optional  

Default: desc. Must be one of asc or desc. Example: desc

orderBy   string  optional  

Default: datetime. Example: datetime

POST project/{project_idsite}/touchpoints/{touchpointid}/coupons

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/project/20/touchpoints/ratione/coupons',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/20/touchpoints/ratione/coupons"
);

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

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

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());
curl --request POST \
    "http://localhost/project/20/touchpoints/ratione/coupons?" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

POST project/{project_idsite}/touchpoints/{touchpointid}/coupons

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 20

touchpointid   string   

Example: ratione

Query Parameters

coupons   object   

DELETE project/{project_idsite}/touchpoints/{touchpointid}/coupons

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://localhost/project/20/touchpoints/rerum/coupons',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/20/touchpoints/rerum/coupons"
);

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

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
curl --request DELETE \
    "http://localhost/project/20/touchpoints/rerum/coupons" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

DELETE project/{project_idsite}/touchpoints/{touchpointid}/coupons

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 20

touchpointid   string   

Example: rerum

Touchpoints

POST project/{project_idsite}/touchpoints/{touchpoint}/copy

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/project/9/touchpoints/consequuntur/copy',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'projectId' => 'eligendi',
            'copyToId' => 'ipsa',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/9/touchpoints/consequuntur/copy"
);

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

let body = {
    "projectId": "eligendi",
    "copyToId": "ipsa"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request POST \
    "http://localhost/project/9/touchpoints/consequuntur/copy" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"projectId\": \"eligendi\",
    \"copyToId\": \"ipsa\"
}"

Request      

POST project/{project_idsite}/touchpoints/{touchpoint}/copy

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 9

touchpoint   string   

The touchpoint. Example: consequuntur

Body Parameters

projectId   string   

Example: eligendi

copyToId   string   

Example: ipsa

GET project/{project_idsite}/touchpoints

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/project/18/touchpoints',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/18/touchpoints"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/project/18/touchpoints" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET project/{project_idsite}/touchpoints

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 18

POST project/{project_idsite}/touchpoints

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/project/14/touchpoints',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'campaignid' => 'aspernatur',
            'journeyid' => 'ut',
            'name' => 'est',
            'status' => 'eum',
            'settings' => [],
            'channel' => 'labore',
            'type' => 'id',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/14/touchpoints"
);

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

let body = {
    "campaignid": "aspernatur",
    "journeyid": "ut",
    "name": "est",
    "status": "eum",
    "settings": [],
    "channel": "labore",
    "type": "id"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request POST \
    "http://localhost/project/14/touchpoints" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"campaignid\": \"aspernatur\",
    \"journeyid\": \"ut\",
    \"name\": \"est\",
    \"status\": \"eum\",
    \"settings\": [],
    \"channel\": \"labore\",
    \"type\": \"id\"
}"

Request      

POST project/{project_idsite}/touchpoints

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 14

Body Parameters

campaignid   string   

Example: aspernatur

journeyid   string   

Example: ut

name   string   

Example: est

status   string   

Example: eum

settings   object   
content   object  optional  
channel   string  optional  

Example: labore

type   string  optional  

Example: id

content_targeting   object  optional  
content_targeting_db   object  optional  

GET project/{project_idsite}/touchpoints/{id}

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/project/3/touchpoints/voluptatum',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/3/touchpoints/voluptatum"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/project/3/touchpoints/voluptatum" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET project/{project_idsite}/touchpoints/{id}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 3

id   string   

The ID of the touchpoint. Example: voluptatum

PUT project/{project_idsite}/touchpoints/{id}

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->put(
    'http://localhost/project/18/touchpoints/quia',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'campaignid' => 'totam',
            'journeyid' => 'sit',
            'name' => 'ut',
            'status' => 'fugiat',
            'settings' => [],
            'channel' => 'mollitia',
            'type' => 'alias',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/18/touchpoints/quia"
);

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

let body = {
    "campaignid": "totam",
    "journeyid": "sit",
    "name": "ut",
    "status": "fugiat",
    "settings": [],
    "channel": "mollitia",
    "type": "alias"
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request PUT \
    "http://localhost/project/18/touchpoints/quia" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"campaignid\": \"totam\",
    \"journeyid\": \"sit\",
    \"name\": \"ut\",
    \"status\": \"fugiat\",
    \"settings\": [],
    \"channel\": \"mollitia\",
    \"type\": \"alias\"
}"

Request      

PUT project/{project_idsite}/touchpoints/{id}

PATCH project/{project_idsite}/touchpoints/{id}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 18

id   string   

The ID of the touchpoint. Example: quia

Body Parameters

campaignid   string   

Example: totam

journeyid   string   

Example: sit

name   string   

Example: ut

status   string   

Example: fugiat

settings   object   
content   object  optional  
channel   string  optional  

Example: mollitia

type   string  optional  

Example: alias

content_targeting   object  optional  
content_targeting_db   object  optional  

DELETE project/{project_idsite}/touchpoints/{id}

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://localhost/project/14/touchpoints/impedit',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/14/touchpoints/impedit"
);

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

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
curl --request DELETE \
    "http://localhost/project/14/touchpoints/impedit" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

DELETE project/{project_idsite}/touchpoints/{id}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 14

id   string   

The ID of the touchpoint. Example: impedit

GET project/{project_idsite}/touchpoints/{touchpointId}/preview

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/project/12/touchpoints/optio/preview',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/12/touchpoints/optio/preview"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/project/12/touchpoints/optio/preview" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET project/{project_idsite}/touchpoints/{touchpointId}/preview

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 12

touchpointId   string   

Example: optio

POST project/{project_idsite}/touchpoints/{touchpoint}/send

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/project/5/touchpoints/ut/send',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'recipients' => [
                'cleve.crist@example.net',
            ],
            'profileid' => 'eum',
            'profilesource' => 'minima',
            'visitorid' => 'voluptas',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/5/touchpoints/ut/send"
);

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

let body = {
    "recipients": [
        "cleve.crist@example.net"
    ],
    "profileid": "eum",
    "profilesource": "minima",
    "visitorid": "voluptas"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request POST \
    "http://localhost/project/5/touchpoints/ut/send" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"recipients\": [
        \"cleve.crist@example.net\"
    ],
    \"profileid\": \"eum\",
    \"profilesource\": \"minima\",
    \"visitorid\": \"voluptas\"
}"

Request      

POST project/{project_idsite}/touchpoints/{touchpoint}/send

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 5

touchpoint   string   

The touchpoint. Example: ut

Body Parameters

recipients   string[]   

Must be a valid email address.

profileid   string  optional  

Example: eum

profilesource   string  optional  

This field is required when profileid is present. Example: minima

visitorid   string  optional  

Example: voluptas

Tracker

Get tracker shopping carts

requires authentication

Returns a list of tracker shopping carts. By default it returns the shopping carts of today, ordered by datetime descending

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/project/minima/tracker/carts',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'from' => '2024-03-06 12:00:54',
            'to' => '2024-03-07 12:00:54',
            'limit' => '10',
            'page' => '1',
            'order' => 'desc',
            'orderBy' => 'datetime',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/minima/tracker/carts"
);

const params = {
    "from": "2024-03-06 12:00:54",
    "to": "2024-03-07 12:00:54",
    "limit": "10",
    "page": "1",
    "order": "desc",
    "orderBy": "datetime",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/project/minima/tracker/carts?from=2024-03-06+12%3A00%3A54&to=2024-03-07+12%3A00%3A54&limit=10&page=1&order=desc&orderBy=datetime" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET project/{project}/tracker/carts

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project   string   

The project. Example: minima

Query Parameters

from   string  optional  

Default: 24 hours ago. This field is required when to is present. Must be a valid date in the format Y-m-d H:i:s. Example: 2024-03-06 12:00:54

to   string  optional  

Default: now. Must be a valid date in the format Y-m-d H:i:s. Must be a date after or equal to from. Must be a date before tomorrow. Example: 2024-03-07 12:00:54

limit   integer  optional  

Default: 10. Must not be greater than 100. Example: 10

page   integer  optional  

Must be at least 1. Example: 1

order   string  optional  

Default: desc. Must be one of asc or desc. Example: desc

orderBy   string  optional  

Default: datetime. Example: datetime

Get tracker category views

requires authentication

Returns a list of recognized category views. By default it returns the categories of today, ordered by datetime descending

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/project/impedit/tracker/categories',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'from' => '2024-03-06 12:00:54',
            'to' => '2024-03-07 12:00:54',
            'limit' => '10',
            'page' => '1',
            'order' => 'desc',
            'orderBy' => 'datetime',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/impedit/tracker/categories"
);

const params = {
    "from": "2024-03-06 12:00:54",
    "to": "2024-03-07 12:00:54",
    "limit": "10",
    "page": "1",
    "order": "desc",
    "orderBy": "datetime",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/project/impedit/tracker/categories?from=2024-03-06+12%3A00%3A54&to=2024-03-07+12%3A00%3A54&limit=10&page=1&order=desc&orderBy=datetime" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET project/{project}/tracker/categories

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project   string   

The project. Example: impedit

Query Parameters

from   string  optional  

Default: 24 hours ago. This field is required when to is present. Must be a valid date in the format Y-m-d H:i:s. Example: 2024-03-06 12:00:54

to   string  optional  

Default: now. Must be a valid date in the format Y-m-d H:i:s. Must be a date after or equal to from. Must be a date before tomorrow. Example: 2024-03-07 12:00:54

limit   integer  optional  

Default: 10. Must not be greater than 100. Example: 10

page   integer  optional  

Must be at least 1. Example: 1

order   string  optional  

Default: desc. Must be one of asc or desc. Example: desc

orderBy   string  optional  

Default: datetime. Example: datetime

Get tracker conversions

requires authentication

Returns a list of tracker conversions. By default it returns the conversions of today, ordered by datetime descending

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/project/ipsa/tracker/conversions',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'from' => '2024-03-06 12:00:54',
            'to' => '2024-03-07 12:00:54',
            'limit' => '10',
            'page' => '1',
            'order' => 'desc',
            'orderBy' => 'datetime',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/ipsa/tracker/conversions"
);

const params = {
    "from": "2024-03-06 12:00:54",
    "to": "2024-03-07 12:00:54",
    "limit": "10",
    "page": "1",
    "order": "desc",
    "orderBy": "datetime",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/project/ipsa/tracker/conversions?from=2024-03-06+12%3A00%3A54&to=2024-03-07+12%3A00%3A54&limit=10&page=1&order=desc&orderBy=datetime" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET project/{project}/tracker/conversions

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project   string   

The project. Example: ipsa

Query Parameters

from   string  optional  

Default: 24 hours ago. This field is required when to is present. Must be a valid date in the format Y-m-d H:i:s. Example: 2024-03-06 12:00:54

to   string  optional  

Default: now. Must be a valid date in the format Y-m-d H:i:s. Must be a date after or equal to from. Must be a date before tomorrow. Example: 2024-03-07 12:00:54

limit   integer  optional  

Default: 10. Must not be greater than 100. Example: 10

page   integer  optional  

Must be at least 1. Example: 1

order   string  optional  

Default: desc. Must be one of asc or desc. Example: desc

orderBy   string  optional  

Default: datetime. Example: datetime

Get tracker product views

requires authentication

Returns a list of recognized product views. By default it returns the product views of today, ordered by datetime descending

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/project/voluptatibus/tracker/products',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'from' => '2024-03-06 12:00:54',
            'to' => '2024-03-07 12:00:54',
            'limit' => '10',
            'page' => '1',
            'order' => 'desc',
            'orderBy' => 'datetime',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/voluptatibus/tracker/products"
);

const params = {
    "from": "2024-03-06 12:00:54",
    "to": "2024-03-07 12:00:54",
    "limit": "10",
    "page": "1",
    "order": "desc",
    "orderBy": "datetime",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/project/voluptatibus/tracker/products?from=2024-03-06+12%3A00%3A54&to=2024-03-07+12%3A00%3A54&limit=10&page=1&order=desc&orderBy=datetime" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET project/{project}/tracker/products

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project   string   

The project. Example: voluptatibus

Query Parameters

from   string  optional  

Default: 24 hours ago. This field is required when to is present. Must be a valid date in the format Y-m-d H:i:s. Example: 2024-03-06 12:00:54

to   string  optional  

Default: now. Must be a valid date in the format Y-m-d H:i:s. Must be a date after or equal to from. Must be a date before tomorrow. Example: 2024-03-07 12:00:54

limit   integer  optional  

Default: 10. Must not be greater than 100. Example: 10

page   integer  optional  

Must be at least 1. Example: 1

order   string  optional  

Default: desc. Must be one of asc or desc. Example: desc

orderBy   string  optional  

Default: datetime. Example: datetime

Two factor

Available types.

requires authentication

Returns the available MFA types.

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/user/rerum/two-factor/types',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/user/rerum/two-factor/types"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/user/rerum/two-factor/types" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Example response (200, success):


{
 "data":"['id' => 'email', 'label' => 'authenticator.phone']",
}

Request      

GET user/{user}/two-factor/types

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

user   string   

The user. Example: rerum

Create settings.

requires authentication

Creates a 2 factor secret and sends a verification messages to the user when phone is set.

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/user/tempora/two-factor',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'two_factor' => 'google',
            'auth_code' => '123654',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/user/tempora/two-factor"
);

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

let body = {
    "two_factor": "google",
    "auth_code": "123654"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request POST \
    "http://localhost/user/tempora/two-factor" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"two_factor\": \"google\",
    \"auth_code\": \"123654\"
}"

Example response (200, success):


{
 "message":"Two factor enabled",
 "two_factor_secret":"103 character string",
 "qr_code":"url",
}

Request      

POST user/{user_login}/two-factor

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

user_login   string   

Example: tempora

Body Parameters

two_factor   string   

The type of two factor. Example: google

auth_code   string  optional  

The authentication code for MFA. Example: 123654

Verify settings.

requires authentication

Verifies the secret with the code and sets the two factor type.

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/user/iusto/two-factor/verify',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'two_factor' => 'google',
            'auth_code' => '123654',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/user/iusto/two-factor/verify"
);

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

let body = {
    "two_factor": "google",
    "auth_code": "123654"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request POST \
    "http://localhost/user/iusto/two-factor/verify" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"two_factor\": \"google\",
    \"auth_code\": \"123654\"
}"

Request      

POST user/{user_login}/two-factor/verify

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

user_login   string   

Example: iusto

Body Parameters

two_factor   string   

The type of two factor. Example: google

auth_code   string  optional  

The authentication code for MFA. Example: 123654

Remove settings.

requires authentication

Removes two factor settings.

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://localhost/user/odit/two-factor',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/user/odit/two-factor"
);

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

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
curl --request DELETE \
    "http://localhost/user/odit/two-factor" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Example response (200, success):


{
 "message":"Two factor disabled",
}

Example response (400, auth code empty):


{
    "message": "Auth code required"
}

Example response (401, auth code not correct):


{
    "message": "Auth code not correct"
}

Request      

DELETE user/{user_login}/two-factor

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

user_login   string   

Example: odit

User

GET me

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/me',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/me"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/me" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET me

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

GET user

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/user',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/user"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/user" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET user

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Authentication for the platform.

Generates an oauth token when the user has succesfully authenticated. When using MFA it will return information on which authentication flow it is using and require a code

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/login',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'username' => 'your@email.com',
            'password' => 'yourpassword',
            'auth_code' => '123654',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/login"
);

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

let body = {
    "username": "your@email.com",
    "password": "yourpassword",
    "auth_code": "123654"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request POST \
    "http://localhost/login" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"username\": \"your@email.com\",
    \"password\": \"yourpassword\",
    \"auth_code\": \"123654\"
}"

Example response (200, success):


{
 "access_token":"324324324324242343434",
 "expires_in":"232132213",
 "token_type":"bearer",
}

Example response (200, mfa):


{
 "two_factor":"email",
 "message_sent":true,
}

Request      

POST login

Headers

Content-Type      

Example: application/json

Accept      

Example: application/json

Body Parameters

username   string   

Your username. Example: your@email.com

password   string   

The password. Example: yourpassword

auth_code   string  optional  

The authentication code for MFA. Example: 123654

Log the user out (Invalidate the token).

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/logout',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/logout"
);

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

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());
curl --request POST \
    "http://localhost/logout" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

POST logout

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Refresh a token.

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/refresh',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/refresh"
);

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

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());
curl --request POST \
    "http://localhost/refresh" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

POST refresh

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Send a reset link to the given user.

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/user/iprohaska@example.org/password-reset',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/user/iprohaska@example.org/password-reset"
);

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

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());
curl --request POST \
    "http://localhost/user/iprohaska@example.org/password-reset" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

POST user/{email}/password-reset

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

email   string   

Example: iprohaska@example.org

Display the password reset view for the given token.

requires authentication

If no token is present, display the link request form.

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/user/jreinger@example.com/vel',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/user/jreinger@example.com/vel"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/user/jreinger@example.com/vel" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

GET user/{email}/{token}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

email   string   

Example: jreinger@example.com

token   string   

Example: vel

Reset the given user's password.

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->put(
    'http://localhost/user/dahlia15@example.net/password-reset',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/user/dahlia15@example.net/password-reset"
);

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

fetch(url, {
    method: "PUT",
    headers,
}).then(response => response.json());
curl --request PUT \
    "http://localhost/user/dahlia15@example.net/password-reset" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Request      

PUT user/{email}/password-reset

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

email   string   

Example: dahlia15@example.net

Update a user.

requires authentication

Updates the passed through user data. Values that are not sent are not updated.

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->put(
    'http://localhost/user/quia',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'alias' => 'veniam',
            'profileimg' => 'eveniet',
            'role' => 'cupiditate',
            'phone' => 'esse',
            'two_factor_secret' => 'amet',
            'two_factor' => 'qui',
            'auth_code' => 'eos',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/user/quia"
);

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

let body = {
    "alias": "veniam",
    "profileimg": "eveniet",
    "role": "cupiditate",
    "phone": "esse",
    "two_factor_secret": "amet",
    "two_factor": "qui",
    "auth_code": "eos"
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
curl --request PUT \
    "http://localhost/user/quia" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"alias\": \"veniam\",
    \"profileimg\": \"eveniet\",
    \"role\": \"cupiditate\",
    \"phone\": \"esse\",
    \"two_factor_secret\": \"amet\",
    \"two_factor\": \"qui\",
    \"auth_code\": \"eos\"
}"

Request      

PUT user/{login}

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

login   string   

Example: quia

Body Parameters

alias   string  optional  

Example: veniam

profileimg   string  optional  

Example: eveniet

role   string  optional  

Example: cupiditate

phone   string  optional  

Example: esse

two_factor_secret   string  optional  

Example: amet

two_factor   string  optional  

Example: qui

auth_code   string  optional  

Example: eos

settings   object  optional  

Carts

Abandoned carts Returns the last 25 carts that are logged for a specific visitor or visitid.

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/project/2/realtime/conversions',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'filter[visitorid]' => '867A33A74CABB43D',
            'filter[visitid]' => '2132324324',
            'filter[goalid]' => '2132324324',
            'page' => '1',
            'fields' => 'visitid,visitorid',
            'limit' => '18',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/2/realtime/conversions"
);

const params = {
    "filter[visitorid]": "867A33A74CABB43D",
    "filter[visitid]": "2132324324",
    "filter[goalid]": "2132324324",
    "page": "1",
    "fields": "visitid,visitorid",
    "limit": "18",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/project/2/realtime/conversions?filter[visitorid]=867A33A74CABB43D&filter[visitid]=2132324324&filter[goalid]=2132324324&page=1&fields=visitid%2Cvisitorid&limit=18" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Example response (200, success):


{
 "page":"current page of the cart list",
 "data":"array of results",
 "next_page_url":"url of the next page",
 "prev_page_url":"url of the previous page",
 "per_page":"results per page",
 "links":"array of links to the pages",
}

Request      

GET project/{project_idsite}/realtime/conversions

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 2

Query Parameters

filter   object  optional  
filter.visitorid   string  optional  

Filter on visitor id. This field is required when filter.visitid is not present. Example: 867A33A74CABB43D

filter.visitid   string  optional  

Filter on visit id. This field is required when filter.visitorid is not present. Example: 2132324324

filter.goalid   integer  optional  

Filter on goal id (-1 cart, 0 converted, > 1 custom goal. Example: 2132324324

page   integer  optional  

Page of results you want to fetch. Example: 1

fields   string  optional  

Comma separated list of fields that need to be returned. Example: visitid,visitorid

limit   integer  optional  

Must not be greater than 100. Example: 18

Invoice

Get invoices.

requires authentication

Returns the invoices.

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/project/1/invoice',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/1/invoice"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/project/1/invoice" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Example response (200, success):


{
    "account": {
        "balance": 2480.5,
        "totalInvoiceBalance": 2480.5,
        "creditBalance": 0,
        "totalDebitMemoBalance": 0,
        "unappliedPaymentAmount": 0,
        "unappliedCreditMemoAmount": 0,
        "contractedMrr": 2050
    },
    "invoices": [
        {
            "number": "23Z00001200",
            "date": "2023-06-01",
            "dueDate": "2023-07-01",
            "amount": 2480.5,
            "balance": 2480.5,
            "fileid": "8a28ad7a8855ec610188763206862b0d"
        }
    ],
    "creditmemos": [
        {
            "number": "21C00000044",
            "date": "2021-06-23",
            "amount": 1211.17,
            "comment": "Discount period March, April, May and June",
            "fileid": "8a2880527b0c22ee017b0c40938701e3"
        }
    ]
}

Request      

GET project/{project_idsite}/invoice

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 1

Visits

Visit log action Returns the last 25 actions that are logged for a specific visitor or visitid.

requires authentication

Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/project/2/visits',
    [
        'headers' => [
            'x-apikey' => '{YOUR_APIKEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'filter[visitorid]' => '867A33A74CABB43D',
            'filter[visitid]' => '2132324324',
            'page' => '1',
            'fields' => 'visitid,visitorid,time_spent,url,name,action,server_time,project_time',
            'limit' => '21',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/project/2/visits"
);

const params = {
    "filter[visitorid]": "867A33A74CABB43D",
    "filter[visitid]": "2132324324",
    "page": "1",
    "fields": "visitid,visitorid,time_spent,url,name,action,server_time,project_time",
    "limit": "21",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
curl --request GET \
    --get "http://localhost/project/2/visits?filter[visitorid]=867A33A74CABB43D&filter[visitid]=2132324324&page=1&fields=visitid%2Cvisitorid%2Ctime_spent%2Curl%2Cname%2Caction%2Cserver_time%2Cproject_time&limit=21" \
    --header "x-apikey: {YOUR_APIKEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

Example response (200, success):


{
 "page":"current page of the visitor action list",
 "data":"array of results",
 "next_page_url":"url of the next page",
 "prev_page_url":"url of the previous page",
 "per_page":"results per page",
 "links":"array of links to the pages",
}

Request      

GET project/{project_idsite}/visits

Headers

x-apikey      

Example: {YOUR_APIKEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

project_idsite   integer   

Example: 2

Query Parameters

filter   object  optional  
filter.visitorid   string  optional  

Filter on visitor id. This field is required when filter.visitid is not present. Example: 867A33A74CABB43D

filter.visitid   string  optional  

Filter on visit id. This field is required when filter.visitorid is not present. Example: 2132324324

page   integer  optional  

Page of results you want to fetch. Example: 1

fields   string  optional  

Comma separated list of fields that need to be returned. Example: visitid,visitorid,time_spent,url,name,action,server_time,project_time

limit   integer  optional  

Must not be greater than 100. Example: 21