MENU navbar-image

Introduction

Version: v5.1.13 Updated: Aug 02, 2024

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

Base URL

http://localhost/api/v1

Authenticating requests

To authenticate requests, include an Authorization header with the value "Bearer {accessToken}".

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

You can retrieve your token with api Generate API token.

Activity Point

App name: Activity Point Version: 5.1.11 Author: phpFox Updated at: Aug 02, 2024

Browse item

Example request:
curl --request GET \
    --get "http://localhost/api/v1/api/harum/activitypoint/conversion-request" \
    --header "Content-Type: application/json" \
    --data "{
    "status": "nihil",
    "from_date": "aspernatur",
    "to_date": "animi",
    "limit": 16,
    "id": 5
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/harum/activitypoint/conversion-request',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'status' => 'nihil',
            'from_date' => 'aspernatur',
            'to_date' => 'animi',
            'limit' => 16,
            'id' => 5,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/harum/activitypoint/conversion-request"
);

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

let body = {
    "status": "nihil",
    "from_date": "aspernatur",
    "to_date": "animi",
    "limit": 16,
    "id": 5
};

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

Request      

GET api/{ver}/activitypoint/conversion-request

URL Parameters

ver  string  

Body Parameters

status  string optional  

from_date  string optional  

to_date  string optional  

limit  integer optional  

Must be at least 1. Must not be greater than 100.

id  integer optional  

GET api/{ver}/activitypoint/conversion-request/{id}

Example request:
curl --request GET \
    --get "http://localhost/api/v1/api/aut/activitypoint/conversion-request/9405634"
$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/aut/activitypoint/conversion-request/9405634');
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/aut/activitypoint/conversion-request/9405634"
);

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

Request      

GET api/{ver}/activitypoint/conversion-request/{id}

URL Parameters

ver  string  

id  string  

The ID of the conversion request.

PATCH api/{ver}/activitypoint/conversion-request/{id}/cancel

Example request:
curl --request PATCH \
    "http://localhost/api/v1/api/facilis/activitypoint/conversion-request/1/cancel"
$client = new \GuzzleHttp\Client();
$response = $client->patch('http://localhost/api/v1/api/facilis/activitypoint/conversion-request/1/cancel');
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/facilis/activitypoint/conversion-request/1/cancel"
);

fetch(url, {
    method: "PATCH",
}).then(response => response.json());

Request      

PATCH api/{ver}/activitypoint/conversion-request/{id}/cancel

URL Parameters

ver  string  

id  string  

The ID of the conversion request.

Browse item.

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/api/quis/activitypoint/package?q=fuga" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "q": "aut",
    "sort": "most_viewed",
    "sort_type": "asc",
    "page": 63,
    "limit": 11
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/quis/activitypoint/package',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'query' => [
            'q'=> 'fuga',
        ],
        'json' => [
            'q' => 'aut',
            'sort' => 'most_viewed',
            'sort_type' => 'asc',
            'page' => 63,
            'limit' => 11,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/quis/activitypoint/package"
);

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

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

let body = {
    "q": "aut",
    "sort": "most_viewed",
    "sort_type": "asc",
    "page": 63,
    "limit": 11
};

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

Request      

GET api/{ver}/activitypoint/package

URL Parameters

ver  string  

Query Parameters

q  string optional  

search text

Body Parameters

q  string optional  

sort  string optional  

Must be one of recent, most_discussed, most_viewed, most_liked, or latest.

sort_type  string optional  

Must be one of desc or asc.

page  integer optional  

Must be at least 1.

limit  integer optional  

Browse item.

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/api/qui/activitypoint/package-transaction" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "q": "facere",
    "status": "autem",
    "from": "2024-08-02T08:10:38",
    "to": "2024-08-02T08:10:38",
    "sort": "most_liked",
    "sort_type": "desc",
    "page": 37,
    "limit": 8
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/qui/activitypoint/package-transaction',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'q' => 'facere',
            'status' => 'autem',
            'from' => '2024-08-02T08:10:38',
            'to' => '2024-08-02T08:10:38',
            'sort' => 'most_liked',
            'sort_type' => 'desc',
            'page' => 37,
            'limit' => 8,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/qui/activitypoint/package-transaction"
);

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

let body = {
    "q": "facere",
    "status": "autem",
    "from": "2024-08-02T08:10:38",
    "to": "2024-08-02T08:10:38",
    "sort": "most_liked",
    "sort_type": "desc",
    "page": 37,
    "limit": 8
};

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

Request      

GET api/{ver}/activitypoint/package-transaction

URL Parameters

ver  string  

Body Parameters

q  string optional  

status  string optional  

from  string optional  

Must be a valid date.

to  string optional  

Must be a valid date.

sort  string optional  

Must be one of recent, most_discussed, most_viewed, most_liked, or latest.

sort_type  string optional  

Must be one of desc or asc.

page  integer optional  

Must be at least 1.

limit  integer optional  

POST api/{ver}/activitypoint/package/purchase/{id}

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/api/minima/activitypoint/package/purchase/12" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "payment_gateway": 6
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/minima/activitypoint/package/purchase/12',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'payment_gateway' => 6,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/minima/activitypoint/package/purchase/12"
);

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

let body = {
    "payment_gateway": 6
};

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

Request      

POST api/{ver}/activitypoint/package/purchase/{id}

URL Parameters

ver  string  

id  string  

The ID of the purchase.

Body Parameters

payment_gateway  integer  

View item.

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/api/sed/activitypoint/package/605" \
    --header "Authorization: Bearer {accessToken}"
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/sed/activitypoint/package/605',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/sed/activitypoint/package/605"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

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

Request      

GET api/{ver}/activitypoint/package/{id}

URL Parameters

ver  string  

id  string  

The ID of the package.

Browse item.

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/api/rerum/activitypoint/setting" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "sort": "most_viewed",
    "sort_type": "asc"
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/rerum/activitypoint/setting',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'sort' => 'most_viewed',
            'sort_type' => 'asc',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/rerum/activitypoint/setting"
);

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

let body = {
    "sort": "most_viewed",
    "sort_type": "asc"
};

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

Request      

GET api/{ver}/activitypoint/setting

URL Parameters

ver  string  

Body Parameters

sort  string optional  

Must be one of recent, most_discussed, most_viewed, most_liked, or latest.

sort_type  string optional  

Must be one of desc or asc.

View item.

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/api/architecto/activitypoint/statistic/88" \
    --header "Authorization: Bearer {accessToken}"
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/architecto/activitypoint/statistic/88',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/architecto/activitypoint/statistic/88"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

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

Request      

GET api/{ver}/activitypoint/statistic/{id}

URL Parameters

ver  string  

id  string  

The ID of the statistic.

Browse item.

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/api/asperiores/activitypoint/transaction" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "type": 1,
    "from": "2024-08-02T08:10:38",
    "to": "2040-03-14",
    "sort": "most_discussed",
    "sort_type": "asc",
    "page": 37,
    "limit": 10
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/asperiores/activitypoint/transaction',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'type' => 1,
            'from' => '2024-08-02T08:10:38',
            'to' => '2040-03-14',
            'sort' => 'most_discussed',
            'sort_type' => 'asc',
            'page' => 37,
            'limit' => 10,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/asperiores/activitypoint/transaction"
);

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

let body = {
    "type": 1,
    "from": "2024-08-02T08:10:38",
    "to": "2040-03-14",
    "sort": "most_discussed",
    "sort_type": "asc",
    "page": 37,
    "limit": 10
};

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

Request      

GET api/{ver}/activitypoint/transaction

URL Parameters

ver  string  

Body Parameters

type  integer optional  

from  string optional  

Must be a valid date.

to  string optional  

Must be a valid date. Must be a date after from.

sort  string optional  

Must be one of recent, most_discussed, most_viewed, most_liked, or latest.

sort_type  string optional  

Must be one of desc or asc.

page  integer optional  

Must be at least 1.

limit  integer optional  

View item.

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/api/beatae/activitypoint/transaction/0" \
    --header "Authorization: Bearer {accessToken}"
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/beatae/activitypoint/transaction/0',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/beatae/activitypoint/transaction/0"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

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

Request      

GET api/{ver}/activitypoint/transaction/{id}

URL Parameters

ver  string  

id  string  

The ID of the transaction.

Advertise

App name: Advertise Version: 5.0.14 Author: phpFox Updated at: Aug 02, 2024

Example request:
curl --request GET \
    --get "http://localhost/api/v1/api/qui/advertise/advertise" \
    --header "Content-Type: application/json" \
    --data "{
    "placement_id": 489.7407,
    "start_date": "nulla",
    "end_date": "accusantium",
    "status": "quaerat",
    "page": 71,
    "limit": 11.27982
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/qui/advertise/advertise',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'placement_id' => 489.7407,
            'start_date' => 'nulla',
            'end_date' => 'accusantium',
            'status' => 'quaerat',
            'page' => 71,
            'limit' => 11.27982,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/qui/advertise/advertise"
);

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

let body = {
    "placement_id": 489.7407,
    "start_date": "nulla",
    "end_date": "accusantium",
    "status": "quaerat",
    "page": 71,
    "limit": 11.27982
};

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

Request      

GET api/{ver}/advertise/advertise

URL Parameters

ver  string  

Body Parameters

placement_id  number optional  

view  string optional  

start_date  string optional  

end_date  string optional  

status  string optional  

page  number optional  

Must be at least 1.

limit  number optional  

Example request:
curl --request POST \
    "http://localhost/api/v1/api/aut/advertise/advertise" \
    --header "Content-Type: application/json" \
    --data "{
    "placement_id": 1287837.94956,
    "image": {
        "status": "in",
        "temp_file": 311.24629
    },
    "url": "https:\/\/www.schowalter.com\/et-consequuntur-reiciendis-natus-nisi-et",
    "image_tooltip": "lxptiesrqtpgrxxzu",
    "html_title": "bzhfkea",
    "html_description": "sgwblbuhxznw",
    "title": "dpktceabwqkce",
    "age_from": 25,
    "languages": [
        "aut"
    ],
    "start_date": "2024-08-02T08:10:38",
    "creation_type": "dolores"
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/aut/advertise/advertise',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'placement_id' => 1287837.94956,
            'image' => [
                'status' => 'in',
                'temp_file' => 311.24629,
            ],
            'url' => 'https://www.schowalter.com/et-consequuntur-reiciendis-natus-nisi-et',
            'image_tooltip' => 'lxptiesrqtpgrxxzu',
            'html_title' => 'bzhfkea',
            'html_description' => 'sgwblbuhxznw',
            'title' => 'dpktceabwqkce',
            'age_from' => 25,
            'languages' => [
                'aut',
            ],
            'start_date' => '2024-08-02T08:10:38',
            'creation_type' => 'dolores',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/aut/advertise/advertise"
);

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

let body = {
    "placement_id": 1287837.94956,
    "image": {
        "status": "in",
        "temp_file": 311.24629
    },
    "url": "https:\/\/www.schowalter.com\/et-consequuntur-reiciendis-natus-nisi-et",
    "image_tooltip": "lxptiesrqtpgrxxzu",
    "html_title": "bzhfkea",
    "html_description": "sgwblbuhxznw",
    "title": "dpktceabwqkce",
    "age_from": 25,
    "languages": [
        "aut"
    ],
    "start_date": "2024-08-02T08:10:38",
    "creation_type": "dolores"
};

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

