Introduction

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

Base URL

https://app.launchcart.com

Authenticating requests

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

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

You can retrieve token using OAuth2 flow.

Endpoints

POST api/v1/store/{storeId}/settings

requires authentication

Example request:

curl --request POST \
    "https://app.launchcart.com/api/v1/store/1/settings" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"settings\": [
        \"magni\"
    ]
}"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/settings"
);

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

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

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

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://app.launchcart.com/api/v1/store/1/settings',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'settings' => [
                'magni',
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

POST api/v1/store/{storeId}/settings/tax/groups

requires authentication

Example request:

curl --request POST \
    "https://app.launchcart.com/api/v1/store/1/settings/tax/groups" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"dzagwqnvgozjlfppmwmylwostphejaoqh\",
    \"priority\": 3,
    \"rules\": [
        {
            \"name\": \"magni\",
            \"country_code\": \"\",
            \"tax_percent\": 8789277.2
        }
    ]
}"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/settings/tax/groups"
);

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

let body = {
    "name": "dzagwqnvgozjlfppmwmylwostphejaoqh",
    "priority": 3,
    "rules": [
        {
            "name": "magni",
            "country_code": "",
            "tax_percent": 8789277.2
        }
    ]
};

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

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://app.launchcart.com/api/v1/store/1/settings/tax/groups',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'dzagwqnvgozjlfppmwmylwostphejaoqh',
            'priority' => 3,
            'rules' => [
                [
                    'name' => 'magni',
                    'country_code' => '',
                    'tax_percent' => 8789277.2,
                ],
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

Request

POST api/v1/store/{storeId}/settings/tax/groups

URL Parameters

storeId integer

Body Parameters

name string

Must be at least 3 characters. Must not be greater than 255 characters.

priority integer

rules object[] optional

rules[].name string

rules[].country_code string

Must be at least 2 characters. Must not be greater than 2 characters.

rules[].tax_percent number optional

POST api/v1/store/{storeId}/settings/tax/groups/{id}

requires authentication

Example request:

curl --request POST \
    "https://app.launchcart.com/api/v1/store/1/settings/tax/groups/magni" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"dzagwqnvgozjlfppmwmylwostphejaoqh\",
    \"priority\": 3,
    \"rules\": [
        {
            \"name\": \"magni\",
            \"country_code\": \"\",
            \"tax_percent\": 8789277.2
        }
    ]
}"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/settings/tax/groups/magni"
);

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

let body = {
    "name": "dzagwqnvgozjlfppmwmylwostphejaoqh",
    "priority": 3,
    "rules": [
        {
            "name": "magni",
            "country_code": "",
            "tax_percent": 8789277.2
        }
    ]
};

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

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://app.launchcart.com/api/v1/store/1/settings/tax/groups/magni',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'dzagwqnvgozjlfppmwmylwostphejaoqh',
            'priority' => 3,
            'rules' => [
                [
                    'name' => 'magni',
                    'country_code' => '',
                    'tax_percent' => 8789277.2,
                ],
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

Request

POST api/v1/store/{storeId}/settings/tax/groups/{id}

URL Parameters

storeId integer

id string

The ID of the group.

Body Parameters

name string

Must be at least 3 characters. Must not be greater than 255 characters.

priority integer

rules object[] optional

rules[].name string

rules[].country_code string

Must be at least 2 characters. Must not be greater than 2 characters.

rules[].tax_percent number optional

DELETE api/v1/store/{storeId}/settings/tax/groups/{group}

requires authentication

Example request:

curl --request DELETE \
    "https://app.launchcart.com/api/v1/store/1/settings/tax/groups/magni" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/settings/tax/groups/magni"
);

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

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

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'https://app.launchcart.com/api/v1/store/1/settings/tax/groups/magni',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

POST api/v1/store/{storeId}/settings/storeLocation/{locationId}

requires authentication

Example request:

curl --request POST \
    "https://app.launchcart.com/api/v1/store/1/settings/storeLocation/magni" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"dzagwqnvgozjlfppmwmylwostphejaoqh\",
    \"address_line\": \"madibfgyszidsreyofnkbcmqrawarqhjl\",
    \"address_line2\": \"grbhrwlctrfyqnyqpdfrzaoxufzokgzeo\",
    \"city\": \"jenqtuedvmhxlhobjbnjgporkmrnlzzya\",
    \"postal_code\": \"ohluvbnwkthzrgpnvdpuszncvgsiwyfmh\",
    \"country_code\": \"\",
    \"state\": \"nnemgkjennpythlemqkohgcuphudyjkzd\",
    \"phone_number\": \"fcnxah\"
}"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/settings/storeLocation/magni"
);

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

let body = {
    "name": "dzagwqnvgozjlfppmwmylwostphejaoqh",
    "address_line": "madibfgyszidsreyofnkbcmqrawarqhjl",
    "address_line2": "grbhrwlctrfyqnyqpdfrzaoxufzokgzeo",
    "city": "jenqtuedvmhxlhobjbnjgporkmrnlzzya",
    "postal_code": "ohluvbnwkthzrgpnvdpuszncvgsiwyfmh",
    "country_code": "",
    "state": "nnemgkjennpythlemqkohgcuphudyjkzd",
    "phone_number": "fcnxah"
};

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

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://app.launchcart.com/api/v1/store/1/settings/storeLocation/magni',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'dzagwqnvgozjlfppmwmylwostphejaoqh',
            'address_line' => 'madibfgyszidsreyofnkbcmqrawarqhjl',
            'address_line2' => 'grbhrwlctrfyqnyqpdfrzaoxufzokgzeo',
            'city' => 'jenqtuedvmhxlhobjbnjgporkmrnlzzya',
            'postal_code' => 'ohluvbnwkthzrgpnvdpuszncvgsiwyfmh',
            'country_code' => '',
            'state' => 'nnemgkjennpythlemqkohgcuphudyjkzd',
            'phone_number' => 'fcnxah',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

Request

POST api/v1/store/{storeId}/settings/storeLocation/{locationId}

URL Parameters

storeId integer

locationId string

Body Parameters

name string

Must not be greater than 255 characters.

address_line string

Must not be greater than 255 characters.

address_line2 string optional

Must not be greater than 255 characters.

city string

Must not be greater than 255 characters.

postal_code string

Must not be greater than 255 characters.

country_code string

Must be at least 3 characters. Must not be greater than 3 characters.

state string optional

Must not be greater than 255 characters.

phone_number string

Must not be greater than 50 characters.

POST api/v1/store/{storeId}/settings/storeLocation

requires authentication

Example request:

curl --request POST \
    "https://app.launchcart.com/api/v1/store/1/settings/storeLocation" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"dzagwqnvgozjlfppmwmylwostphejaoqh\",
    \"address_line\": \"madibfgyszidsreyofnkbcmqrawarqhjl\",
    \"address_line2\": \"grbhrwlctrfyqnyqpdfrzaoxufzokgzeo\",
    \"city\": \"jenqtuedvmhxlhobjbnjgporkmrnlzzya\",
    \"postal_code\": \"ohluvbnwkthzrgpnvdpuszncvgsiwyfmh\",
    \"country_code\": \"\",
    \"state\": \"nnemgkjennpythlemqkohgcuphudyjkzd\",
    \"phone_number\": \"fcnxah\"
}"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/settings/storeLocation"
);

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

let body = {
    "name": "dzagwqnvgozjlfppmwmylwostphejaoqh",
    "address_line": "madibfgyszidsreyofnkbcmqrawarqhjl",
    "address_line2": "grbhrwlctrfyqnyqpdfrzaoxufzokgzeo",
    "city": "jenqtuedvmhxlhobjbnjgporkmrnlzzya",
    "postal_code": "ohluvbnwkthzrgpnvdpuszncvgsiwyfmh",
    "country_code": "",
    "state": "nnemgkjennpythlemqkohgcuphudyjkzd",
    "phone_number": "fcnxah"
};

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

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://app.launchcart.com/api/v1/store/1/settings/storeLocation',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'dzagwqnvgozjlfppmwmylwostphejaoqh',
            'address_line' => 'madibfgyszidsreyofnkbcmqrawarqhjl',
            'address_line2' => 'grbhrwlctrfyqnyqpdfrzaoxufzokgzeo',
            'city' => 'jenqtuedvmhxlhobjbnjgporkmrnlzzya',
            'postal_code' => 'ohluvbnwkthzrgpnvdpuszncvgsiwyfmh',
            'country_code' => '',
            'state' => 'nnemgkjennpythlemqkohgcuphudyjkzd',
            'phone_number' => 'fcnxah',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

Request

POST api/v1/store/{storeId}/settings/storeLocation

URL Parameters

storeId integer

Body Parameters

name string

Must not be greater than 255 characters.

address_line string

Must not be greater than 255 characters.

address_line2 string optional

Must not be greater than 255 characters.

city string

Must not be greater than 255 characters.

postal_code string

Must not be greater than 255 characters.

country_code string

Must be at least 3 characters. Must not be greater than 3 characters.

state string optional

Must not be greater than 255 characters.

phone_number string

Must not be greater than 50 characters.

DELETE api/v1/store/{storeId}/settings/storeLocation/{locationId}

requires authentication

Example request:

curl --request DELETE \
    "https://app.launchcart.com/api/v1/store/1/settings/storeLocation/magni" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"settings\": [
        \"magni\"
    ]
}"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/settings/storeLocation/magni"
);

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

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

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

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'https://app.launchcart.com/api/v1/store/1/settings/storeLocation/magni',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'settings' => [
                'magni',
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

POST api/v1/store/{storeId}/settings/shipping/profiles/{profileId}

requires authentication

Example request:

curl --request POST \
    "https://app.launchcart.com/api/v1/store/1/settings/shipping/profiles/magni" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"settings\": [
        \"magni\"
    ]
}"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/settings/shipping/profiles/magni"
);

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

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

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

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://app.launchcart.com/api/v1/store/1/settings/shipping/profiles/magni',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'settings' => [
                'magni',
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

POST api/v1/store/{storeId}/settings/shipping/profiles

requires authentication

Example request:

curl --request POST \
    "https://app.launchcart.com/api/v1/store/1/settings/shipping/profiles" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"settings\": [
        \"magni\"
    ]
}"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/settings/shipping/profiles"
);

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

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

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

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://app.launchcart.com/api/v1/store/1/settings/shipping/profiles',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'settings' => [
                'magni',
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

DELETE api/v1/store/{storeId}/settings/shipping/profiles/{profileId}

requires authentication

Example request:

curl --request DELETE \
    "https://app.launchcart.com/api/v1/store/1/settings/shipping/profiles/magni" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"settings\": [
        \"magni\"
    ]
}"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/settings/shipping/profiles/magni"
);

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

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

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

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'https://app.launchcart.com/api/v1/store/1/settings/shipping/profiles/magni',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'settings' => [
                'magni',
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

POST api/v1/store/{storeId}/settings/shipping/serviceProvider/{shippingServiceId}

requires authentication

Example request:

curl --request POST \
    "https://app.launchcart.com/api/v1/store/1/settings/shipping/serviceProvider/magni" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"settings\": [
        \"magni\"
    ]
}"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/settings/shipping/serviceProvider/magni"
);

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

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

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

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://app.launchcart.com/api/v1/store/1/settings/shipping/serviceProvider/magni',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'settings' => [
                'magni',
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

POST api/v1/store/{storeId}/settings/shipping/serviceProvider

requires authentication

Example request:

curl --request POST \
    "https://app.launchcart.com/api/v1/store/1/settings/shipping/serviceProvider" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"settings\": [
        \"magni\"
    ]
}"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/settings/shipping/serviceProvider"
);

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

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

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

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://app.launchcart.com/api/v1/store/1/settings/shipping/serviceProvider',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'settings' => [
                'magni',
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

DELETE api/v1/store/{storeId}/settings/shipping/serviceProvider/{shippingServiceId}

requires authentication

Example request:

curl --request DELETE \
    "https://app.launchcart.com/api/v1/store/1/settings/shipping/serviceProvider/magni" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"settings\": [
        \"magni\"
    ]
}"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/settings/shipping/serviceProvider/magni"
);

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

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

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

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'https://app.launchcart.com/api/v1/store/1/settings/shipping/serviceProvider/magni',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'settings' => [
                'magni',
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

POST api/v1/store/{storeId}/settings/shipping/zones/{zoneId}

requires authentication

Example request:

curl --request POST \
    "https://app.launchcart.com/api/v1/store/1/settings/shipping/zones/magni" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"settings\": [
        \"magni\"
    ]
}"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/settings/shipping/zones/magni"
);

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

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

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

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://app.launchcart.com/api/v1/store/1/settings/shipping/zones/magni',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'settings' => [
                'magni',
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

POST api/v1/store/{storeId}/settings/shipping/zones

requires authentication

Example request:

curl --request POST \
    "https://app.launchcart.com/api/v1/store/1/settings/shipping/zones" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"settings\": [
        \"magni\"
    ]
}"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/settings/shipping/zones"
);

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

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

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

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://app.launchcart.com/api/v1/store/1/settings/shipping/zones',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'settings' => [
                'magni',
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

DELETE api/v1/store/{storeId}/settings/shipping/zones/{zoneId}

requires authentication

Example request:

curl --request DELETE \
    "https://app.launchcart.com/api/v1/store/1/settings/shipping/zones/magni" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"settings\": [
        \"magni\"
    ]
}"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/settings/shipping/zones/magni"
);

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

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

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

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'https://app.launchcart.com/api/v1/store/1/settings/shipping/zones/magni',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'settings' => [
                'magni',
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

POST api/v1/store/{storeId}/settings/currency/attach

requires authentication

Example request:

curl --request POST \
    "https://app.launchcart.com/api/v1/store/1/settings/currency/attach" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"code\": \"\"
}"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/settings/currency/attach"
);

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

let body = {
    "code": ""
};

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

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://app.launchcart.com/api/v1/store/1/settings/currency/attach',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'code' => '',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

POST api/v1/store/{storeId}/settings/currency/base

requires authentication

Example request:

curl --request POST \
    "https://app.launchcart.com/api/v1/store/1/settings/currency/base" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"code\": \"\"
}"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/settings/currency/base"
);

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

let body = {
    "code": ""
};

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

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://app.launchcart.com/api/v1/store/1/settings/currency/base',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'code' => '',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

POST api/v1/store/{storeId}/settings/currency/test

requires authentication

Example request:

curl --request POST \
    "https://app.launchcart.com/api/v1/store/1/settings/currency/test" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/settings/currency/test"
);

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

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

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://app.launchcart.com/api/v1/store/1/settings/currency/test',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

POST api/v1/store/{storeId}/settings/currency/{code}/settings

requires authentication

Example request:

curl --request POST \
    "https://app.launchcart.com/api/v1/store/1/settings/currency/magni/settings" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/settings/currency/magni/settings"
);

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

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

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://app.launchcart.com/api/v1/store/1/settings/currency/magni/settings',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

PATCH api/v1/store/{storeId}/products/{productId}

requires authentication

Example request:

curl --request PATCH \
    "https://app.launchcart.com/api/v1/store/1/products/1" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/products/1"
);

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

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

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'https://app.launchcart.com/api/v1/store/1/products/1',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

PUT api/v1/store/{storeId}/products/{productId}/inventory

requires authentication

Example request:

curl --request PUT \
    "https://app.launchcart.com/api/v1/store/1/products/1/inventory" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/products/1/inventory"
);

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

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

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'https://app.launchcart.com/api/v1/store/1/products/1/inventory',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

POST api/v1/store/{storeId}/customTemplates

requires authentication

Example request:

curl --request POST \
    "https://app.launchcart.com/api/v1/store/1/customTemplates" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/customTemplates"
);

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

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

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://app.launchcart.com/api/v1/store/1/customTemplates',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

POST api/v1/store/{storeId}/customTemplates/{id}

requires authentication

Example request:

curl --request POST \
    "https://app.launchcart.com/api/v1/store/1/customTemplates/3" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/customTemplates/3"
);

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

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

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://app.launchcart.com/api/v1/store/1/customTemplates/3',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

POST api/v1/store/{storeId}/webhooks

requires authentication

Example request:

curl --request POST \
    "https://app.launchcart.com/api/v1/store/1/webhooks" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"hook\": \"magni\",
    \"callback\": \"http:\\/\\/yost.com\\/\",
    \"type\": \"json\"
}"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/webhooks"
);

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

let body = {
    "hook": "magni",
    "callback": "http:\/\/yost.com\/",
    "type": "json"
};

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

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://app.launchcart.com/api/v1/store/1/webhooks',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'hook' => 'magni',
            'callback' => 'http://yost.com/',
            'type' => 'json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

POST api/v1/store/{storeId}/marketing/promotionalBar

requires authentication

Example request:

curl --request POST \
    "https://app.launchcart.com/api/v1/store/1/marketing/promotionalBar" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"dzagwqnvgozjlfppmwmylwostphejaoqh\",
    \"settings\": [
        \"magni\"
    ],
    \"is_active\": true,
    \"start_date\": \"2024-11-06T12:19:28\",
    \"end_date\": \"2024-11-06T12:19:28\"
}"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/marketing/promotionalBar"
);

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

let body = {
    "name": "dzagwqnvgozjlfppmwmylwostphejaoqh",
    "settings": [
        "magni"
    ],
    "is_active": true,
    "start_date": "2024-11-06T12:19:28",
    "end_date": "2024-11-06T12:19:28"
};

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

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://app.launchcart.com/api/v1/store/1/marketing/promotionalBar',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'dzagwqnvgozjlfppmwmylwostphejaoqh',
            'settings' => [
                'magni',
            ],
            'is_active' => true,
            'start_date' => '2024-11-06T12:19:28',
            'end_date' => '2024-11-06T12:19:28',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

Request

POST api/v1/store/{storeId}/marketing/promotionalBar

URL Parameters

storeId integer

Body Parameters

name string

Must be at least 3 characters. Must not be greater than 255 characters.

settings string[]

is_active boolean optional

start_date string optional

Must be a valid date.

end_date string optional

Must be a valid date.

PUT api/v1/store/{storeId}/marketing/promotionalBar/{barId}

requires authentication

Example request:

curl --request PUT \
    "https://app.launchcart.com/api/v1/store/1/marketing/promotionalBar/magni" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"dzagwqnvgozjlfppmwmylwostphejaoqh\",
    \"settings\": [
        \"magni\"
    ],
    \"is_active\": true,
    \"start_date\": \"2024-11-06T12:19:28\",
    \"end_date\": \"2024-11-06T12:19:28\"
}"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/marketing/promotionalBar/magni"
);

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