Request      

POST api/{ver}/advertise/advertise

URL Parameters

ver  string  

Body Parameters

placement_id  number  

image  object  

image.status  string optional  

This field is required when image.temp_file is present.

image.temp_file  number optional  

This field is required when image.id is 0.

url  string  

Must be a valid URL.

image_tooltip  string optional  

Must not be greater than 255 characters.

html_title  string optional  

This field is required when creation_type is html. Must not be greater than 25 characters.

html_description  string optional  

Must not be greater than 135 characters.

title  string  

Must not be greater than 255 characters.

total_click  string optional  

total_impression  string optional  

genders  string[] optional  

This field is required when genders is present.

age_from  integer optional  

Must be at least 1.

age_to  string optional  

languages  string[] optional  

This field is required when languages is present.

is_active  string optional  

start_date  string  

Must be a valid date.

end_date  string optional  

creation_type  string  

location  object optional  

Must have at least {min, plural, =1 {# item} other {# items}}.

Example request:
curl --request PATCH \
    "http://localhost/api/v1/api/id/advertise/advertise/active/614"
$client = new \GuzzleHttp\Client();
$response = $client->patch('http://localhost/api/v1/api/id/advertise/advertise/active/614');
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/id/advertise/advertise/active/614"
);

fetch(url, {
    method: "PATCH",
}).then(response => response.json());

Request      

PATCH api/{ver}/advertise/advertise/active/{id}

URL Parameters

ver  string  

id  string  

The ID of the active.

Example request:
curl --request PATCH \
    "http://localhost/api/v1/api/qui/advertise/advertise/hide/01150"
$client = new \GuzzleHttp\Client();
$response = $client->patch('http://localhost/api/v1/api/qui/advertise/advertise/hide/01150');
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/qui/advertise/advertise/hide/01150"
);

fetch(url, {
    method: "PATCH",
}).then(response => response.json());

Request      

PATCH api/{ver}/advertise/advertise/hide/{id}

URL Parameters

ver  string  

id  string  

The ID of the hide.

Example request:
curl --request GET \
    --get "http://localhost/api/v1/api/unde/advertise/advertise/report/34553" \
    --header "Content-Type: application/json" \
    --data "{
    "report_type": "sint",
    "view": "sequi",
    "start_date_month": "quod",
    "end_date_month": "qui",
    "start_date_week": "iste",
    "end_date_week": "molestiae",
    "start_date_day": "accusamus",
    "end_date_day": "rerum"
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/unde/advertise/advertise/report/34553',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'report_type' => 'sint',
            'view' => 'sequi',
            'start_date_month' => 'quod',
            'end_date_month' => 'qui',
            'start_date_week' => 'iste',
            'end_date_week' => 'molestiae',
            'start_date_day' => 'accusamus',
            'end_date_day' => 'rerum',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/unde/advertise/advertise/report/34553"
);

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

let body = {
    "report_type": "sint",
    "view": "sequi",
    "start_date_month": "quod",
    "end_date_month": "qui",
    "start_date_week": "iste",
    "end_date_week": "molestiae",
    "start_date_day": "accusamus",
    "end_date_day": "rerum"
};

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

Request      

GET api/{ver}/advertise/advertise/report/{id}

URL Parameters

ver  string  

id  string  

The ID of the report.

Body Parameters

report_type  string  

view  string  

start_date_month  string optional  

end_date_month  string optional  

start_date_week  string optional  

end_date_week  string optional  

start_date_day  string optional  

end_date_day  string optional  

Example request:
curl --request GET \
    --get "http://localhost/api/v1/api/et/advertise/advertise/show" \
    --header "Content-Type: application/json" \
    --data "{
    "placement_id": 1106342,
    "location": "nesciunt"
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/et/advertise/advertise/show',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'placement_id' => 1106342.0,
            'location' => 'nesciunt',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/et/advertise/advertise/show"
);

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

let body = {
    "placement_id": 1106342,
    "location": "nesciunt"
};

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

Request      

GET api/{ver}/advertise/advertise/show

URL Parameters

ver  string  

Body Parameters

placement_id  number  

location  string optional  

Example request:
curl --request PATCH \
    "http://localhost/api/v1/api/aperiam/advertise/advertise/total/4" \
    --header "Content-Type: application/json" \
    --data "{
    "type": "eveniet"
}"

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://localhost/api/v1/api/aperiam/advertise/advertise/total/4',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'type' => 'eveniet',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/aperiam/advertise/advertise/total/4"
);

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

let body = {
    "type": "eveniet"
};

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

Request      

PATCH api/{ver}/advertise/advertise/total/{id}

URL Parameters

ver  string  

id  string  

The ID of the total.

Body Parameters

type  string  

Example request:
curl --request GET \
    --get "http://localhost/api/v1/api/et/advertise/advertise/28"
$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/et/advertise/advertise/28');
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/et/advertise/advertise/28"
);

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

Request      

GET api/{ver}/advertise/advertise/{id}

URL Parameters

ver  string  

id  string  

The ID of the advertise.

Example request:
curl --request PUT \
    "http://localhost/api/v1/api/asperiores/advertise/advertise/9" \
    --header "Content-Type: application/json" \
    --data "{
    "title": "iswogbo",
    "age_from": 55,
    "age_to": 709782.2,
    "languages": [
        "temporibus"
    ]
}"

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'http://localhost/api/v1/api/asperiores/advertise/advertise/9',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'title' => 'iswogbo',
            'age_from' => 55,
            'age_to' => 709782.2,
            'languages' => [
                'temporibus',
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/asperiores/advertise/advertise/9"
);

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

let body = {
    "title": "iswogbo",
    "age_from": 55,
    "age_to": 709782.2,
    "languages": [
        "temporibus"
    ]
};

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

Request      

PUT api/{ver}/advertise/advertise/{id}

PATCH api/{ver}/advertise/advertise/{id}

URL Parameters

ver  string  

id  string  

The ID of the advertise.

Body Parameters

title  string  

Must not be greater than 255 characters.

genders  string[] optional  

This field is required when genders is present.

age_from  number optional  

Must be at least 1.

age_to  number optional  

languages  string[] optional  

This field is required when languages is present.

location  object optional  

Must have at least {min, plural, =1 {# item} other {# items}}.

Example request:
curl --request DELETE \
    "http://localhost/api/v1/api/ut/advertise/advertise/32"
$client = new \GuzzleHttp\Client();
$response = $client->delete('http://localhost/api/v1/api/ut/advertise/advertise/32');
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/ut/advertise/advertise/32"
);

fetch(url, {
    method: "DELETE",
}).then(response => response.json());

Request      

DELETE api/{ver}/advertise/advertise/{id}

URL Parameters

ver  string  

id  string  

The ID of the advertise.

Example request:
curl --request GET \
    --get "http://localhost/api/v1/api/voluptas/advertise/invoice" \
    --header "Content-Type: application/json" \
    --data "{
    "start_date": "deleniti",
    "end_date": "qui",
    "status": "sunt",
    "page": 3,
    "limit": 19049969.9
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/voluptas/advertise/invoice',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'start_date' => 'deleniti',
            'end_date' => 'qui',
            'status' => 'sunt',
            'page' => 3,
            'limit' => 19049969.9,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/voluptas/advertise/invoice"
);

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

let body = {
    "start_date": "deleniti",
    "end_date": "qui",
    "status": "sunt",
    "page": 3,
    "limit": 19049969.9
};

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

Request      

GET api/{ver}/advertise/invoice

URL Parameters

ver  string  

Body Parameters

start_date  string optional  

end_date  string optional  

status  string optional  

page  number optional  

Must be at least 1.

limit  number optional  

Example request:
curl --request PATCH \
    "http://localhost/api/v1/api/ut/advertise/invoice/cancel/5334"
$client = new \GuzzleHttp\Client();
$response = $client->patch('http://localhost/api/v1/api/ut/advertise/invoice/cancel/5334');
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/ut/advertise/invoice/cancel/5334"
);

fetch(url, {
    method: "PATCH",
}).then(response => response.json());

Request      

PATCH api/{ver}/advertise/invoice/cancel/{id}

URL Parameters

ver  string  

id  string  

The ID of the cancel.

Example request:
curl --request POST \
    "http://localhost/api/v1/api/quam/advertise/invoice/change" \
    --header "Content-Type: application/json" \
    --data "{
    "invoice_id": 9.24132404,
    "item_id": 45,
    "item_type": "delectus",
    "payment_gateway": 39414632
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/quam/advertise/invoice/change',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'invoice_id' => 9.24132404,
            'item_id' => 45,
            'item_type' => 'delectus',
            'payment_gateway' => 39414632.0,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/quam/advertise/invoice/change"
);

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

let body = {
    "invoice_id": 9.24132404,
    "item_id": 45,
    "item_type": "delectus",
    "payment_gateway": 39414632
};

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

Request      

POST api/{ver}/advertise/invoice/change

URL Parameters

ver  string  

Body Parameters

invoice_id  number optional  

item_id  number  

Must be at least 1.

item_type  string  

payment_gateway  number optional  

Example request:
curl --request POST \
    "http://localhost/api/v1/api/voluptatem/advertise/invoice/payment" \
    --header "Content-Type: application/json" \
    --data "{
    "invoice_id": 9335,
    "item_id": 85,
    "item_type": "dolores",
    "payment_gateway": 5585.9355
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/voluptatem/advertise/invoice/payment',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'invoice_id' => 9335.0,
            'item_id' => 85,
            'item_type' => 'dolores',
            'payment_gateway' => 5585.9355,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/voluptatem/advertise/invoice/payment"
);

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

let body = {
    "invoice_id": 9335,
    "item_id": 85,
    "item_type": "dolores",
    "payment_gateway": 5585.9355
};

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

Request      

POST api/{ver}/advertise/invoice/payment

URL Parameters

ver  string  

Body Parameters

invoice_id  number optional  

item_id  number  

Must be at least 1.

item_type  string  

payment_gateway  number optional  

Example request:
curl --request GET \
    --get "http://localhost/api/v1/api/corporis/advertise/sponsor" \
    --header "Content-Type: application/json" \
    --data "{
    "start_date": "soluta",
    "end_date": "quia",
    "status": "iste",
    "page": 70,
    "limit": 65604908
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/corporis/advertise/sponsor',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'start_date' => 'soluta',
            'end_date' => 'quia',
            'status' => 'iste',
            'page' => 70,
            'limit' => 65604908.0,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/corporis/advertise/sponsor"
);

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

let body = {
    "start_date": "soluta",
    "end_date": "quia",
    "status": "iste",
    "page": 70,
    "limit": 65604908
};

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

Request      

GET api/{ver}/advertise/sponsor

URL Parameters

ver  string  

Body Parameters

start_date  string optional  

end_date  string optional  

status  string optional  

page  number optional  

Must be at least 1.

limit  number optional  

Example request:
curl --request POST \
    "http://localhost/api/v1/api/non/advertise/sponsor" \
    --header "Content-Type: application/json" \
    --data "{
    "title": "ztmihaceslerh",
    "age_from": 43,
    "languages": [
        "eos"
    ],
    "start_date": "2024-08-02T08:10:38",
    "item_type": "aspernatur",
    "item_id": 1,
    "total_impression": 92
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/non/advertise/sponsor',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'title' => 'ztmihaceslerh',
            'age_from' => 43,
            'languages' => [
                'eos',
            ],
            'start_date' => '2024-08-02T08:10:38',
            'item_type' => 'aspernatur',
            'item_id' => 1,
            'total_impression' => 92,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/non/advertise/sponsor"
);

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

let body = {
    "title": "ztmihaceslerh",
    "age_from": 43,
    "languages": [
        "eos"
    ],
    "start_date": "2024-08-02T08:10:38",
    "item_type": "aspernatur",
    "item_id": 1,
    "total_impression": 92
};

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

Request      

POST api/{ver}/advertise/sponsor

URL Parameters

ver  string  

Body Parameters

title  string  

Must not be greater than 255 characters.

genders  string[] optional  

This field is required when genders is present.

age_from  integer optional  

Must be at least 1.

age_to  string optional  

languages  string[] optional  

This field is required when languages is present.

location  object optional  

Must have at least {min, plural, =1 {# item} other {# items}}.

start_date  string  

Must be a valid date.

end_date  string optional  

item_type  string  

item_id  integer  

total_impression  integer  

Must be at least 100.

Example request:
curl --request PATCH \
    "http://localhost/api/v1/api/natus/advertise/sponsor/active/0222"
$client = new \GuzzleHttp\Client();
$response = $client->patch('http://localhost/api/v1/api/natus/advertise/sponsor/active/0222');
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/natus/advertise/sponsor/active/0222"
);

fetch(url, {
    method: "PATCH",
}).then(response => response.json());

Request      

PATCH api/{ver}/advertise/sponsor/active/{id}

URL Parameters

ver  string  

id  string  

The ID of the active.

Example request:
curl --request POST \
    "http://localhost/api/v1/api/et/advertise/sponsor/feed" \
    --header "Content-Type: application/json" \
    --data "{
    "title": "iivkvutnvggzodttutln",
    "age_from": 14,
    "languages": [
        "iure"
    ],
    "start_date": "2024-08-02T08:10:38",
    "item_type": "aperiam",
    "item_id": 18,
    "total_impression": 91
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/et/advertise/sponsor/feed',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'title' => 'iivkvutnvggzodttutln',
            'age_from' => 14,
            'languages' => [
                'iure',
            ],
            'start_date' => '2024-08-02T08:10:38',
            'item_type' => 'aperiam',
            'item_id' => 18,
            'total_impression' => 91,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/et/advertise/sponsor/feed"
);

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

let body = {
    "title": "iivkvutnvggzodttutln",
    "age_from": 14,
    "languages": [
        "iure"
    ],
    "start_date": "2024-08-02T08:10:38",
    "item_type": "aperiam",
    "item_id": 18,
    "total_impression": 91
};

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

Request      

POST api/{ver}/advertise/sponsor/feed

URL Parameters

ver  string  

Body Parameters

title  string  

Must not be greater than 255 characters.

genders  string[] optional  

This field is required when genders is present.

age_from  integer optional  

Must be at least 1.

age_to  string optional  

languages  string[] optional  

This field is required when languages is present.

location  object optional  

Must have at least {min, plural, =1 {# item} other {# items}}.

start_date  string  

Must be a valid date.

end_date  string optional  

item_type  string  

item_id  integer  

total_impression  integer  

Must be at least 100.

Example request:
curl --request GET \
    --get "http://localhost/api/v1/api/maxime/advertise/sponsor/form/feed/ipsum/inventore"
$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/maxime/advertise/sponsor/form/feed/ipsum/inventore');
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/maxime/advertise/sponsor/form/feed/ipsum/inventore"
);

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

Request      

GET api/{ver}/advertise/sponsor/form/feed/{itemType}/{itemId}

URL Parameters

ver  string  

itemType  string  

itemId  string  

Example request:
curl --request GET \
    --get "http://localhost/api/v1/api/molestiae/advertise/sponsor/form/laudantium/est"
$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/molestiae/advertise/sponsor/form/laudantium/est');
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/molestiae/advertise/sponsor/form/laudantium/est"
);

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

Request      

GET api/{ver}/advertise/sponsor/form/{itemType}/{itemId}

URL Parameters

ver  string  

itemType  string  

itemId  string  

Example request:
curl --request GET \
    --get "http://localhost/api/v1/api/et/advertise/sponsor/554"
$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/et/advertise/sponsor/554');
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/et/advertise/sponsor/554"
);

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

Request      

GET api/{ver}/advertise/sponsor/{id}

URL Parameters

ver  string  

id  string  

The ID of the sponsor.

Example request:
curl --request PUT \
    "http://localhost/api/v1/api/sint/advertise/sponsor/61" \
    --header "Content-Type: application/json" \
    --data "{
    "title": "renzquucrflhyoashzzk",
    "age_from": 27,
    "languages": [
        "voluptatem"
    ]
}"

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'http://localhost/api/v1/api/sint/advertise/sponsor/61',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'title' => 'renzquucrflhyoashzzk',
            'age_from' => 27,
            'languages' => [
                'voluptatem',
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/sint/advertise/sponsor/61"
);

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

let body = {
    "title": "renzquucrflhyoashzzk",
    "age_from": 27,
    "languages": [
        "voluptatem"
    ]
};

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

Request      

PUT api/{ver}/advertise/sponsor/{id}

PATCH api/{ver}/advertise/sponsor/{id}

URL Parameters

ver  string  

id  string  

The ID of the sponsor.

Body Parameters

title  string  

Must not be greater than 255 characters.

genders  string[] optional  

This field is required when genders is present.

age_from  integer optional  

Must be at least 1.

age_to  string optional  

languages  string[] optional  

This field is required when languages is present.

location  object optional  

Must have at least {min, plural, =1 {# item} other {# items}}.

Example request:
curl --request DELETE \
    "http://localhost/api/v1/api/voluptates/advertise/sponsor/17"
$client = new \GuzzleHttp\Client();
$response = $client->delete('http://localhost/api/v1/api/voluptates/advertise/sponsor/17');
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/voluptates/advertise/sponsor/17"
);

fetch(url, {
    method: "DELETE",
}).then(response => response.json());

Request      

DELETE api/{ver}/advertise/sponsor/{id}

URL Parameters

ver  string  

id  string  

The ID of the sponsor.

Example request:
curl --request POST \
    "http://localhost/api/v1/api/ipsa/sponsor/total/click" \
    --header "Content-Type: application/json" \
    --data "{
    "item_type": "animi",
    "item_ids": []
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/ipsa/sponsor/total/click',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'item_type' => 'animi',
            'item_ids' => [],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/ipsa/sponsor/total/click"
);

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

let body = {
    "item_type": "animi",
    "item_ids": []
};

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

Request      

POST api/{ver}/sponsor/total/click

URL Parameters

ver  string  

Body Parameters

item_type  string  

item_ids  object  

Example request:
curl --request POST \
    "http://localhost/api/v1/api/eligendi/sponsor/total/view" \
    --header "Content-Type: application/json" \
    --data "{
    "item_type": "omnis",
    "item_ids": []
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/eligendi/sponsor/total/view',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'item_type' => 'omnis',
            'item_ids' => [],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/eligendi/sponsor/total/view"
);

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

let body = {
    "item_type": "omnis",
    "item_ids": []
};

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

Request      

POST api/{ver}/sponsor/total/view

URL Parameters

ver  string  

Body Parameters

item_type  string  

item_ids  object  

Announcement

App name: Announcement Version: 5.0.16 Author: phpFox Updated at: Aug 02, 2024

Browse announcement.

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/api/itaque/announcement?limit=10" \
    --header "Authorization: Bearer {accessToken}"
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/itaque/announcement',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
        'query' => [
            'limit'=> '10',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/itaque/announcement"
);

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

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

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

Request      

GET api/{ver}/announcement

URL Parameters

ver  string  

Query Parameters

limit  integer optional  

The items to return.

Browse announcement.

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/api/expedita/announcement/view?announcement_id=308514161.09299&limit=10" \
    --header "Authorization: Bearer {accessToken}"
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/expedita/announcement/view',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
        'query' => [
            'announcement_id'=> '308514161.09299',
            'limit'=> '10',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/expedita/announcement/view"
);

const params = {
    "announcement_id": "308514161.09299",
    "limit": "10",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

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

Request      

GET api/{ver}/announcement/view

URL Parameters

ver  string  

Query Parameters

announcement_id  number  

limit  integer optional  

The items to return.

Hide announcement.

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/api/vitae/announcement/view" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "announcement_id": 64
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/vitae/announcement/view',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'announcement_id' => 64,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/vitae/announcement/view"
);

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

let body = {
    "announcement_id": 64
};

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

Request      

POST api/{ver}/announcement/view

URL Parameters

ver  string  

Body Parameters

announcement_id  number  

Must be at least 1.

View announcement.

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/api/pariatur/announcement/77100" \
    --header "Authorization: Bearer {accessToken}"
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/pariatur/announcement/77100',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/pariatur/announcement/77100"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

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

Request      

GET api/{ver}/announcement/{id}

URL Parameters

ver  string  

id  string  

The ID of the announcement.

Attachments

App name: Attachments Version: 5.0.4 Author: phpFox Updated at: Aug 02, 2024

Upload attachment.

Example request:
curl --request POST \
    "http://localhost/api/v1/api/maxime/attachment" \
    --header "Content-Type: multipart/form-data" \
    --form "storage_id=beatae" \
    --form "item_type=et" \
    --form "upload_type=deleniti" \
    --form "file=@/tmp/phpn1PDDx" 
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/maxime/attachment',
    [
        'headers' => [
            'Content-Type' => 'multipart/form-data',
        ],
        'multipart' => [
            [
                'name' => 'storage_id',
                'contents' => 'beatae'
            ],
            [
                'name' => 'item_type',
                'contents' => 'et'
            ],
            [
                'name' => 'upload_type',
                'contents' => 'deleniti'
            ],
            [
                'name' => 'file',
                'contents' => fopen('/tmp/phpn1PDDx', 'r')
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/maxime/attachment"
);

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

const body = new FormData();
body.append('storage_id', 'beatae');
body.append('item_type', 'et');
body.append('upload_type', 'deleniti');
body.append('file', document.querySelector('input[name="file"]').files[0]);

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

Request      

POST api/{ver}/attachment

URL Parameters

ver  string  

Body Parameters

storage_id  string optional  

file  file  

Must be a file. Must not be greater than 8192 kilobytes.

item_type  string  

upload_type  string optional  

Allow downloading resource.

Example request:
curl --request GET \
    --get "http://localhost/api/v1/api/labore/attachment/download/3"
$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/labore/attachment/download/3');
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/labore/attachment/download/3"
);

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

Request      

GET api/{ver}/attachment/download/{id}

URL Parameters

ver  string  

id  string  

The ID of the download.

Authorization

App name: Authorization Version: 5.0.14 Author: phpFox Updated at: Aug 02, 2024

Store item.

Example request:
curl --request POST \
    "http://localhost/api/v1/api/autem/authorization/device" \
    --header "Content-Type: application/json" \
    --data "{
    "device_token": "molestias",
    "device_id": "ea",
    "device_uid": "qui",
    "token_source": "dolores",
    "platform": "officia",
    "platform_version": "alias"
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/autem/authorization/device',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'device_token' => 'molestias',
            'device_id' => 'ea',
            'device_uid' => 'qui',
            'token_source' => 'dolores',
            'platform' => 'officia',
            'platform_version' => 'alias',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/autem/authorization/device"
);

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