let body = {
    "name": "dzagwqnvgozjlfppmwmylwostphejaoqh",
    "settings": [
        "magni"
    ],
    "is_active": true,
    "start_date": "2024-11-06T12:19:28",
    "end_date": "2024-11-06T12:19:28"
};

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

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'https://app.launchcart.com/api/v1/store/1/marketing/promotionalBar/magni',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'dzagwqnvgozjlfppmwmylwostphejaoqh',
            'settings' => [
                'magni',
            ],
            'is_active' => true,
            'start_date' => '2024-11-06T12:19:28',
            'end_date' => '2024-11-06T12:19:28',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

Request

PUT api/v1/store/{storeId}/marketing/promotionalBar/{barId}

URL Parameters

storeId integer

barId string

Body Parameters

name string

Must be at least 3 characters. Must not be greater than 255 characters.

settings string[]

is_active boolean optional

start_date string optional

Must be a valid date.

end_date string optional

Must be a valid date.

DELETE api/v1/store/{storeId}/marketing/promotionalBar/{barId}

requires authentication

Example request:

curl --request DELETE \
    "https://app.launchcart.com/api/v1/store/1/marketing/promotionalBar/magni" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/marketing/promotionalBar/magni"
);

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

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

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'https://app.launchcart.com/api/v1/store/1/marketing/promotionalBar/magni',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

POST api/v1/store/{storeId}/marketing/popups

requires authentication

Example request:

curl --request POST \
    "https://app.launchcart.com/api/v1/store/1/marketing/popups" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/marketing/popups"
);

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

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

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://app.launchcart.com/api/v1/store/1/marketing/popups',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

PUT api/v1/store/{storeId}/marketing/popups/{id}

requires authentication

Example request:

curl --request PUT \
    "https://app.launchcart.com/api/v1/store/1/marketing/popups/magni" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/marketing/popups/magni"
);

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

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

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'https://app.launchcart.com/api/v1/store/1/marketing/popups/magni',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

DELETE api/v1/store/{storeId}/marketing/popups/{id}

requires authentication

Example request:

curl --request DELETE \
    "https://app.launchcart.com/api/v1/store/1/marketing/popups/magni" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/marketing/popups/magni"
);

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

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

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'https://app.launchcart.com/api/v1/store/1/marketing/popups/magni',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

PATCH api/v1/store/{storeId}/customers/{id}

requires authentication

Example request:

curl --request PATCH \
    "https://app.launchcart.com/api/v1/store/1/customers/1" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/customers/1"
);

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

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

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'https://app.launchcart.com/api/v1/store/1/customers/1',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

POST api/v1/store/{storeId}/import-reviews

requires authentication

Example request:

curl --request POST \
    "https://app.launchcart.com/api/v1/store/1/import-reviews" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: multipart/form-data" \
    --header "Accept: application/json" \
    --form "reviews=@/private/var/folders/44/g612g_p93bl62hwm4phl2k000000gn/T/phpDAZmOm"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/import-reviews"
);

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

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

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

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://app.launchcart.com/api/v1/store/1/import-reviews',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'multipart/form-data',
            'Accept' => 'application/json',
        ],
        'multipart' => [
            [
                'name' => 'reviews',
                'contents' => fopen('/private/var/folders/44/g612g_p93bl62hwm4phl2k000000gn/T/phpDAZmOm', 'r')
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

POST api/v1/store/{storeId}/rtsm/store

requires authentication

Example request:

curl --request POST \
    "https://app.launchcart.com/api/v1/store/1/rtsm/store" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/rtsm/store"
);

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

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

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://app.launchcart.com/api/v1/store/1/rtsm/store',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

GET api/v1/store/{storeId}/customers

requires authentication

Example request:

curl --request GET \
    --get "https://app.launchcart.com/api/v1/store/1/customers" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/customers"
);

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

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

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://app.launchcart.com/api/v1/store/1/customers',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

GET api/v1/store/{storeId}/products/variants

requires authentication

Example request:

curl --request GET \
    --get "https://app.launchcart.com/api/v1/store/1/products/variants" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"filterBy\": \"upc\",
    \"comparison\": \"neq\",
    \"sortDirection\": \"DESC\",
    \"sortBy\": \"quantity\",
    \"variants\": \"simple\"
}"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/products/variants"
);

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

let body = {
    "filterBy": "upc",
    "comparison": "neq",
    "sortDirection": "DESC",
    "sortBy": "quantity",
    "variants": "simple"
};

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

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://app.launchcart.com/api/v1/store/1/products/variants',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'filterBy' => 'upc',
            'comparison' => 'neq',
            'sortDirection' => 'DESC',
            'sortBy' => 'quantity',
            'variants' => 'simple',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

Request

GET api/v1/store/{storeId}/products/variants

URL Parameters

storeId integer

Body Parameters

filterBy string optional

Must be one of name, sku, upc, quantity, vendor, type, or tag.

comparison string optional

Must be one of eq, neq, gt, or lt.

sortDirection string optional

Must be one of DESC or ASC.

sortBy string optional

Must be one of quantity.

variants string optional

Must be one of simple or grouped.

GET api/v1/store/{storeId}/settings/currency/{code}/settings

requires authentication

Example request:

curl --request GET \
    --get "https://app.launchcart.com/api/v1/store/1/settings/currency/magni/settings" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/settings/currency/magni/settings"
);

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

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

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://app.launchcart.com/api/v1/store/1/settings/currency/magni/settings',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

GET api/v1/store/{storeId}/settings/links/fetch-links/{linksSet?}

requires authentication

Example request:

curl --request GET \
    --get "https://app.launchcart.com/api/v1/store/1/settings/links/fetch-links/magni" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/settings/links/fetch-links/magni"
);

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

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

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://app.launchcart.com/api/v1/store/1/settings/links/fetch-links/magni',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

GET api/v1/store/{storeId}/products

requires authentication

Example request:

curl --request GET \
    --get "https://app.launchcart.com/api/v1/store/1/products" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/products"
);

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

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

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://app.launchcart.com/api/v1/store/1/products',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

Get variants for selector

requires authentication

Example request:

curl --request GET \
    --get "https://app.launchcart.com/api/v1/store/1/products/variantsSelector" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/products/variantsSelector"
);

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

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

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://app.launchcart.com/api/v1/store/1/products/variantsSelector',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

Get categories selector (tree)

requires authentication

Example request:

curl --request GET \
    --get "https://app.launchcart.com/api/v1/store/1/products/categoriesSelector" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/products/categoriesSelector"
);

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

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

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://app.launchcart.com/api/v1/store/1/products/categoriesSelector',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

GET api/v1/store/{storeId}/settings/currency/ability/change

requires authentication

Example request:

curl --request GET \
    --get "https://app.launchcart.com/api/v1/store/1/settings/currency/ability/change" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/settings/currency/ability/change"
);

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

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

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://app.launchcart.com/api/v1/store/1/settings/currency/ability/change',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

GET api/v1/store/{storeId}/settings/tax/groups/{group}

requires authentication

Example request:

curl --request GET \
    --get "https://app.launchcart.com/api/v1/store/1/settings/tax/groups/magni" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/settings/tax/groups/magni"
);

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

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

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://app.launchcart.com/api/v1/store/1/settings/tax/groups/magni',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

GET api/v1/store/{storeId}/settings

requires authentication

Example request:

curl --request GET \
    --get "https://app.launchcart.com/api/v1/store/1/settings" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/settings"
);

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

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

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://app.launchcart.com/api/v1/store/1/settings',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

GET api/v1/store/{storeId}/settings/storeInfo

requires authentication

Example request:

curl --request GET \
    --get "https://app.launchcart.com/api/v1/store/1/settings/storeInfo" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/settings/storeInfo"
);

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

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

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://app.launchcart.com/api/v1/store/1/settings/storeInfo',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

GET api/v1/store/{storeId}/settings/domains

requires authentication

Example request:

curl --request GET \
    --get "https://app.launchcart.com/api/v1/store/1/settings/domains" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/settings/domains"
);

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

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

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://app.launchcart.com/api/v1/store/1/settings/domains',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

GET api/v1/store/{storeId}/settings/theme

requires authentication

Example request:

curl --request GET \
    --get "https://app.launchcart.com/api/v1/store/1/settings/theme" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/settings/theme"
);

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

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

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://app.launchcart.com/api/v1/store/1/settings/theme',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

GET api/v1/store/{storeId}/settings/theme/{themeId}

requires authentication

Example request:

curl --request GET \
    --get "https://app.launchcart.com/api/v1/store/1/settings/theme/magni" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/settings/theme/magni"
);

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

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

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://app.launchcart.com/api/v1/store/1/settings/theme/magni',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

GET api/v1/store/{storeId}/settings/tax/groups

requires authentication

Example request:

curl --request GET \
    --get "https://app.launchcart.com/api/v1/store/1/settings/tax/groups" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/settings/tax/groups"
);

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

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

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://app.launchcart.com/api/v1/store/1/settings/tax/groups',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

GET api/v1/store/{storeId}/settings/currency

requires authentication

Example request:

curl --request GET \
    --get "https://app.launchcart.com/api/v1/store/1/settings/currency" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/settings/currency"
);

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

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

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://app.launchcart.com/api/v1/store/1/settings/currency',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

GET api/v1/store/{storeId}/settings/storeLocation

requires authentication

Example request:

curl --request GET \
    --get "https://app.launchcart.com/api/v1/store/1/settings/storeLocation" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/settings/storeLocation"
);

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

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

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://app.launchcart.com/api/v1/store/1/settings/storeLocation',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

GET api/v1/store/{storeId}/settings/shipping/profiles

requires authentication

Example request:

curl --request GET \
    --get "https://app.launchcart.com/api/v1/store/1/settings/shipping/profiles" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/settings/shipping/profiles"
);

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

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

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://app.launchcart.com/api/v1/store/1/settings/shipping/profiles',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

GET api/v1/store/{storeId}/settings/shipping/profiles/{profileId}

requires authentication

Example request:

curl --request GET \
    --get "https://app.launchcart.com/api/v1/store/1/settings/shipping/profiles/magni" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/settings/shipping/profiles/magni"
);

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

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

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://app.launchcart.com/api/v1/store/1/settings/shipping/profiles/magni',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

GET api/v1/store/{storeId}/settings/shipping/serviceProvider

requires authentication

Example request:

curl --request GET \
    --get "https://app.launchcart.com/api/v1/store/1/settings/shipping/serviceProvider" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/settings/shipping/serviceProvider"
);

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

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

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://app.launchcart.com/api/v1/store/1/settings/shipping/serviceProvider',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

GET api/v1/store/{storeId}/settings/shipping/serviceProvider/{shippingServiceId}

requires authentication

Example request:

curl --request GET \
    --get "https://app.launchcart.com/api/v1/store/1/settings/shipping/serviceProvider/magni" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/settings/shipping/serviceProvider/magni"
);

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

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

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://app.launchcart.com/api/v1/store/1/settings/shipping/serviceProvider/magni',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

GET api/v1/store/{storeId}/settings/shipping/zones

requires authentication

Example request:

curl --request GET \
    --get "https://app.launchcart.com/api/v1/store/1/settings/shipping/zones" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/settings/shipping/zones"
);

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

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

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://app.launchcart.com/api/v1/store/1/settings/shipping/zones',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

GET api/v1/store/{storeId}/settings/shipping/zones/{zoneId}

requires authentication

Example request:

curl --request GET \
    --get "https://app.launchcart.com/api/v1/store/1/settings/shipping/zones/magni" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/settings/shipping/zones/magni"
);

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

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

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://app.launchcart.com/api/v1/store/1/settings/shipping/zones/magni',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

GET api/v1/store/{storeId}/marketing/promotionalBar

requires authentication

Example request:

curl --request GET \
    --get "https://app.launchcart.com/api/v1/store/1/marketing/promotionalBar" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/marketing/promotionalBar"
);

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

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

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://app.launchcart.com/api/v1/store/1/marketing/promotionalBar',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

GET api/v1/store/{storeId}/orders

requires authentication

Example request:

curl --request GET \
    --get "https://app.launchcart.com/api/v1/store/1/orders" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/orders"
);

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

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

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://app.launchcart.com/api/v1/store/1/orders',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

GET api/v1/store/{storeId}/customTemplates

requires authentication

Example request:

curl --request GET \
    --get "https://app.launchcart.com/api/v1/store/1/customTemplates" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/customTemplates"
);

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

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

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://app.launchcart.com/api/v1/store/1/customTemplates',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

GET api/v1/store/{storeId}/customTemplates/{type}/edit

requires authentication

Example request:

curl --request GET \
    --get "https://app.launchcart.com/api/v1/store/1/customTemplates/magni/edit" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/customTemplates/magni/edit"
);

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

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

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://app.launchcart.com/api/v1/store/1/customTemplates/magni/edit',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

GET api/v1/store/{storeId}/webhooks

requires authentication

Example request:

curl --request GET \
    --get "https://app.launchcart.com/api/v1/store/1/webhooks" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/webhooks"
);

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

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

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://app.launchcart.com/api/v1/store/1/webhooks',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

GET api/v1/store/{storeId}/marketing/promotionalBar/{barId}

requires authentication

Example request:

curl --request GET \
    --get "https://app.launchcart.com/api/v1/store/1/marketing/promotionalBar/magni" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/marketing/promotionalBar/magni"
);

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

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

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://app.launchcart.com/api/v1/store/1/marketing/promotionalBar/magni',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

GET api/v1/store/{storeId}/unlayer-list

requires authentication

Example request:

curl --request GET \
    --get "https://app.launchcart.com/api/v1/store/1/unlayer-list" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/unlayer-list"
);

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

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

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://app.launchcart.com/api/v1/store/1/unlayer-list',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

GET api/v1/store/{storeId}/marketing/popups

requires authentication

Example request:

curl --request GET \
    --get "https://app.launchcart.com/api/v1/store/1/marketing/popups" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/marketing/popups"
);

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

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

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://app.launchcart.com/api/v1/store/1/marketing/popups',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

GET api/v1/store/{storeId}/marketing/popups/{id}

requires authentication

Example request:

curl --request GET \
    --get "https://app.launchcart.com/api/v1/store/1/marketing/popups/magni" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/marketing/popups/magni"
);

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

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

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://app.launchcart.com/api/v1/store/1/marketing/popups/magni',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

GET api/v1/store/{storeId}/rtsm/store

requires authentication

Example request:

curl --request GET \
    --get "https://app.launchcart.com/api/v1/store/1/rtsm/store" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/rtsm/store"
);

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

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

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://app.launchcart.com/api/v1/store/1/rtsm/store',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

GET api/v1/store/{storeId}/review/{reviewId}/accept/{token}/{accepted}

requires authentication

Example request:

curl --request GET \
    --get "https://app.launchcart.com/api/v1/store/1/review/magni/accept/magni/magni" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/review/magni/accept/magni/magni"
);

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

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

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://app.launchcart.com/api/v1/store/1/review/magni/accept/magni/magni',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

GET api/v1/store/{storeId}/reviews/unsubscribe/thank_you

requires authentication

Example request:

curl --request GET \
    --get "https://app.launchcart.com/api/v1/store/1/reviews/unsubscribe/thank_you" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/reviews/unsubscribe/thank_you"
);

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

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

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://app.launchcart.com/api/v1/store/1/reviews/unsubscribe/thank_you',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

This function shows a form to confirm unsubscribing when the link is valid or redirects to products page if not

requires authentication

Example request:

curl --request GET \
    --get "https://app.launchcart.com/api/v1/store/1/reviews/unsubscribe/magni/list/magni/magni" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/reviews/unsubscribe/magni/list/magni/magni"
);

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

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

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://app.launchcart.com/api/v1/store/1/reviews/unsubscribe/magni/list/magni/magni',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

GET api/v1/store/{storeId}/base-data

requires authentication

Example request:

curl --request GET \
    --get "https://app.launchcart.com/api/v1/store/1/base-data" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/base-data"
);

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

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

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://app.launchcart.com/api/v1/store/1/base-data',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

GET api/v1/store/{storeId}/orders/{status}/{days}

requires authentication

Example request:

curl --request GET \
    --get "https://app.launchcart.com/api/v1/store/1/orders/1/magni" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/orders/1/magni"
);

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

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

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://app.launchcart.com/api/v1/store/1/orders/1/magni',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

GET api/v1/store/{storeId}/orders/order-details/{orderId}

requires authentication

Example request:

curl --request GET \
    --get "https://app.launchcart.com/api/v1/store/1/orders/order-details/magni" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/orders/order-details/magni"
);

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

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

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://app.launchcart.com/api/v1/store/1/orders/order-details/magni',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

requires authentication

Example request:

curl --request GET \
    --get "https://app.launchcart.com/api/v1/store/1/newsletter/accounts/selector/magni" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/newsletter/accounts/selector/magni"
);

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

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

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://app.launchcart.com/api/v1/store/1/newsletter/accounts/selector/magni',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

GET api/v1/store/{storeId}/products/{product}

requires authentication

Example request:

curl --request GET \
    --get "https://app.launchcart.com/api/v1/store/1/products/1" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/products/1"
);

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

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

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://app.launchcart.com/api/v1/store/1/products/1',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

POST api/v1/store/{storeId}/products/{productId}

requires authentication

Example request:

curl --request POST \
    "https://app.launchcart.com/api/v1/store/1/products/1" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"dzagwqnvgozjlfppmwm\",
    \"description\": \"magni\",
    \"main_price\": 0,
    \"retail_price\": 0,
    \"unit_price\": 0,
    \"shipping_price_domestic\": 8789277.2,
    \"shipping_price_international\": 8789277.2,
    \"tax_enabled\": \"magni\",
    \"shipping_enabled\": \"magni\",
    \"main_status\": \"0\",
    \"sku\": \"magni\",
    \"upc\": \"magni\",
    \"main_slug\": \"zagwqnvgozjlfppmwmylwostphejaoqhm\",
    \"metadata\": [
        \"magni\"
    ],
    \"attributes\": [
        \"magni\"
    ],
    \"attribute_values\": [
        [
            \"zagwqn\"
        ]
    ],
    \"track_quantity\": true,
    \"variantsData\": [
        {
            \"files\": [
                \"magni\"
            ],
            \"price\": \"magni\"
        }
    ],
    \"attrs\": [
        [
            \"vgozjl\"
        ]
    ]
}"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/products/1"
);

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