let body = {
    "device_token": "molestias",
    "device_id": "ea",
    "device_uid": "qui",
    "token_source": "dolores",
    "platform": "officia",
    "platform_version": "alias"
};

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

Request      

POST api/{ver}/authorization/device

URL Parameters

ver  string  

Body Parameters

device_token  string  

device_id  string  

device_uid  string optional  

token_source  string  

platform  string optional  

platform_version  string optional  

extra  object optional  

PATCH api/{ver}/authorization/device/logout-all

Example request:
curl --request PATCH \
    "http://localhost/api/v1/api/aut/authorization/device/logout-all"
$client = new \GuzzleHttp\Client();
$response = $client->patch('http://localhost/api/v1/api/aut/authorization/device/logout-all');
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/aut/authorization/device/logout-all"
);

fetch(url, {
    method: "PATCH",
}).then(response => response.json());

Request      

PATCH api/{ver}/authorization/device/logout-all

URL Parameters

ver  string  

Blog

App name: Blog Version: 5.0.17 Author: phpFox Updated at: Aug 02, 2024

Browse blog.

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/api/doloremque/blog?q=omnis&view=all&sort=latest&sort_type=asc&when=this_month&category_id=17&user_id=0&owner_id=15&page=47&limit=16" \
    --header "Authorization: Bearer {accessToken}"
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/doloremque/blog',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
        'query' => [
            'q'=> 'omnis',
            'view'=> 'all',
            'sort'=> 'latest',
            'sort_type'=> 'asc',
            'when'=> 'this_month',
            'category_id'=> '17',
            'user_id'=> '0',
            'owner_id'=> '15',
            'page'=> '47',
            'limit'=> '16',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/doloremque/blog"
);

const params = {
    "q": "omnis",
    "view": "all",
    "sort": "latest",
    "sort_type": "asc",
    "when": "this_month",
    "category_id": "17",
    "user_id": "0",
    "owner_id": "15",
    "page": "47",
    "limit": "16",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

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

Request      

GET api/{ver}/blog

URL Parameters

ver  string  

Query Parameters

q  string optional  

view  string optional  

Must be one of all, my, pending, feature, sponsor, search, my_pending, draft, or friend.

sort  string optional  

Must be one of recent, most_discussed, most_viewed, most_liked, or latest.

sort_type  string optional  

Must be one of desc or asc.

when  string optional  

Must be one of all, this_month, this_week, or today.

category_id  integer optional  

user_id  integer optional  

The profile id to filter.

owner_id  integer optional  

page  integer optional  

Must be at least 1.

limit  integer optional  

is_featured  string optional  

Create blog.

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/api/dolore/blog" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "title": "et",
    "categories": [
        43.6
    ],
    "owner_id": 153.716,
    "file": {
        "temp_file": 67735.097656496
    },
    "text": "eos",
    "draft": 6132.264,
    "tags": [
        "ad"
    ],
    "privacy": "dolore",
    "attachments": [
        "veritatis"
    ]
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/dolore/blog',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'title' => 'et',
            'categories' => [
                43.6,
            ],
            'owner_id' => 153.716,
            'file' => [
                'temp_file' => 67735.097656496,
            ],
            'text' => 'eos',
            'draft' => 6132.264,
            'tags' => [
                'ad',
            ],
            'privacy' => 'dolore',
            'attachments' => [
                'veritatis',
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/dolore/blog"
);

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

let body = {
    "title": "et",
    "categories": [
        43.6
    ],
    "owner_id": 153.716,
    "file": {
        "temp_file": 67735.097656496
    },
    "text": "eos",
    "draft": 6132.264,
    "tags": [
        "ad"
    ],
    "privacy": "dolore",
    "attachments": [
        "veritatis"
    ]
};

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

Request      

POST api/{ver}/blog

URL Parameters

ver  string  

Body Parameters

title  string  

categories  number[] optional  

owner_id  number optional  

file  object optional  

file.temp_file  number optional  

This field is required when file is present.

text  string  

draft  number optional  

tags  string[] optional  

privacy  string  

captcha  string optional  

attachments  number[] optional  

attachments[].id  number optional  

attachments[].status  string optional  

Display a listing of the resource.

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/api/ad/blog-category" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "id": 0,
    "page": 11,
    "q": "quia",
    "level": 44382,
    "limit": 4450.50019
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/ad/blog-category',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'id' => 0.0,
            'page' => 11,
            'q' => 'quia',
            'level' => 44382.0,
            'limit' => 4450.50019,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/ad/blog-category"
);

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

let body = {
    "id": 0,
    "page": 11,
    "q": "quia",
    "level": 44382,
    "limit": 4450.50019
};

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

Request      

GET api/{ver}/blog-category

URL Parameters

ver  string  

Body Parameters

id  number optional  

page  number optional  

Must be at least 1.

q  string optional  

level  number optional  

limit  number optional  

Approve blog.

requires authentication

Example request:
curl --request PATCH \
    "http://localhost/api/v1/api/eligendi/blog/approve/2336" \
    --header "Authorization: Bearer {accessToken}"
$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://localhost/api/v1/api/eligendi/blog/approve/2336',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/eligendi/blog/approve/2336"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

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

Request      

PATCH api/{ver}/blog/approve/{id}

URL Parameters

ver  string  

id  string  

The ID of the approve.

Feature blog.

requires authentication

Example request:
curl --request PATCH \
    "http://localhost/api/v1/api/totam/blog/feature/91521" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "feature": "1"
}"

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://localhost/api/v1/api/totam/blog/feature/91521',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'feature' => '1',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/totam/blog/feature/91521"
);

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

let body = {
    "feature": "1"
};

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

Request      

PATCH api/{ver}/blog/feature/{id}

URL Parameters

ver  string  

id  string  

The ID of the feature.

Body Parameters

feature  number  

Must be one of 0 or 1.

GET api/{ver}/blog/form

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/api/rerum/blog/form" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "owner_id": 14.44484
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/rerum/blog/form',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'owner_id' => 14.44484,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/rerum/blog/form"
);

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

let body = {
    "owner_id": 14.44484
};

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

Request      

GET api/{ver}/blog/form

URL Parameters

ver  string  

Body Parameters

owner_id  number optional  

GET api/{ver}/blog/form/{id}

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/api/alias/blog/form/8124" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "owner_id": 27
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/alias/blog/form/8124',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'owner_id' => 27.0,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/alias/blog/form/8124"
);

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

let body = {
    "owner_id": 27
};

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

Request      

GET api/{ver}/blog/form/{id}

URL Parameters

ver  string  

id  string  

The ID of the form.

Body Parameters

owner_id  number optional  

Publish blog.

requires authentication

Example request:
curl --request PATCH \
    "http://localhost/api/v1/api/totam/blog/publish/14" \
    --header "Authorization: Bearer {accessToken}"
$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://localhost/api/v1/api/totam/blog/publish/14',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/totam/blog/publish/14"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

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

Request      

PATCH api/{ver}/blog/publish/{id}

URL Parameters

ver  string  

id  string  

The ID of the publish.

Get search form.

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/api/et/blog/search-form" \
    --header "Authorization: Bearer {accessToken}"
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/et/blog/search-form',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/et/blog/search-form"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

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

Request      

GET api/{ver}/blog/search-form

URL Parameters

ver  string  

Sponsor blog in feed.

requires authentication

Example request:
curl --request PATCH \
    "http://localhost/api/v1/api/exercitationem/blog/sponsor-in-feed/4" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "sponsor": 219
}"

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://localhost/api/v1/api/exercitationem/blog/sponsor-in-feed/4',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'sponsor' => 219.0,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/exercitationem/blog/sponsor-in-feed/4"
);

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

let body = {
    "sponsor": 219
};

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

Request      

PATCH api/{ver}/blog/sponsor-in-feed/{id}

URL Parameters

ver  string  

id  string  

The ID of the sponsor in feed.

Body Parameters

sponsor  number  

Sponsor blog.

requires authentication

Example request:
curl --request PATCH \
    "http://localhost/api/v1/api/consequatur/blog/sponsor/84586" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "sponsor": "eligendi"
}"

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://localhost/api/v1/api/consequatur/blog/sponsor/84586',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'sponsor' => 'eligendi',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/consequatur/blog/sponsor/84586"
);

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

let body = {
    "sponsor": "eligendi"
};

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

Request      

PATCH api/{ver}/blog/sponsor/{id}

URL Parameters

ver  string  

id  string  

The ID of the sponsor.

Body Parameters

sponsor  string  

View Blog.

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/api/sequi/blog/2" \
    --header "Authorization: Bearer {accessToken}"
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/sequi/blog/2',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/sequi/blog/2"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

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

Request      

GET api/{ver}/blog/{id}

URL Parameters

ver  string  

id  string  

The ID of the blog.

Update blog.

requires authentication

Example request:
curl --request PUT \
    "http://localhost/api/v1/api/sed/blog/13" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "title": "rerum",
    "categories": [
        80
    ],
    "file": {
        "temp_file": 66.78084,
        "status": "et"
    },
    "text": "possimus",
    "tags": [
        "magni"
    ],
    "draft": 28883.7489,
    "published": true,
    "attachments": [
        "nisi"
    ]
}"

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'http://localhost/api/v1/api/sed/blog/13',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'title' => 'rerum',
            'categories' => [
                80,
            ],
            'file' => [
                'temp_file' => 66.78084,
                'status' => 'et',
            ],
            'text' => 'possimus',
            'tags' => [
                'magni',
            ],
            'draft' => 28883.7489,
            'published' => true,
            'attachments' => [
                'nisi',
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/sed/blog/13"
);

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

let body = {
    "title": "rerum",
    "categories": [
        80
    ],
    "file": {
        "temp_file": 66.78084,
        "status": "et"
    },
    "text": "possimus",
    "tags": [
        "magni"
    ],
    "draft": 28883.7489,
    "published": true,
    "attachments": [
        "nisi"
    ]
};

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

Request      

PUT api/{ver}/blog/{id}

PATCH api/{ver}/blog/{id}

URL Parameters

ver  string  

id  string  

The ID of the blog.

Body Parameters

title  string optional  

categories  integer[] optional  

Must be at least 1.

file  object optional  

file.temp_file  number optional  

This field is required when file.status is update.

file.status  string optional  

This field is required when file is present.

text  string optional  

tags  string[] optional  

draft  number optional  

published  boolean optional  

privacy  string optional  

attachments  number[] optional  

attachments[].id  number optional  

attachments[].status  string optional  

captcha  string optional  

Delete blog.

requires authentication

Example request:
curl --request DELETE \
    "http://localhost/api/v1/api/dolor/blog/8" \
    --header "Authorization: Bearer {accessToken}"
$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://localhost/api/v1/api/dolor/blog/8',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/dolor/blog/8"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

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

Request      

DELETE api/{ver}/blog/{id}

URL Parameters

ver  string  

id  string  

The ID of the blog.

CAPTCHA

App name: CAPTCHA Version: 5.0.11 Author: phpFox Updated at: Aug 02, 2024

POST api/{ver}/captcha/verify

Example request:
curl --request POST \
    "http://localhost/api/v1/api/illum/captcha/verify" \
    --header "Content-Type: application/json" \
    --data "{
    "action_name": "velit"
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/illum/captcha/verify',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'action_name' => 'velit',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/illum/captcha/verify"
);

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

let body = {
    "action_name": "velit"
};

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

Request      

POST api/{ver}/captcha/verify

URL Parameters

ver  string  

Body Parameters

action_name  string optional  

captcha  string optional  

POST api/{ver}/image-captcha/refresh

Example request:
curl --request POST \
    "http://localhost/api/v1/api/reiciendis/image-captcha/refresh"
$client = new \GuzzleHttp\Client();
$response = $client->post('http://localhost/api/v1/api/reiciendis/image-captcha/refresh');
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/reiciendis/image-captcha/refresh"
);

fetch(url, {
    method: "POST",
}).then(response => response.json());

Request      

POST api/{ver}/image-captcha/refresh

URL Parameters

ver  string  

Chat

App name: Chat Version: 5.0.18 Author: phpFox Updated at: Aug 02, 2024

GET api/{ver}/chat

Example request:
curl --request GET \
    --get "http://localhost/api/v1/api/beatae/chat" \
    --header "Content-Type: application/json" \
    --data "{
    "q": "qui",
    "message_id": 1774.7,
    "room_id": 0.6,
    "last_message_id": 808.6239,
    "scroll": "perspiciatis",
    "upper_bound": 17,
    "lower_bound": 66,
    "page": 30,
    "limit": 14
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/beatae/chat',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'q' => 'qui',
            'message_id' => 1774.7,
            'room_id' => 0.6,
            'last_message_id' => 808.6239,
            'scroll' => 'perspiciatis',
            'upper_bound' => 17,
            'lower_bound' => 66,
            'page' => 30,
            'limit' => 14,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/beatae/chat"
);

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

let body = {
    "q": "qui",
    "message_id": 1774.7,
    "room_id": 0.6,
    "last_message_id": 808.6239,
    "scroll": "perspiciatis",
    "upper_bound": 17,
    "lower_bound": 66,
    "page": 30,
    "limit": 14
};

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

Request      

GET api/{ver}/chat

URL Parameters

ver  string  

Body Parameters

q  string optional  

message_id  number optional  

room_id  number  

last_message_id  number optional  

scroll  string optional  

upper_bound  number optional  

Must be at least 1.

lower_bound  number optional  

Must be at least 1.

page  integer optional  

Must be at least 1.

limit  integer optional  

POST api/{ver}/chat

Example request:
curl --request POST \
    "http://localhost/api/v1/api/esse/chat" \
    --header "Content-Type: application/json" \
    --data "{
    "room_id": 73924092.65,
    "message": "natus",
    "type": "voluptatem",
    "reply_id": 3,
    "tempId": "suscipit",
    "attachments": [
        "magnam"
    ]
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/esse/chat',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'room_id' => 73924092.65,
            'message' => 'natus',
            'type' => 'voluptatem',
            'reply_id' => 3,
            'tempId' => 'suscipit',
            'attachments' => [
                'magnam',
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/esse/chat"
);

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

let body = {
    "room_id": 73924092.65,
    "message": "natus",
    "type": "voluptatem",
    "reply_id": 3,
    "tempId": "suscipit",
    "attachments": [
        "magnam"
    ]
};

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

Request      

POST api/{ver}/chat

URL Parameters

ver  string  

Body Parameters

room_id  number optional  

message  string optional  

type  string optional  

reply_id  integer optional  

tempId  string optional  

attachments  number[] optional  

attachments[].id  number optional  

attachments[].status  string optional  

GET api/{ver}/chat-room

Example request:
curl --request GET \
    --get "http://localhost/api/v1/api/sit/chat-room" \
    --header "Content-Type: application/json" \
    --data "{
    "q": "dolores",
    "page": 22,
    "limit": 16
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/sit/chat-room',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'q' => 'dolores',
            'page' => 22,
            'limit' => 16,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/sit/chat-room"
);

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

let body = {
    "q": "dolores",
    "page": 22,
    "limit": 16
};

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

Request      

GET api/{ver}/chat-room

URL Parameters

ver  string  

Body Parameters

q  string optional  

page  integer optional  

Must be at least 1.

limit  integer optional  

POST api/{ver}/chat-room

Example request:
curl --request POST \
    "http://localhost/api/v1/api/illum/chat-room" \
    --header "Content-Type: application/json" \
    --data "{
    "member_ids": [
        543269.332345123
    ],
    "users": [
        "modi"
    ]
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/illum/chat-room',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'member_ids' => [
                543269.332345123,
            ],
            'users' => [
                'modi',
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/illum/chat-room"
);

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

let body = {
    "member_ids": [
        543269.332345123
    ],
    "users": [
        "modi"
    ]
};

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

Request      

POST api/{ver}/chat-room

URL Parameters

ver  string  

Body Parameters

member_ids  number[] optional  

users  number[] optional  

users[].id  number optional  

GET api/{ver}/chat-room/addForm

Example request:
curl --request GET \
    --get "http://localhost/api/v1/api/magni/chat-room/addForm"
$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/magni/chat-room/addForm');
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/magni/chat-room/addForm"
);

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

Request      

GET api/{ver}/chat-room/addForm

URL Parameters

ver  string  

PUT api/{ver}/chat-room/mark-all-read

Example request:
curl --request PUT \
    "http://localhost/api/v1/api/qui/chat-room/mark-all-read" \
    --header "Content-Type: application/json" \
    --data "{
    "room_ids": [
        372330.412638
    ]
}"

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'http://localhost/api/v1/api/qui/chat-room/mark-all-read',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'room_ids' => [
                372330.412638,
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/qui/chat-room/mark-all-read"
);

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

let body = {
    "room_ids": [
        372330.412638
    ]
};

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

Request      

PUT api/{ver}/chat-room/mark-all-read

URL Parameters

ver  string  

Body Parameters

room_ids  number[] optional  

PUT api/{ver}/chat-room/mark-read/{id}

Example request:
curl --request PUT \
    "http://localhost/api/v1/api/omnis/chat-room/mark-read/8501"
$client = new \GuzzleHttp\Client();
$response = $client->put('http://localhost/api/v1/api/omnis/chat-room/mark-read/8501');
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/omnis/chat-room/mark-read/8501"
);

fetch(url, {
    method: "PUT",
}).then(response => response.json());

Request      

PUT api/{ver}/chat-room/mark-read/{id}

URL Parameters

ver  string  

id  string  

The ID of the mark read.

GET api/{ver}/chat-room/{id}

Example request:
curl --request GET \
    --get "http://localhost/api/v1/api/et/chat-room/291"
$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/et/chat-room/291');
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/et/chat-room/291"
);

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

Request      

GET api/{ver}/chat-room/{id}

URL Parameters

ver  string  

id  string  

The ID of the chat room.

DELETE api/{ver}/chat-room/{id}

Example request:
curl --request DELETE \
    "http://localhost/api/v1/api/expedita/chat-room/3321"
$client = new \GuzzleHttp\Client();
$response = $client->delete('http://localhost/api/v1/api/expedita/chat-room/3321');
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/expedita/chat-room/3321"
);

fetch(url, {
    method: "DELETE",
}).then(response => response.json());

Request      

DELETE api/{ver}/chat-room/{id}

URL Parameters

ver  string  

id  string  

The ID of the chat room.

Display the specified resource.

Example request:
curl --request GET \
    --get "http://localhost/api/v1/api/dolores/chat/download/472558"
$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/dolores/chat/download/472558');
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/dolores/chat/download/472558"
);

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

Request      

GET api/{ver}/chat/download/{id}

URL Parameters

ver  string  

id  string  

The ID of the download.

PUT api/{ver}/chat/react/{id}

Example request:
curl --request PUT \
    "http://localhost/api/v1/api/culpa/chat/react/1" \
    --header "Content-Type: application/json" \
    --data "{
    "react": "autem",
    "remove": false
}"

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'http://localhost/api/v1/api/culpa/chat/react/1',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'react' => 'autem',
            'remove' => false,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/culpa/chat/react/1"
);

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

let body = {
    "react": "autem",
    "remove": false
};

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

Request      

PUT api/{ver}/chat/react/{id}

URL Parameters

ver  string  

id  string  

The ID of the react.

Body Parameters

react  string optional  

remove  boolean optional  

PUT api/{ver}/chat/remove/{id}

Example request:
curl --request PUT \
    "http://localhost/api/v1/api/voluptatem/chat/remove/36216"
$client = new \GuzzleHttp\Client();
$response = $client->put('http://localhost/api/v1/api/voluptatem/chat/remove/36216');
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/voluptatem/chat/remove/36216"
);

fetch(url, {
    method: "PUT",
}).then(response => response.json());

Request      

PUT api/{ver}/chat/remove/{id}

URL Parameters

ver  string  

id  string  

The ID of the remove.

GET api/{ver}/chat/{id}

Example request:
curl --request GET \
    --get "http://localhost/api/v1/api/enim/chat/2"
$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/enim/chat/2');
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/enim/chat/2"
);

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

Request      

GET api/{ver}/chat/{id}

URL Parameters

ver  string  

id  string  

The ID of the chat.

PUT api/{ver}/chat/{id}

Example request:
curl --request PUT \
    "http://localhost/api/v1/api/dolores/chat/30" \
    --header "Content-Type: application/json" \
    --data "{
    "message": "laudantium",
    "type": "dolorum"
}"

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'http://localhost/api/v1/api/dolores/chat/30',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'message' => 'laudantium',
            'type' => 'dolorum',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/dolores/chat/30"
);

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

let body = {
    "message": "laudantium",
    "type": "dolorum"
};

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

Request      

PUT api/{ver}/chat/{id}

PATCH api/{ver}/chat/{id}

URL Parameters

ver  string  

id  string  

The ID of the chat.

Body Parameters

message  string optional  

type  string optional  

ChatPlus

App name: ChatPlus Version: 5.0.24 Author: phpFox Updated at: Aug 02, 2024

GET api/{ver}/chatplus/can-create-direct-message/{type}/{id_from}/{id_to}

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/api/incidunt/chatplus/can-create-direct-message/aspernatur/facilis/in" \
    --header "Authorization: Bearer {accessToken}"
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/incidunt/chatplus/can-create-direct-message/aspernatur/facilis/in',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/incidunt/chatplus/can-create-direct-message/aspernatur/facilis/in"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

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

Request      

GET api/{ver}/chatplus/can-create-direct-message/{type}/{id_from}/{id_to}

URL Parameters

ver  string  

type  string  

id_from  string  

id_to  string  

GET api/{ver}/chatplus/export-users

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/api/nemo/chatplus/export-users" \
    --header "Authorization: Bearer {accessToken}"
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/nemo/chatplus/export-users',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/nemo/chatplus/export-users"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

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

Request      

GET api/{ver}/chatplus/export-users