let body = {
    "name": "dzagwqnvgozjlfppmwm",
    "description": "magni",
    "main_price": 0,
    "retail_price": 0,
    "unit_price": 0,
    "shipping_price_domestic": 8789277.2,
    "shipping_price_international": 8789277.2,
    "tax_enabled": "magni",
    "shipping_enabled": "magni",
    "main_status": "0",
    "sku": "magni",
    "upc": "magni",
    "main_slug": "zagwqnvgozjlfppmwmylwostphejaoqhm",
    "metadata": [
        "magni"
    ],
    "attributes": [
        "magni"
    ],
    "attribute_values": [
        [
            "zagwqn"
        ]
    ],
    "track_quantity": true,
    "variantsData": [
        {
            "files": [
                "magni"
            ],
            "price": "magni"
        }
    ],
    "attrs": [
        [
            "vgozjl"
        ]
    ]
};

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

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://app.launchcart.com/api/v1/store/1/products/1',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'dzagwqnvgozjlfppmwm',
            'description' => 'magni',
            'main_price' => 0,
            'retail_price' => 0,
            'unit_price' => 0,
            'shipping_price_domestic' => 8789277.2,
            'shipping_price_international' => 8789277.2,
            'tax_enabled' => 'magni',
            'shipping_enabled' => 'magni',
            'main_status' => '0',
            'sku' => 'magni',
            'upc' => 'magni',
            'main_slug' => 'zagwqnvgozjlfppmwmylwostphejaoqhm',
            'metadata' => [
                'magni',
            ],
            'attributes' => [
                'magni',
            ],
            'attribute_values' => [
                [
                    'zagwqn',
                ],
            ],
            'track_quantity' => true,
            'variantsData' => [
                [
                    'files' => [
                        'magni',
                    ],
                    'price' => 'magni',
                ],
            ],
            'attrs' => [
                [
                    'vgozjl',
                ],
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

Request

POST api/v1/store/{storeId}/products/{productId}

URL Parameters

storeId integer

productId integer

Body Parameters

name string

Must not be greater than 150 characters.

description string

main_price number

Must be at least 0.

retail_price number optional

Must be at least 0.

unit_price number optional

Must be at least 0.

shipping_price_domestic number optional

shipping_price_international number optional

tax_enabled string

shipping_enabled string

main_status string optional

Must be one of 1, 0, or 5.

sku string optional

upc string optional

main_slug string optional

Must not be greater than 255 characters.

metadata string[] optional

attributes string[] optional

attribute_values string[][] optional

Must not be greater than 50 characters.

track_quantity boolean optional

variantsData object[] optional

variantsData[].files string[] optional

variantsData[].price string

attrs string[][] optional

Must not be greater than 50 characters.

POST api/v1/store/{storeId}/products

requires authentication

Example request:

curl --request POST \
    "https://app.launchcart.com/api/v1/store/1/products" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"dzagwqnvgozjlfppmwm\",
    \"description\": \"magni\",
    \"main_price\": 0,
    \"retail_price\": 0,
    \"unit_price\": 0,
    \"shipping_price_domestic\": 8789277.2,
    \"shipping_price_international\": 8789277.2,
    \"tax_enabled\": \"magni\",
    \"shipping_enabled\": \"magni\",
    \"main_status\": \"0\",
    \"sku\": \"magni\",
    \"upc\": \"magni\",
    \"main_slug\": \"zagwqnvgozjlfppmwmylwostphejaoqhm\",
    \"metadata\": [
        \"magni\"
    ],
    \"attributes\": [
        \"magni\"
    ],
    \"attribute_values\": [
        [
            \"zagwqn\"
        ]
    ],
    \"track_quantity\": true,
    \"variantsData\": [
        {
            \"files\": [
                \"magni\"
            ],
            \"price\": \"magni\"
        }
    ],
    \"attrs\": [
        [
            \"vgozjl\"
        ]
    ]
}"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/products"
);

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

let body = {
    "name": "dzagwqnvgozjlfppmwm",
    "description": "magni",
    "main_price": 0,
    "retail_price": 0,
    "unit_price": 0,
    "shipping_price_domestic": 8789277.2,
    "shipping_price_international": 8789277.2,
    "tax_enabled": "magni",
    "shipping_enabled": "magni",
    "main_status": "0",
    "sku": "magni",
    "upc": "magni",
    "main_slug": "zagwqnvgozjlfppmwmylwostphejaoqhm",
    "metadata": [
        "magni"
    ],
    "attributes": [
        "magni"
    ],
    "attribute_values": [
        [
            "zagwqn"
        ]
    ],
    "track_quantity": true,
    "variantsData": [
        {
            "files": [
                "magni"
            ],
            "price": "magni"
        }
    ],
    "attrs": [
        [
            "vgozjl"
        ]
    ]
};

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

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://app.launchcart.com/api/v1/store/1/products',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'dzagwqnvgozjlfppmwm',
            'description' => 'magni',
            'main_price' => 0,
            'retail_price' => 0,
            'unit_price' => 0,
            'shipping_price_domestic' => 8789277.2,
            'shipping_price_international' => 8789277.2,
            'tax_enabled' => 'magni',
            'shipping_enabled' => 'magni',
            'main_status' => '0',
            'sku' => 'magni',
            'upc' => 'magni',
            'main_slug' => 'zagwqnvgozjlfppmwmylwostphejaoqhm',
            'metadata' => [
                'magni',
            ],
            'attributes' => [
                'magni',
            ],
            'attribute_values' => [
                [
                    'zagwqn',
                ],
            ],
            'track_quantity' => true,
            'variantsData' => [
                [
                    'files' => [
                        'magni',
                    ],
                    'price' => 'magni',
                ],
            ],
            'attrs' => [
                [
                    'vgozjl',
                ],
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

Request

POST api/v1/store/{storeId}/products

URL Parameters

storeId integer

Body Parameters

name string

Must not be greater than 150 characters.

description string

main_price number

Must be at least 0.

retail_price number optional

Must be at least 0.

unit_price number optional

Must be at least 0.

shipping_price_domestic number optional

shipping_price_international number optional

tax_enabled string

shipping_enabled string

main_status string optional

Must be one of 1, 0, or 5.

sku string optional

upc string optional

main_slug string optional

Must not be greater than 255 characters.

metadata string[] optional

attributes string[] optional

attribute_values string[][] optional

Must not be greater than 50 characters.

track_quantity boolean optional

variantsData object[] optional

variantsData[].files string[] optional

variantsData[].price string

attrs string[][] optional

Must not be greater than 50 characters.

POST api/v1/store/{storeId}/integration/printful/products/resync/{productId}

requires authentication

Example request:

curl --request POST \
    "https://app.launchcart.com/api/v1/store/1/integration/printful/products/resync/magni" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/integration/printful/products/resync/magni"
);

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

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

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://app.launchcart.com/api/v1/store/1/integration/printful/products/resync/magni',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

POST api/v1/store/{storeId}/integration/printful/orders/resync/{orderId}

requires authentication

Example request:

curl --request POST \
    "https://app.launchcart.com/api/v1/store/1/integration/printful/orders/resync/magni" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/integration/printful/orders/resync/magni"
);

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

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

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://app.launchcart.com/api/v1/store/1/integration/printful/orders/resync/magni',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

POST api/v1/store/{storeId}/integration/printful/orders

requires authentication

Example request:

curl --request POST \
    "https://app.launchcart.com/api/v1/store/1/integration/printful/orders" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/integration/printful/orders"
);

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

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

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://app.launchcart.com/api/v1/store/1/integration/printful/orders',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

POST api/v1/store/{storeId}/orders/{id}/refund

requires authentication

Example request:

curl --request POST \
    "https://app.launchcart.com/api/v1/store/1/orders/1/refund" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"items\": [
        {
            \"id\": 3,
            \"quantity\": 3
        }
    ],
    \"shipping\": 8789277.2,
    \"notifyCustomer\": false
}"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/orders/1/refund"
);

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

let body = {
    "items": [
        {
            "id": 3,
            "quantity": 3
        }
    ],
    "shipping": 8789277.2,
    "notifyCustomer": false
};

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

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://app.launchcart.com/api/v1/store/1/orders/1/refund',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'items' => [
                [
                    'id' => 3,
                    'quantity' => 3,
                ],
            ],
            'shipping' => 8789277.2,
            'notifyCustomer' => false,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

Request

POST api/v1/store/{storeId}/orders/{id}/refund

URL Parameters

storeId integer

id integer

The ID of the order.

Body Parameters

items object[] optional

items[].id integer

items[].quantity integer

shipping number optional

notifyCustomer boolean optional

POST api/v1/store/{storeId}/integration/printful/products

requires authentication

Example request:

curl --request POST \
    "https://app.launchcart.com/api/v1/store/1/integration/printful/products" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/integration/printful/products"
);

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

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

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://app.launchcart.com/api/v1/store/1/integration/printful/products',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

GET api/v1/store/{storeId}/integration/printful/settings

requires authentication

Example request:

curl --request GET \
    --get "https://app.launchcart.com/api/v1/store/1/integration/printful/settings" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/integration/printful/settings"
);

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

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

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://app.launchcart.com/api/v1/store/1/integration/printful/settings',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

PATCH api/v1/store/{storeId}/orders/{id}/status

requires authentication

Example request:

curl --request PATCH \
    "https://app.launchcart.com/api/v1/store/1/orders/1/status" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"status\": \"failed\",
    \"notifyCustomer\": false
}"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/orders/1/status"
);

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

let body = {
    "status": "failed",
    "notifyCustomer": false
};

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

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'https://app.launchcart.com/api/v1/store/1/orders/1/status',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'status' => 'failed',
            'notifyCustomer' => false,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

Request

PATCH api/v1/store/{storeId}/orders/{id}/status

URL Parameters

storeId integer

id integer

The ID of the order.

Body Parameters

status string

Must be one of new, paid, failed, refuned, partially_refunded, canceled, or pending.

notifyCustomer boolean optional

PUT api/v1/store/{storeId}/customers/{customer}

requires authentication

Example request:

curl --request PUT \
    "https://app.launchcart.com/api/v1/store/1/customers/1" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"first_name\": \"magni\",
    \"last_name\": \"magni\",
    \"email\": \"[email protected]\",
    \"note\": \"magni\",
    \"subscribe_newsletter\": true,
    \"billing_addresses\": [
        {
            \"first_name\": \"magni\",
            \"last_name\": \"magni\",
            \"company\": \"magni\",
            \"address1\": \"magni\",
            \"address2\": \"magni\",
            \"city\": \"magni\",
            \"country\": \"magni\",
            \"state\": \"magni\",
            \"zip\": \"magni\",
            \"phone\": \"magni\"
        }
    ],
    \"shipping_addresses\": [
        {
            \"first_name\": \"magni\",
            \"last_name\": \"magni\",
            \"company\": \"magni\",
            \"address1\": \"magni\",
            \"address2\": \"magni\",
            \"city\": \"magni\",
            \"country\": \"magni\",
            \"state\": \"magni\",
            \"zip\": \"magni\",
            \"phone\": \"magni\"
        }
    ],
    \"payment_profiles\": [
        {
            \"id\": 8789277.2,
            \"gateway_profile_id\": \"magni\",
            \"exp_month\": 8789277.2,
            \"exp_year\": 8789277.2,
            \"last4\": 8789277.2,
            \"settings\": [
                \"magni\"
            ]
        }
    ]
}"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/customers/1"
);

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

let body = {
    "first_name": "magni",
    "last_name": "magni",
    "email": "[email protected]",
    "note": "magni",
    "subscribe_newsletter": true,
    "billing_addresses": [
        {
            "first_name": "magni",
            "last_name": "magni",
            "company": "magni",
            "address1": "magni",
            "address2": "magni",
            "city": "magni",
            "country": "magni",
            "state": "magni",
            "zip": "magni",
            "phone": "magni"
        }
    ],
    "shipping_addresses": [
        {
            "first_name": "magni",
            "last_name": "magni",
            "company": "magni",
            "address1": "magni",
            "address2": "magni",
            "city": "magni",
            "country": "magni",
            "state": "magni",
            "zip": "magni",
            "phone": "magni"
        }
    ],
    "payment_profiles": [
        {
            "id": 8789277.2,
            "gateway_profile_id": "magni",
            "exp_month": 8789277.2,
            "exp_year": 8789277.2,
            "last4": 8789277.2,
            "settings": [
                "magni"
            ]
        }
    ]
};

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

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'https://app.launchcart.com/api/v1/store/1/customers/1',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'first_name' => 'magni',
            'last_name' => 'magni',
            'email' => '[email protected]',
            'note' => 'magni',
            'subscribe_newsletter' => true,
            'billing_addresses' => [
                [
                    'first_name' => 'magni',
                    'last_name' => 'magni',
                    'company' => 'magni',
                    'address1' => 'magni',
                    'address2' => 'magni',
                    'city' => 'magni',
                    'country' => 'magni',
                    'state' => 'magni',
                    'zip' => 'magni',
                    'phone' => 'magni',
                ],
            ],
            'shipping_addresses' => [
                [
                    'first_name' => 'magni',
                    'last_name' => 'magni',
                    'company' => 'magni',
                    'address1' => 'magni',
                    'address2' => 'magni',
                    'city' => 'magni',
                    'country' => 'magni',
                    'state' => 'magni',
                    'zip' => 'magni',
                    'phone' => 'magni',
                ],
            ],
            'payment_profiles' => [
                [
                    'id' => 8789277.2,
                    'gateway_profile_id' => 'magni',
                    'exp_month' => 8789277.2,
                    'exp_year' => 8789277.2,
                    'last4' => 8789277.2,
                    'settings' => [
                        'magni',
                    ],
                ],
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

Request

PUT api/v1/store/{storeId}/customers/{customer}

URL Parameters

storeId integer

customer integer

The customer.

Body Parameters

first_name string optional

last_name string optional

email string optional

Must be a valid email address.

note string optional

subscribe_newsletter boolean optional

billing_addresses object[] optional

billing_addresses[].first_name string optional

billing_addresses[].last_name string optional

billing_addresses[].company string optional

billing_addresses[].address1 string optional

billing_addresses[].address2 string optional

billing_addresses[].city string optional

billing_addresses[].country string optional

billing_addresses[].state string optional

billing_addresses[].zip string optional

billing_addresses[].phone string optional

shipping_addresses object[] optional

shipping_addresses[].first_name string optional

shipping_addresses[].last_name string optional

shipping_addresses[].company string optional

shipping_addresses[].address1 string optional

shipping_addresses[].address2 string optional

shipping_addresses[].city string optional

shipping_addresses[].country string optional

shipping_addresses[].state string optional

shipping_addresses[].zip string optional

shipping_addresses[].phone string optional

payment_profiles object[] optional

payment_profiles[].id number optional

payment_profiles[].gateway_profile_id string optional

payment_profiles[].exp_month number optional

payment_profiles[].exp_year number optional

payment_profiles[].last4 number optional

payment_profiles[].settings string[] optional

GET api/v1/store/{storeId}/customers/{customer}

requires authentication

Example request:

curl --request GET \
    --get "https://app.launchcart.com/api/v1/store/1/customers/1" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/customers/1"
);

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

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

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://app.launchcart.com/api/v1/store/1/customers/1',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

POST api/v1/store/{storeId}/customers

requires authentication

Example request:

curl --request POST \
    "https://app.launchcart.com/api/v1/store/1/customers" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"first_name\": \"magni\",
    \"last_name\": \"magni\",
    \"email\": \"[email protected]\",
    \"note\": \"magni\",
    \"subscribe_newsletter\": true,
    \"billing_addresses\": [
        {
            \"first_name\": \"magni\",
            \"last_name\": \"magni\",
            \"company\": \"magni\",
            \"address1\": \"magni\",
            \"address2\": \"magni\",
            \"city\": \"magni\",
            \"country\": \"magni\",
            \"state\": \"magni\",
            \"zip\": \"magni\",
            \"phone\": \"magni\"
        }
    ],
    \"shipping_addresses\": [
        {
            \"first_name\": \"magni\",
            \"last_name\": \"magni\",
            \"company\": \"magni\",
            \"address1\": \"magni\",
            \"address2\": \"magni\",
            \"city\": \"magni\",
            \"country\": \"magni\",
            \"state\": \"magni\",
            \"zip\": \"magni\",
            \"phone\": \"magni\"
        }
    ],
    \"payment_profiles\": [
        {
            \"id\": 8789277.2,
            \"gateway_profile_id\": \"magni\",
            \"exp_month\": 8789277.2,
            \"exp_year\": 8789277.2,
            \"last4\": 8789277.2,
            \"settings\": [
                \"magni\"
            ]
        }
    ]
}"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/customers"
);

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

let body = {
    "first_name": "magni",
    "last_name": "magni",
    "email": "[email protected]",
    "note": "magni",
    "subscribe_newsletter": true,
    "billing_addresses": [
        {
            "first_name": "magni",
            "last_name": "magni",
            "company": "magni",
            "address1": "magni",
            "address2": "magni",
            "city": "magni",
            "country": "magni",
            "state": "magni",
            "zip": "magni",
            "phone": "magni"
        }
    ],
    "shipping_addresses": [
        {
            "first_name": "magni",
            "last_name": "magni",
            "company": "magni",
            "address1": "magni",
            "address2": "magni",
            "city": "magni",
            "country": "magni",
            "state": "magni",
            "zip": "magni",
            "phone": "magni"
        }
    ],
    "payment_profiles": [
        {
            "id": 8789277.2,
            "gateway_profile_id": "magni",
            "exp_month": 8789277.2,
            "exp_year": 8789277.2,
            "last4": 8789277.2,
            "settings": [
                "magni"
            ]
        }
    ]
};

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

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://app.launchcart.com/api/v1/store/1/customers',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'first_name' => 'magni',
            'last_name' => 'magni',
            'email' => '[email protected]',
            'note' => 'magni',
            'subscribe_newsletter' => true,
            'billing_addresses' => [
                [
                    'first_name' => 'magni',
                    'last_name' => 'magni',
                    'company' => 'magni',
                    'address1' => 'magni',
                    'address2' => 'magni',
                    'city' => 'magni',
                    'country' => 'magni',
                    'state' => 'magni',
                    'zip' => 'magni',
                    'phone' => 'magni',
                ],
            ],
            'shipping_addresses' => [
                [
                    'first_name' => 'magni',
                    'last_name' => 'magni',
                    'company' => 'magni',
                    'address1' => 'magni',
                    'address2' => 'magni',
                    'city' => 'magni',
                    'country' => 'magni',
                    'state' => 'magni',
                    'zip' => 'magni',
                    'phone' => 'magni',
                ],
            ],
            'payment_profiles' => [
                [
                    'id' => 8789277.2,
                    'gateway_profile_id' => 'magni',
                    'exp_month' => 8789277.2,
                    'exp_year' => 8789277.2,
                    'last4' => 8789277.2,
                    'settings' => [
                        'magni',
                    ],
                ],
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

Request

POST api/v1/store/{storeId}/customers

URL Parameters

storeId integer

Body Parameters

first_name string optional

last_name string optional

email string optional

Must be a valid email address.

note string optional

subscribe_newsletter boolean optional

billing_addresses object[] optional

billing_addresses[].first_name string optional

billing_addresses[].last_name string optional

billing_addresses[].company string optional

billing_addresses[].address1 string optional

billing_addresses[].address2 string optional

billing_addresses[].city string optional

billing_addresses[].country string optional

billing_addresses[].state string optional

billing_addresses[].zip string optional

billing_addresses[].phone string optional

shipping_addresses object[] optional

shipping_addresses[].first_name string optional

shipping_addresses[].last_name string optional

shipping_addresses[].company string optional

shipping_addresses[].address1 string optional

shipping_addresses[].address2 string optional

shipping_addresses[].city string optional

shipping_addresses[].country string optional

shipping_addresses[].state string optional

shipping_addresses[].zip string optional

shipping_addresses[].phone string optional

payment_profiles object[] optional

payment_profiles[].id number optional

payment_profiles[].gateway_profile_id string optional

payment_profiles[].exp_month number optional

payment_profiles[].exp_year number optional

payment_profiles[].last4 number optional

payment_profiles[].settings string[] optional

PUT api/v1/store/{storeId}/payments/opennode

requires authentication

Example request:

curl --request PUT \
    "https://app.launchcart.com/api/v1/store/1/payments/opennode" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"security_key\": \"magni\"
}"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/payments/opennode"
);

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