URL Parameters

ver  string  

GET api/{ver}/chatplus/jobs

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/api/maiores/chatplus/jobs" \
    --header "Authorization: Bearer {accessToken}"
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/maiores/chatplus/jobs',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/maiores/chatplus/jobs"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

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

Request      

GET api/{ver}/chatplus/jobs

URL Parameters

ver  string  

GET api/{ver}/chatplus/me

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/api/recusandae/chatplus/me" \
    --header "Authorization: Bearer {accessToken}"
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/recusandae/chatplus/me',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/recusandae/chatplus/me"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

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

Request      

GET api/{ver}/chatplus/me

URL Parameters

ver  string  

GET api/{ver}/chatplus/prefetch-users

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/api/dolores/chatplus/prefetch-users" \
    --header "Authorization: Bearer {accessToken}"
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/dolores/chatplus/prefetch-users',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/dolores/chatplus/prefetch-users"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

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

Request      

GET api/{ver}/chatplus/prefetch-users

URL Parameters

ver  string  

POST api/{ver}/chatplus/rooms/upload/{room_id}

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/api/numquam/chatplus/rooms/upload/cupiditate" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "userId": "eum",
    "roomId": "neque",
    "token": "laudantium",
    "msg": "voluptatum",
    "file": []
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/numquam/chatplus/rooms/upload/cupiditate',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'userId' => 'eum',
            'roomId' => 'neque',
            'token' => 'laudantium',
            'msg' => 'voluptatum',
            'file' => [],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/numquam/chatplus/rooms/upload/cupiditate"
);

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

let body = {
    "userId": "eum",
    "roomId": "neque",
    "token": "laudantium",
    "msg": "voluptatum",
    "file": []
};

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

Request      

POST api/{ver}/chatplus/rooms/upload/{room_id}

URL Parameters

ver  string  

room_id  string  

The ID of the room.

Body Parameters

userId  string  

roomId  string  

token  string  

msg  string optional  

file  object  

GET api/{ver}/chatplus/settings

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/api/omnis/chatplus/settings" \
    --header "Authorization: Bearer {accessToken}"
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/omnis/chatplus/settings',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/omnis/chatplus/settings"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

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

Request      

GET api/{ver}/chatplus/settings

URL Parameters

ver  string  

GET api/{ver}/chatplus/spotlight

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/api/sint/chatplus/spotlight" \
    --header "Authorization: Bearer {accessToken}"
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/sint/chatplus/spotlight',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/sint/chatplus/spotlight"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

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

Request      

GET api/{ver}/chatplus/spotlight

URL Parameters

ver  string  

GET api/{ver}/chatplus/user/{type}/{query}

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/api/aliquid/chatplus/user/dolorem/enim" \
    --header "Authorization: Bearer {accessToken}"
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/aliquid/chatplus/user/dolorem/enim',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/aliquid/chatplus/user/dolorem/enim"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

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

Request      

GET api/{ver}/chatplus/user/{type}/{query}

URL Parameters

ver  string  

type  string  

query  string  

Comment

App name: Comment Version: 5.0.18 Author: phpFox Updated at: Aug 02, 2024

Browse comments.

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/api/amet/comment" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "item_id": 101429069.948,
    "item_type": "aut",
    "parent_id": 5.65656,
    "page": 40,
    "limit": 88,
    "sort": "autem",
    "sort_type": "sit",
    "last_id": 0.085758,
    "excludes": [
        3.5701
    ],
    "comment_id": 16
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/amet/comment',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'item_id' => 101429069.948,
            'item_type' => 'aut',
            'parent_id' => 5.65656,
            'page' => 40,
            'limit' => 88.0,
            'sort' => 'autem',
            'sort_type' => 'sit',
            'last_id' => 0.085758,
            'excludes' => [
                3.5701,
            ],
            'comment_id' => 16,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/amet/comment"
);

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

let body = {
    "item_id": 101429069.948,
    "item_type": "aut",
    "parent_id": 5.65656,
    "page": 40,
    "limit": 88,
    "sort": "autem",
    "sort_type": "sit",
    "last_id": 0.085758,
    "excludes": [
        3.5701
    ],
    "comment_id": 16
};

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

Request      

GET api/{ver}/comment

URL Parameters

ver  string  

Body Parameters

item_id  number  

item_type  string  

parent_id  number optional  

page  number optional  

Must be at least 1.

limit  number optional  

sort  string optional  

sort_type  string optional  

last_id  number optional  

excludes  number[] optional  

comment_id  integer optional  

Create comment.

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/api/consectetur/comment" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "item_id": 78004,
    "item_type": "aperiam",
    "text": "vero",
    "parent_id": 52569535.72,
    "photo_id": 459.591,
    "sticker_id": 133297958.92801
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/consectetur/comment',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'item_id' => 78004.0,
            'item_type' => 'aperiam',
            'text' => 'vero',
            'parent_id' => 52569535.72,
            'photo_id' => 459.591,
            'sticker_id' => 133297958.92801,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/consectetur/comment"
);

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

let body = {
    "item_id": 78004,
    "item_type": "aperiam",
    "text": "vero",
    "parent_id": 52569535.72,
    "photo_id": 459.591,
    "sticker_id": 133297958.92801
};

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

Request      

POST api/{ver}/comment

URL Parameters

ver  string  

Body Parameters

item_id  number  

item_type  string  

text  string optional  

This field is required when none of photo_id and sticker_id are present.

parent_id  number optional  

photo_id  number optional  

sticker_id  number optional  

captcha  string optional  

GET api/{ver}/comment-lists

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/api/qui/comment-lists" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "item_id": 7027.62989,
    "item_type": "expedita",
    "parent_id": 179886608.8894273,
    "page": 76,
    "limit": 861.393965,
    "sort": "aut",
    "sort_type": "et",
    "last_id": 19.62853041,
    "excludes": [
        89659.7
    ],
    "comment_id": 12
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/qui/comment-lists',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'item_id' => 7027.62989,
            'item_type' => 'expedita',
            'parent_id' => 179886608.8894273,
            'page' => 76,
            'limit' => 861.393965,
            'sort' => 'aut',
            'sort_type' => 'et',
            'last_id' => 19.62853041,
            'excludes' => [
                89659.7,
            ],
            'comment_id' => 12,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/qui/comment-lists"
);

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

let body = {
    "item_id": 7027.62989,
    "item_type": "expedita",
    "parent_id": 179886608.8894273,
    "page": 76,
    "limit": 861.393965,
    "sort": "aut",
    "sort_type": "et",
    "last_id": 19.62853041,
    "excludes": [
        89659.7
    ],
    "comment_id": 12
};

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

Request      

GET api/{ver}/comment-lists

URL Parameters

ver  string  

Body Parameters

item_id  number  

item_type  string  

parent_id  number optional  

page  number optional  

Must be at least 1.

limit  number optional  

sort  string optional  

sort_type  string optional  

last_id  number optional  

excludes  number[] optional  

comment_id  integer optional  

Approve comment.

requires authentication

Example request:
curl --request PATCH \
    "http://localhost/api/v1/api/ad/comment/approve/0" \
    --header "Authorization: Bearer {accessToken}"
$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://localhost/api/v1/api/ad/comment/approve/0',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/ad/comment/approve/0"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

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

Request      

PATCH api/{ver}/comment/approve/{id}

URL Parameters

ver  string  

id  string  

The ID of the approve.

GET api/{ver}/comment/download/{id}

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/api/ea/comment/download/9616" \
    --header "Authorization: Bearer {accessToken}"
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/ea/comment/download/9616',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/ea/comment/download/9616"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

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

Request      

GET api/{ver}/comment/download/{id}

URL Parameters

ver  string  

id  string  

The ID of the download.

POST api/{ver}/comment/hide

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/api/voluptates/comment/hide" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "comment_id": 86728.058328,
    "is_hidden": "illum"
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/voluptates/comment/hide',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'comment_id' => 86728.058328,
            'is_hidden' => 'illum',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/voluptates/comment/hide"
);

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

let body = {
    "comment_id": 86728.058328,
    "is_hidden": "illum"
};

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

Request      

POST api/{ver}/comment/hide

URL Parameters

ver  string  

Body Parameters

comment_id  number  

is_hidden  string  

is_global  string optional  

GET api/{ver}/comment/history-edit/{id}

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/api/sed/comment/history-edit/005" \
    --header "Authorization: Bearer {accessToken}"
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/sed/comment/history-edit/005',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/sed/comment/history-edit/005"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

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

Request      

GET api/{ver}/comment/history-edit/{id}

URL Parameters

ver  string  

id  string  

The ID of the history edit.

GET api/{ver}/comment/preview/{id}

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/api/maiores/comment/preview/04597" \
    --header "Authorization: Bearer {accessToken}"
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/maiores/comment/preview/04597',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/maiores/comment/preview/04597"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

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

Request      

GET api/{ver}/comment/preview/{id}

URL Parameters

ver  string  

id  string  

The ID of the preview.

GET api/{ver}/comment/related-comment

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/api/at/comment/related-comment" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "item_id": 1036337.1141512138,
    "item_type": "animi",
    "parent_id": 28464558.22,
    "page": 16,
    "limit": 22405.6465881,
    "sort": "vel",
    "sort_type": "error",
    "last_id": 222489,
    "excludes": [
        2.557
    ],
    "comment_id": 4
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/at/comment/related-comment',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'item_id' => 1036337.1141512138,
            'item_type' => 'animi',
            'parent_id' => 28464558.22,
            'page' => 16,
            'limit' => 22405.6465881,
            'sort' => 'vel',
            'sort_type' => 'error',
            'last_id' => 222489.0,
            'excludes' => [
                2.557,
            ],
            'comment_id' => 4,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/at/comment/related-comment"
);

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

let body = {
    "item_id": 1036337.1141512138,
    "item_type": "animi",
    "parent_id": 28464558.22,
    "page": 16,
    "limit": 22405.6465881,
    "sort": "vel",
    "sort_type": "error",
    "last_id": 222489,
    "excludes": [
        2.557
    ],
    "comment_id": 4
};

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

Request      

GET api/{ver}/comment/related-comment

URL Parameters

ver  string  

Body Parameters

item_id  number  

item_type  string  

parent_id  number optional  

page  number optional  

Must be at least 1.

limit  number optional  

sort  string optional  

sort_type  string optional  

last_id  number optional  

excludes  number[] optional  

comment_id  integer optional  

GET api/{ver}/comment/reply/{id}

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/api/cumque/comment/reply/03" \
    --header "Authorization: Bearer {accessToken}"
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/cumque/comment/reply/03',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/cumque/comment/reply/03"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

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

Request      

GET api/{ver}/comment/reply/{id}

URL Parameters

ver  string  

id  string  

The ID of the reply.

GET api/{ver}/comment/translate

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/api/ex/comment/translate" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "id": 9,
    "target": "dolores"
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/ex/comment/translate',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'id' => 9,
            'target' => 'dolores',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/ex/comment/translate"
);

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

let body = {
    "id": 9,
    "target": "dolores"
};

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

Request      

GET api/{ver}/comment/translate

URL Parameters

ver  string  

Body Parameters

id  integer  

target  string optional  

View comment.

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/api/quo/comment/2" \
    --header "Authorization: Bearer {accessToken}"
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/quo/comment/2',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/quo/comment/2"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

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

Request      

GET api/{ver}/comment/{id}

URL Parameters

ver  string  

id  string  

The ID of the comment.

Update comment.

requires authentication

Example request:
curl --request PUT \
    "http://localhost/api/v1/api/ab/comment/4620" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "text": "ut",
    "is_hide": 301658454.7211105
}"

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'http://localhost/api/v1/api/ab/comment/4620',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'text' => 'ut',
            'is_hide' => 301658454.7211105,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/ab/comment/4620"
);

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

let body = {
    "text": "ut",
    "is_hide": 301658454.7211105
};

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

Request      

PUT api/{ver}/comment/{id}

PATCH api/{ver}/comment/{id}

URL Parameters

ver  string  

id  string  

The ID of the comment.

Body Parameters

text  string optional  

photo_id  string optional  

is_hide  number optional  

sticker_id  string optional  

Remove comment.

requires authentication

Example request:
curl --request DELETE \
    "http://localhost/api/v1/api/vero/comment/6" \
    --header "Authorization: Bearer {accessToken}"
$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://localhost/api/v1/api/vero/comment/6',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/vero/comment/6"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

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

Request      

DELETE api/{ver}/comment/{id}

URL Parameters

ver  string  

id  string  

The ID of the comment.

PATCH api/{ver}/comment/{id}/remove-preview

requires authentication

Example request:
curl --request PATCH \
    "http://localhost/api/v1/api/est/comment/40/remove-preview" \
    --header "Authorization: Bearer {accessToken}"
$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://localhost/api/v1/api/est/comment/40/remove-preview',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/est/comment/40/remove-preview"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

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

Request      

PATCH api/{ver}/comment/{id}/remove-preview

URL Parameters

ver  string  

id  string  

The ID of the comment.

Contact

App name: Contact Version: 5.0.14 Author: phpFox Updated at: Aug 02, 2024

Store item.

Example request:
curl --request POST \
    "http://localhost/api/v1/api/nostrum/contact" \
    --header "Content-Type: application/json" \
    --data "{
    "category_id": 6,
    "full_name": "rf",
    "subject": "j",
    "email": "[email protected]",
    "message": "culpa",
    "send_copy": 2
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/nostrum/contact',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'category_id' => 6,
            'full_name' => 'rf',
            'subject' => 'j',
            'email' => '[email protected]',
            'message' => 'culpa',
            'send_copy' => 2,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/nostrum/contact"
);

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

let body = {
    "category_id": 6,
    "full_name": "rf",
    "subject": "j",
    "email": "[email protected]",
    "message": "culpa",
    "send_copy": 2
};

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

Request      

POST api/{ver}/contact

URL Parameters

ver  string  

Body Parameters

category_id  integer  

full_name  string  

Must be between 1 and 255 characters.

subject  string  

Must be between 1 and 255 characters.

email  string  

Must be a valid email address. Must be between 1 and 255 characters.

message  string  

send_copy  integer optional  

captcha  string optional  

Core

App name: Core Version: 5.1.13 Author: phpFox Updated at: Aug 02, 2024

View frontend settings.

Example request:
curl --request GET \
    --get "http://localhost/api/v1/api/eligendi/core/admin/settings/ab"
$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/eligendi/core/admin/settings/ab');
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/eligendi/core/admin/settings/ab"
);

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

Request      

GET api/{ver}/core/admin/settings/{revision?}

URL Parameters

ver  string  

revision  string optional  

GET api/{ver}/core/custom-privacy-option

Example request:
curl --request GET \
    --get "http://localhost/api/v1/api/et/core/custom-privacy-option" \
    --header "Content-Type: application/json" \
    --data "{
    "item_type": "omnis",
    "item_id": 538125.197968,
    "page": 68,
    "limit": 3629456.7,
    "sort": "facilis",
    "sort_type": "autem"
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/et/core/custom-privacy-option',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'item_type' => 'omnis',
            'item_id' => 538125.197968,
            'page' => 68,
            'limit' => 3629456.7,
            'sort' => 'facilis',
            'sort_type' => 'autem',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/et/core/custom-privacy-option"
);

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

let body = {
    "item_type": "omnis",
    "item_id": 538125.197968,
    "page": 68,
    "limit": 3629456.7,
    "sort": "facilis",
    "sort_type": "autem"
};

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

Request      

GET api/{ver}/core/custom-privacy-option

URL Parameters

ver  string  

Body Parameters

item_type  string optional  

item_id  number optional  

page  number optional  

Must be at least 1.

limit  number optional  

sort  string optional  

sort_type  string optional  

GET api/{ver}/core/custom-privacy-option/form

Example request:
curl --request GET \
    --get "http://localhost/api/v1/api/sit/core/custom-privacy-option/form"
$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/sit/core/custom-privacy-option/form');
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/sit/core/custom-privacy-option/form"
);

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

Request      

GET api/{ver}/core/custom-privacy-option/form

URL Parameters

ver  string  

GET api/{ver}/core/form/{formName}/{id?}

Example request:
curl --request GET \
    --get "http://localhost/api/v1/api/error/core/form/sunt/680685"
$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/error/core/form/sunt/680685');
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/error/core/form/sunt/680685"
);

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

Request      

GET api/{ver}/core/form/{formName}/{id?}

URL Parameters

ver  string  

formName  string  

id  string optional  

The ID of the .

Show data grid.

Example request:
curl --request GET \
    --get "http://localhost/api/v1/api/eum/core/grid/quidem/qui?dataGrid=phrase_admin"
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/eum/core/grid/quidem/qui',
    [
        'query' => [
            'dataGrid'=> 'phrase_admin',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/eum/core/grid/quidem/qui"
);

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

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

Request      

GET api/{ver}/core/grid/{gridName}/{parent?}

URL Parameters

ver  string  

gridName  string  

parent  string optional  

Query Parameters

dataGrid  string  

Grid name.

View app settings.

Example request:
curl --request GET \
    --get "http://localhost/api/v1/api/deserunt/core/mobile/action-settings"
$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/deserunt/core/mobile/action-settings');
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/deserunt/core/mobile/action-settings"
);

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

Request      

GET api/{ver}/core/mobile/action-settings

URL Parameters

ver  string  

View app settings.

Example request:
curl --request GET \
    --get "http://localhost/api/v1/api/quo/core/mobile/app-settings"
$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/quo/core/mobile/app-settings');
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/quo/core/mobile/app-settings"
);

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

Request      

GET api/{ver}/core/mobile/app-settings

URL Parameters

ver  string  

GET api/{ver}/core/mobile/form/{formName}/{id?}

Example request:
curl --request GET \
    --get "http://localhost/api/v1/api/pariatur/core/mobile/form/ut/04"
$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/pariatur/core/mobile/form/ut/04');
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/pariatur/core/mobile/form/ut/04"
);

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

Request      

GET api/{ver}/core/mobile/form/{formName}/{id?}

URL Parameters

ver  string  

formName  string  

id  string optional  

The ID of the .

View app settings.

Example request:
curl --request GET \
    --get "http://localhost/api/v1/api/similique/core/mobile/settings/similique"
$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/similique/core/mobile/settings/similique');
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/similique/core/mobile/settings/similique"
);

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

Request      

GET api/{ver}/core/mobile/settings/{revision?}

URL Parameters

ver  string  

revision  string optional  

GET api/{ver}/core/package/build/callback

Example request:
curl --request GET \
    --get "http://localhost/api/v1/api/ipsa/core/package/build/callback" \
    --header "Content-Type: application/json" \
    --data "{
    "buildId": "et"
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/ipsa/core/package/build/callback',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'buildId' => 'et',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/ipsa/core/package/build/callback"
);

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

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

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

Request      

GET api/{ver}/core/package/build/callback

URL Parameters

ver  string  

Body Parameters

buildId  string  

View user badge status.

Example request:
curl --request GET \
    --get "http://localhost/api/v1/api/quis/core/status"
$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/quis/core/status');
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/quis/core/status"
);

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

Request      

GET api/{ver}/core/status

URL Parameters

ver  string  

GET api/{ver}/core/translation/{group}/{lang?}/{revision?}

Example request:
curl --request GET \
    --get "http://localhost/api/v1/api/quia/core/translation/tempore/perspiciatis/qui"
$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/quia/core/translation/tempore/perspiciatis/qui');
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/quia/core/translation/tempore/perspiciatis/qui"
);

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

Request      

GET api/{ver}/core/translation/{group}/{lang?}/{revision?}

URL Parameters

ver  string  

group  string  

lang  string optional  

revision  string optional  

Get canonical URL.

Example request:
curl --request GET \
    --get "http://localhost/api/v1/api/odit/core/url-to-route" \
    --header "Content-Type: application/json" \
    --data "{
    "url": "sapiente"
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/odit/core/url-to-route',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'url' => 'sapiente',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/odit/core/url-to-route"
);

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

let body = {
    "url": "sapiente"
};

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

Request      

GET api/{ver}/core/url-to-route

URL Parameters

ver  string  

Body Parameters

url  string  

View frontend settings.

Example request:
curl --request GET \
    --get "http://localhost/api/v1/api/quasi/core/web/action-settings"
$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/quasi/core/web/action-settings');
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/quasi/core/web/action-settings"
);

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

Request      

GET api/{ver}/core/web/action-settings

URL Parameters

ver  string  

View frontend settings.

Example request:
curl --request GET \
    --get "http://localhost/api/v1/api/dolore/core/web/app-settings"
$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/dolore/core/web/app-settings');
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/dolore/core/web/app-settings"
);

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

Request      

GET api/{ver}/core/web/app-settings

URL Parameters

ver  string  

View frontend settings.

Example request:
curl --request GET \
    --get "http://localhost/api/v1/api/cum/core/web/settings/id"
$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/cum/core/web/settings/id');
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/cum/core/web/settings/id"
);

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

Request      

GET api/{ver}/core/web/settings/{revision?}

URL Parameters

ver  string  

revision  string optional  

Upload single.

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/api/optio/file" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "storage_id": "nihil",
    "file": "blanditiis",
    "file_type": "ex",
    "item_type": "atque",
    "thumbnail_sizes": [
        "consequatur"
    ],
    "base64": "ut"
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/optio/file',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'storage_id' => 'nihil',
            'file' => 'blanditiis',
            'file_type' => 'ex',
            'item_type' => 'atque',
            'thumbnail_sizes' => [
                'consequatur',
            ],
            'base64' => 'ut',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/optio/file"
);

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

let body = {
    "storage_id": "nihil",
    "file": "blanditiis",
    "file_type": "ex",
    "item_type": "atque",
    "thumbnail_sizes": [
        "consequatur"
    ],
    "base64": "ut"
};

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

Request      

POST api/{ver}/file

URL Parameters

ver  string  

Body Parameters

storage_id  string optional  

file  string  

file_type  string optional  

item_type  string optional  

thumbnail_sizes  string[] optional  

base64  string optional  

Upload multiple file.

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/api/voluptas/files" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "storage_id": "sint",
    "item_type": "modi",
    "upload_type": "libero",
    "thumbnail_sizes": [
        "ut"
    ],
    "file": [
        "dolor"
    ]
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/voluptas/files',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'storage_id' => 'sint',
            'item_type' => 'modi',
            'upload_type' => 'libero',
            'thumbnail_sizes' => [
                'ut',
            ],
            'file' => [
                'dolor',
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/voluptas/files"
);

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

let body = {
    "storage_id": "sint",
    "item_type": "modi",
    "upload_type": "libero",
    "thumbnail_sizes": [
        "ut"
    ],
    "file": [
        "dolor"
    ]
};

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

Request      

POST api/{ver}/files

URL Parameters

ver  string  

Body Parameters

storage_id  string optional  

0  string optional  

item_type  string optional  

upload_type  string optional  

thumbnail_sizes  string[] optional  

file  string[]  

View link.

Example request:
curl --request POST \
    "http://localhost/api/v1/api/provident/link/fetch" \
    --header "Content-Type: application/json" \
    --data "{
    "link": "ex",
    "owner_id": 20
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/provident/link/fetch',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'link' => 'ex',
            'owner_id' => 20,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/provident/link/fetch"
);

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

let body = {
    "link": "ex",
    "owner_id": 20
};

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

Request      

POST api/{ver}/link/fetch

URL Parameters

ver  string  

Body Parameters

link  string  

owner_id  integer optional  

GET api/{ver}/ping

Example request:
curl --request GET \
    --get "http://localhost/api/v1/api/ratione/ping"
$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/ratione/ping');
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/ratione/ping"
);

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

Request      

GET api/{ver}/ping

URL Parameters

ver  string  

E-Wallet

App name: E-Wallet Version: 5.1.7 Author: phpFox Updated at: Aug 02, 2024

Browse item.

Example request:
curl --request GET \
    --get "http://localhost/api/v1/api/vel/emoney/request" \
    --header "Content-Type: application/json" \
    --data "{
    "from_date": "quos",
    "to_date": "omnis",
    "id": 14
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/vel/emoney/request',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'from_date' => 'quos',
            'to_date' => 'omnis',
            'id' => 14,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/vel/emoney/request"
);

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

let body = {
    "from_date": "quos",
    "to_date": "omnis",
    "id": 14
};

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

Request      

GET api/{ver}/emoney/request

URL Parameters

ver  string  

Body Parameters

from_date  string optional  

to_date  string optional  

status  string optional  

id  integer optional  

PATCH api/{ver}/emoney/request/cancel/{id}

Example request:
curl --request PATCH \
    "http://localhost/api/v1/api/magni/emoney/request/cancel/1034212"
$client = new \GuzzleHttp\Client();
$response = $client->patch('http://localhost/api/v1/api/magni/emoney/request/cancel/1034212');
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/magni/emoney/request/cancel/1034212"
);

fetch(url, {
    method: "PATCH",
}).then(response => response.json());

Request      

PATCH api/{ver}/emoney/request/cancel/{id}

URL Parameters

ver  string  

id  string  

The ID of the cancel.

GET api/{ver}/emoney/request/{id}

Example request:
curl --request GET \
    --get "http://localhost/api/v1/api/atque/emoney/request/73"
$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/atque/emoney/request/73');
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/atque/emoney/request/73"
);

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

Request      

GET api/{ver}/emoney/request/{id}

URL Parameters

ver  string  

id  string  

The ID of the request.

View item.

Example request:
curl --request GET \
    --get "http://localhost/api/v1/api/consequatur/emoney/statistic/3"
$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/consequatur/emoney/statistic/3');
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/consequatur/emoney/statistic/3"
);

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

Request      

GET api/{ver}/emoney/statistic/{id}

URL Parameters

ver  string  

id  string  

The ID of the statistic.

Browse item.

Example request:
curl --request GET \
    --get "http://localhost/api/v1/api/atque/emoney/transaction" \
    --header "Content-Type: application/json" \
    --data "{
    "q": "sit",
    "base_currency": "esse",
    "from_date": "et",
    "to_date": "ut",
    "buyer": "in",
    "id": 7,
    "source": "error",
    "type": "magnam"
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/atque/emoney/transaction',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'q' => 'sit',
            'base_currency' => 'esse',
            'from_date' => 'et',
            'to_date' => 'ut',
            'buyer' => 'in',
            'id' => 7,
            'source' => 'error',
            'type' => 'magnam',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/atque/emoney/transaction"
);

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

let body = {
    "q": "sit",
    "base_currency": "esse",
    "from_date": "et",
    "to_date": "ut",
    "buyer": "in",
    "id": 7,
    "source": "error",
    "type": "magnam"
};

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

Request      

GET api/{ver}/emoney/transaction

URL Parameters

ver  string  

Body Parameters

q  string optional  

base_currency  string optional  

status  string optional  

from_date  string optional  

to_date  string optional  

buyer  string optional  

id  integer optional  

source  string optional  

type  string optional  

GET api/{ver}/emoney/transaction/{id}

Example request:
curl --request GET \
    --get "http://localhost/api/v1/api/dolor/emoney/transaction/6410805"
$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/dolor/emoney/transaction/6410805');
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/dolor/emoney/transaction/6410805"
);

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

Request      

GET api/{ver}/emoney/transaction/{id}

URL Parameters

ver  string  

id  string  

The ID of the transaction.

Event

App name: Event Version: 5.0.18 Author: phpFox Updated at: Aug 02, 2024

Display a listing of the resource.

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/api/animi/event" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "q": "qui",
    "view": "vel",
    "sort": "voluptate",
    "sort_type": "dolor",
    "when": "est",
    "category_id": 2.8,
    "user_id": 21,
    "owner_id": 2,
    "event_id": 704.13,
    "page": 33,
    "where": "ehoibodusundfrdkxyplohsmiwqidrsmoz",
    "lat": 1714.12105342,
    "lng": 25604004.562,
    "radius": 73,
    "limit": 32591645.448726192,
    "is_online": 6.2,
    "is_featured": 277759.095,
    "bounds_west": 63220055.683261,
    "bounds_east": 41905.82402,
    "bounds_south": 179935.05809102,
    "bounds_north": 22.393
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/animi/event',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'q' => 'qui',
            'view' => 'vel',
            'sort' => 'voluptate',
            'sort_type' => 'dolor',
            'when' => 'est',
            'category_id' => 2.8,
            'user_id' => 21.0,
            'owner_id' => 2,
            'event_id' => 704.13,
            'page' => 33,
            'where' => 'ehoibodusundfrdkxyplohsmiwqidrsmoz',
            'lat' => 1714.12105342,
            'lng' => 25604004.562,
            'radius' => 73,
            'limit' => 32591645.448726192,
            'is_online' => 6.2,
            'is_featured' => 277759.095,
            'bounds_west' => 63220055.683261,
            'bounds_east' => 41905.82402,
            'bounds_south' => 179935.05809102,
            'bounds_north' => 22.393,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/animi/event"
);

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

let body = {
    "q": "qui",
    "view": "vel",
    "sort": "voluptate",
    "sort_type": "dolor",
    "when": "est",
    "category_id": 2.8,
    "user_id": 21,
    "owner_id": 2,
    "event_id": 704.13,
    "page": 33,
    "where": "ehoibodusundfrdkxyplohsmiwqidrsmoz",
    "lat": 1714.12105342,
    "lng": 25604004.562,
    "radius": 73,
    "limit": 32591645.448726192,
    "is_online": 6.2,
    "is_featured": 277759.095,
    "bounds_west": 63220055.683261,
    "bounds_east": 41905.82402,
    "bounds_south": 179935.05809102,
    "bounds_north": 22.393
};

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

Request      

GET api/{ver}/event

URL Parameters

ver  string  

Body Parameters

q  string optional  

view  string optional  

sort  string optional  

sort_type  string optional  

when  string optional  

category_id  number optional  

user_id  number optional  

owner_id  integer optional  

event_id  number optional  

page  number optional  

Must be at least 1.

where  string optional  

Must be at least 2 characters.

lat  number optional  

lng  number optional  

radius  number optional  

Must be at least 1.

limit  number optional  

is_online  number optional  

is_featured  number optional  

bounds_west  number optional  

bounds_east  number optional  

bounds_south  number optional  

bounds_north  number optional  

Store a newly created resource in storage.

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/api/ut/event" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "name": "perferendis",
    "text": "doloribus",
    "file": {
        "file_type": "veniam",
        "temp_file": 15493.16683673
    },
    "attachments": [
        "quia"
    ],
    "categories": [
        17.371062
    ],
    "owner_id": 1424335.72417,
    "is_online": 22291,
    "event_url": "http:\/\/www.renner.com\/eaque-nam-magnam-aut-eveniet-alias",
    "start_time": "2022-12-31",
    "end_time": "2074-10-28",
    "privacy": "sit",
    "image_position": "quod",
    "location_name": "enim"
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/ut/event',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'name' => 'perferendis',
            'text' => 'doloribus',
            'file' => [
                'file_type' => 'veniam',
                'temp_file' => 15493.16683673,
            ],
            'attachments' => [
                'quia',
            ],
            'categories' => [
                17.371062,
            ],
            'owner_id' => 1424335.72417,
            'is_online' => 22291.0,
            'event_url' => 'http://www.renner.com/eaque-nam-magnam-aut-eveniet-alias',
            'start_time' => '2022-12-31',
            'end_time' => '2074-10-28',
            'privacy' => 'sit',
            'image_position' => 'quod',
            'location_name' => 'enim',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/ut/event"
);

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

let body = {
    "name": "perferendis",
    "text": "doloribus",
    "file": {
        "file_type": "veniam",
        "temp_file": 15493.16683673
    },
    "attachments": [
        "quia"
    ],
    "categories": [
        17.371062
    ],
    "owner_id": 1424335.72417,
    "is_online": 22291,
    "event_url": "http:\/\/www.renner.com\/eaque-nam-magnam-aut-eveniet-alias",
    "start_time": "2022-12-31",
    "end_time": "2074-10-28",
    "privacy": "sit",
    "image_position": "quod",
    "location_name": "enim"
};

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

Request      

POST api/{ver}/event

URL Parameters

ver  string  

Body Parameters

name  string  

text  string optional  

file  object optional  

file.file_type  string optional  

This field is required when file is present.

file.temp_file  number optional  

This field is required when file is present.

attachments  number[] optional  

attachments[].id  number optional  

attachments[].status  string optional  

categories  number[] optional  

owner_id  number optional  

is_online  number  

event_url  string optional  

This field is required when is_online is 1. Must be a valid URL.

start_time  string  

Must be a valid date. Must be a date before end_time.

end_time  string  

Must be a valid date. Must be a date after start_time.

privacy  string  

host  object optional  

image_position  string optional  

location_name  string optional  

This field is required when is_online is 0.

Display a listing of the resource.

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/api/quo/event-category" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "id": 6991.161503,
    "page": 15,
    "q": "cumque",
    "level": 42594839.51371666,
    "limit": 20
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/quo/event-category',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'id' => 6991.161503,
            'page' => 15,
            'q' => 'cumque',
            'level' => 42594839.51371666,
            'limit' => 20,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://localhost/api/v1/api/quo/event-category"
);

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

let body = {
    "id": 6991.161503,
    "page": 15,
    "q": "cumque",
    "level": 42594839.51371666,
    "limit": 20
};

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

Request