let body = {
    "security_key": "magni"
};

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

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'https://app.launchcart.com/api/v1/store/1/payments/opennode',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'security_key' => 'magni',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

Update flow

requires authentication

Example request:

curl --request PUT \
    "https://app.launchcart.com/api/v1/store/1/payments/nmi" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"security_key\": \"magni\",
    \"tokenization_key\": \"magni\",
    \"is_3d_secure_enabled\": true
}"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/payments/nmi"
);

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

let body = {
    "security_key": "magni",
    "tokenization_key": "magni",
    "is_3d_secure_enabled": true
};

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

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'https://app.launchcart.com/api/v1/store/1/payments/nmi',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'security_key' => 'magni',
            'tokenization_key' => 'magni',
            'is_3d_secure_enabled' => true,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

DELETE api/v1/store/{storeId}/customers/{customer}

requires authentication

Example request:

curl --request DELETE \
    "https://app.launchcart.com/api/v1/store/1/customers/1" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/customers/1"
);

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

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

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'https://app.launchcart.com/api/v1/store/1/customers/1',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

POST api/v1/store/{storeId}/openai/product/description

requires authentication

Example request:

curl --request POST \
    "https://app.launchcart.com/api/v1/store/1/openai/product/description" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/openai/product/description"
);

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

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

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://app.launchcart.com/api/v1/store/1/openai/product/description',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

POST api/v1/store/{storeId}/settings/shipping/enableShippingValidation

requires authentication

Example request:

curl --request POST \
    "https://app.launchcart.com/api/v1/store/1/settings/shipping/enableShippingValidation" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/settings/shipping/enableShippingValidation"
);

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

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

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://app.launchcart.com/api/v1/store/1/settings/shipping/enableShippingValidation',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

POST api/v1/store/{storeId}/settings/shipping/disableShippingValidation

requires authentication

Example request:

curl --request POST \
    "https://app.launchcart.com/api/v1/store/1/settings/shipping/disableShippingValidation" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/settings/shipping/disableShippingValidation"
);

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

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

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://app.launchcart.com/api/v1/store/1/settings/shipping/disableShippingValidation',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

POST api/v1/store/{storeId}/settings/currency/{storeCurrency_id}

requires authentication

Example request:

curl --request POST \
    "https://app.launchcart.com/api/v1/store/1/settings/currency/1" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"enabled\": false
}"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/settings/currency/1"
);

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

let body = {
    "enabled": false
};

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

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://app.launchcart.com/api/v1/store/1/settings/currency/1',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'enabled' => false,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

PUT api/v1/store/{storeId}/products/sku/{sku}/inventory

requires authentication

Example request:

curl --request PUT \
    "https://app.launchcart.com/api/v1/store/1/products/sku/magni/inventory" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/products/sku/magni/inventory"
);

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

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

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'https://app.launchcart.com/api/v1/store/1/products/sku/magni/inventory',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

GET api/v1/store/{storeId}/products/{product_id}/attribute

requires authentication

Example request:

curl --request GET \
    --get "https://app.launchcart.com/api/v1/store/1/products/1/attribute" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/products/1/attribute"
);

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

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

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://app.launchcart.com/api/v1/store/1/products/1/attribute',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

POST api/v1/store/{storeId}/products/{product_id}/attribute

requires authentication

Example request:

curl --request POST \
    "https://app.launchcart.com/api/v1/store/1/products/1/attribute" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/products/1/attribute"
);

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

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

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://app.launchcart.com/api/v1/store/1/products/1/attribute',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

PUT api/v1/store/{storeId}/products/{product_id}/attribute/{attributeId}

requires authentication

Example request:

curl --request PUT \
    "https://app.launchcart.com/api/v1/store/1/products/1/attribute/1" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/products/1/attribute/1"
);

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

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

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'https://app.launchcart.com/api/v1/store/1/products/1/attribute/1',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

DELETE api/v1/store/{storeId}/products/{product_id}/attribute/{attributeId}

requires authentication

Example request:

curl --request DELETE \
    "https://app.launchcart.com/api/v1/store/1/products/1/attribute/1" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/products/1/attribute/1"
);

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

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

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'https://app.launchcart.com/api/v1/store/1/products/1/attribute/1',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

Required request parameter 'models_file' array

requires authentication

Example request:

curl --request POST \
    "https://app.launchcart.com/api/v1/store/1/products/1/attribute/model-files/store" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: multipart/form-data" \
    --header "Accept: application/json" \
    --form "models_file[]=@/private/var/folders/44/g612g_p93bl62hwm4phl2k000000gn/T/phpbEPirg"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/products/1/attribute/model-files/store"
);

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

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

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

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://app.launchcart.com/api/v1/store/1/products/1/attribute/model-files/store',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'multipart/form-data',
            'Accept' => 'application/json',
        ],
        'multipart' => [
            [
                'name' => 'models_file[]',
                'contents' => fopen('/private/var/folders/44/g612g_p93bl62hwm4phl2k000000gn/T/phpbEPirg', 'r')
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

Update the specified resource in storage.

requires authentication

Example request:

curl --request GET \
    --get "https://app.launchcart.com/api/v1/store/1/products/1/attribute/model-files/model" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/products/1/attribute/model-files/model"
);

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

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

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://app.launchcart.com/api/v1/store/1/products/1/attribute/model-files/model',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

PUT api/v1/store/{storeId}/products/{product_id}/attribute/model-files/update/{model_id}

requires authentication

Example request:

curl --request PUT \
    "https://app.launchcart.com/api/v1/store/1/products/1/attribute/model-files/update/1" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: multipart/form-data" \
    --header "Accept: application/json" \
    --form "models_file=@/private/var/folders/44/g612g_p93bl62hwm4phl2k000000gn/T/phpMrhkUw" \
    --form "thumb=@/private/var/folders/44/g612g_p93bl62hwm4phl2k000000gn/T/phpBU9gUc"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/products/1/attribute/model-files/update/1"
);

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

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

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

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'https://app.launchcart.com/api/v1/store/1/products/1/attribute/model-files/update/1',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'multipart/form-data',
            'Accept' => 'application/json',
        ],
        'multipart' => [
            [
                'name' => 'models_file',
                'contents' => fopen('/private/var/folders/44/g612g_p93bl62hwm4phl2k000000gn/T/phpMrhkUw', 'r')
            ],
            [
                'name' => 'thumb',
                'contents' => fopen('/private/var/folders/44/g612g_p93bl62hwm4phl2k000000gn/T/phpBU9gUc', 'r')
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

Request

PUT api/v1/store/{storeId}/products/{product_id}/attribute/model-files/update/{model_id}

URL Parameters

storeId integer

product_id integer

The ID of the product.

model_id integer

The ID of the model.

Body Parameters

models_file file optional

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

thumb file optional

Must be a file. Must be an image. Must not be greater than 2000 kilobytes.

Remove the specified resource from storage.

requires authentication

Example request:

curl --request DELETE \
    "https://app.launchcart.com/api/v1/store/1/products/1/attribute/model-files/destroy/1" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/products/1/attribute/model-files/destroy/1"
);

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

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

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'https://app.launchcart.com/api/v1/store/1/products/1/attribute/model-files/destroy/1',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

Get media type

requires authentication

Example request:

curl --request GET \
    --get "https://app.launchcart.com/api/v1/store/1/products/1/media/magni/media-type" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/products/1/media/magni/media-type"
);

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

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

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://app.launchcart.com/api/v1/store/1/products/1/media/magni/media-type',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

Get media status

requires authentication

Example request:

curl --request GET \
    --get "https://app.launchcart.com/api/v1/store/1/products/1/media/magni/media-status" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/products/1/media/magni/media-status"
);

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

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

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://app.launchcart.com/api/v1/store/1/products/1/media/magni/media-status',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

Delete all resolutions for media

requires authentication

Example request:

curl --request GET \
    --get "https://app.launchcart.com/api/v1/store/1/products/1/media/magni/analyze" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/products/1/media/magni/analyze"
);

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

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

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://app.launchcart.com/api/v1/store/1/products/1/media/magni/analyze',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

Reorder product medias

requires authentication

Example request:

curl --request POST \
    "https://app.launchcart.com/api/v1/store/1/products/1/media/reorder" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"files\": [
        3
    ]
}"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/products/1/media/reorder"
);

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

let body = {
    "files": [
        3
    ]
};

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

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://app.launchcart.com/api/v1/store/1/products/1/media/reorder',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'files' => [
                3,
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

Update product video

requires authentication

Example request:

curl --request POST \
    "https://app.launchcart.com/api/v1/store/1/products/1/media/magni" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/products/1/media/magni"
);

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

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

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://app.launchcart.com/api/v1/store/1/products/1/media/magni',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

Delete all resolutions for media

requires authentication

Example request:

curl --request DELETE \
    "https://app.launchcart.com/api/v1/store/1/products/1/media/magni" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/products/1/media/magni"
);

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

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

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'https://app.launchcart.com/api/v1/store/1/products/1/media/magni',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

Get product media list

requires authentication

Example request:

curl --request GET \
    --get "https://app.launchcart.com/api/v1/store/1/products/1/media" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/products/1/media"
);

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

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

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://app.launchcart.com/api/v1/store/1/products/1/media',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

Create new media

requires authentication

Example request:

curl --request POST \
    "https://app.launchcart.com/api/v1/store/1/products/1/media" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/products/1/media"
);

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

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

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://app.launchcart.com/api/v1/store/1/products/1/media',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

Delete all resolutions for media

requires authentication

Example request:

curl --request DELETE \
    "https://app.launchcart.com/api/v1/store/1/products/1/media" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/products/1/media"
);

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

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

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'https://app.launchcart.com/api/v1/store/1/products/1/media',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

Update videos order

requires authentication

Example request:

curl --request PUT \
    "https://app.launchcart.com/api/v1/store/1/products/1/video/order" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/products/1/video/order"
);

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

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

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'https://app.launchcart.com/api/v1/store/1/products/1/video/order',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

Get list of all product videos

requires authentication

Example request:

curl --request GET \
    --get "https://app.launchcart.com/api/v1/store/1/products/1/video" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/products/1/video"
);

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

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

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://app.launchcart.com/api/v1/store/1/products/1/video',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

Get single video for product

requires authentication

Example request:

curl --request GET \
    --get "https://app.launchcart.com/api/v1/store/1/products/1/video/magni" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/products/1/video/magni"
);

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

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

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://app.launchcart.com/api/v1/store/1/products/1/video/magni',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

Create new product video

requires authentication

Example request:

curl --request POST \
    "https://app.launchcart.com/api/v1/store/1/products/1/video" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/products/1/video"
);

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

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

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://app.launchcart.com/api/v1/store/1/products/1/video',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

Update product video

requires authentication

Example request:

curl --request PUT \
    "https://app.launchcart.com/api/v1/store/1/products/1/video/magni" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/products/1/video/magni"
);

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

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

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'https://app.launchcart.com/api/v1/store/1/products/1/video/magni',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

Remove video

requires authentication

Example request:

curl --request DELETE \
    "https://app.launchcart.com/api/v1/store/1/products/1/video/magni" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/products/1/video/magni"
);

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

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

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'https://app.launchcart.com/api/v1/store/1/products/1/video/magni',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

GET api/v1/store/{storeId}/orders/details/{id}

requires authentication

Example request:

curl --request GET \
    --get "https://app.launchcart.com/api/v1/store/1/orders/details/magni" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/orders/details/magni"
);

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

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

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://app.launchcart.com/api/v1/store/1/orders/details/magni',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

POST api/v1/store/{storeId}/orders/{id}/mark-shipped

requires authentication

Example request:

curl --request POST \
    "https://app.launchcart.com/api/v1/store/1/orders/1/mark-shipped" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"orderItems\": [
        {
            \"tracking\": \"magni\",
            \"orderItemId\": \"magni\"
        }
    ],
    \"notifyCustomer\": true
}"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/orders/1/mark-shipped"
);

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

let body = {
    "orderItems": [
        {
            "tracking": "magni",
            "orderItemId": "magni"
        }
    ],
    "notifyCustomer": true
};

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

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://app.launchcart.com/api/v1/store/1/orders/1/mark-shipped',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'orderItems' => [
                [
                    'tracking' => 'magni',
                    'orderItemId' => 'magni',
                ],
            ],
            'notifyCustomer' => true,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

Request

POST api/v1/store/{storeId}/orders/{id}/mark-shipped

URL Parameters

storeId integer

id integer

The ID of the order.

Body Parameters

orderItems object[] optional

orderItems[].tracking string

orderItems[].orderItemId string

notifyCustomer boolean optional

GET api/v1/store/{storeId}/customTemplates/unlayerTemplates

requires authentication

Example request:

curl --request GET \
    --get "https://app.launchcart.com/api/v1/store/1/customTemplates/unlayerTemplates" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/customTemplates/unlayerTemplates"
);

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

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

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://app.launchcart.com/api/v1/store/1/customTemplates/unlayerTemplates',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

GET api/v1/store/{storeId}/customTemplates/unlayerTemplates/{templateId}

requires authentication

Example request:

curl --request GET \
    --get "https://app.launchcart.com/api/v1/store/1/customTemplates/unlayerTemplates/magni" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/customTemplates/unlayerTemplates/magni"
);

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

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

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://app.launchcart.com/api/v1/store/1/customTemplates/unlayerTemplates/magni',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

DELETE api/v1/store/{storeId}/customTemplates/{customTemplate_id}

requires authentication

Example request:

curl --request DELETE \
    "https://app.launchcart.com/api/v1/store/1/customTemplates/3" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/customTemplates/3"
);

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

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

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'https://app.launchcart.com/api/v1/store/1/customTemplates/3',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

DELETE api/v1/store/{storeId}/webhooks/{webhook_id}

requires authentication

Example request:

curl --request DELETE \
    "https://app.launchcart.com/api/v1/store/1/webhooks/02b733cc-1b0f-4490-b765-742b302fed58" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/webhooks/02b733cc-1b0f-4490-b765-742b302fed58"
);

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

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

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'https://app.launchcart.com/api/v1/store/1/webhooks/02b733cc-1b0f-4490-b765-742b302fed58',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

Update flow

requires authentication

Example request:

curl --request PUT \
    "https://app.launchcart.com/api/v1/store/1/payments/revere_payments" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"security_key\": \"magni\",
    \"tokenization_key\": \"magni\",
    \"is_3d_secure_enabled\": true
}"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/payments/revere_payments"
);

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

let body = {
    "security_key": "magni",
    "tokenization_key": "magni",
    "is_3d_secure_enabled": true
};

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

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'https://app.launchcart.com/api/v1/store/1/payments/revere_payments',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'security_key' => 'magni',
            'tokenization_key' => 'magni',
            'is_3d_secure_enabled' => true,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

PUT api/v1/store/{storeId}/products/upc/{upc}/inventory

requires authentication

Example request:

curl --request PUT \
    "https://app.launchcart.com/api/v1/store/1/products/upc/magni/inventory" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/products/upc/magni/inventory"
);

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

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

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'https://app.launchcart.com/api/v1/store/1/products/upc/magni/inventory',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

GET api/v1/store/{storeId}/subscribers

requires authentication

Example request:

curl --request GET \
    --get "https://app.launchcart.com/api/v1/store/1/subscribers" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/subscribers"
);

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

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

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://app.launchcart.com/api/v1/store/1/subscribers',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

GET api/v1/store/{storeId}/products/inventory

requires authentication

Example request:

curl --request GET \
    --get "https://app.launchcart.com/api/v1/store/1/products/inventory" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/products/inventory"
);

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

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

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://app.launchcart.com/api/v1/store/1/products/inventory',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

GET api/v1/store/{storeId}/apphooks

requires authentication

Example request:

curl --request GET \
    --get "https://app.launchcart.com/api/v1/store/1/apphooks" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/apphooks"
);

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

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

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://app.launchcart.com/api/v1/store/1/apphooks',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

POST api/v1/store/{storeId}/apphooks

requires authentication

Example request:

curl --request POST \
    "https://app.launchcart.com/api/v1/store/1/apphooks" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"type\": \"storefront_header\",
    \"content\": \"magni\",
    \"active\": true
}"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/apphooks"
);

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

let body = {
    "type": "storefront_header",
    "content": "magni",
    "active": true
};

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

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://app.launchcart.com/api/v1/store/1/apphooks',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'type' => 'storefront_header',
            'content' => 'magni',
            'active' => true,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error:

DELETE api/v1/store/{storeId}/apphooks/{appHook_id}

requires authentication

Example request:

curl --request DELETE \
    "https://app.launchcart.com/api/v1/store/1/apphooks/3" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://app.launchcart.com/api/v1/store/1/apphooks/3"
);

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

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

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'https://app.launchcart.com/api/v1/store/1/apphooks/3',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Received response:

Request failed with error: