Introduction

About our API


The BookingLive Version 1 API:

  • Is REST-based
  • Uses OAuth2 for Authorization
  • Always returns responses in JSON

All URL references in the API Documentation have the following base:

https://www.bookinglive.io/api/v1

Authentication

Setup

  1. Login into your Connect account Login

  2. Create a new Client navigate to the developers section (under settings) Connect Developers

  3. What you will need to authorize your users:

    • Client ID
    • Client Secret
    • Redirect URI
  4. The Connect API currently uses OAuth2.0 for authorization.

    • Server side Authorization:

      The following steps must be undertaken in order to authorize your users:

      1. Redirect users to our authorization URl, while including your API key and redirect URI as parameters:

        https://www.bookinglive.io/oauth/authorize?response_type=code&client_id=CLIENT_ID&redirect_uri=REDIRECT_URI

        When the user authorizes your app, your redirect URI will receive a request with the private ACCESS_TOKEN included as a query parameter. Example redirect of the Request you will be redirected to:

        http://www.yourdomain.com/oauth/redirect?code=YOUR_ACCESS_CODE
      2. Once redirected in order for you to receive an Authorization code you will need to make a POST request to

        https://www.bookinglive.io/oauth/token?grant_type=authorization_code&client_id=CLIENT_ID&client_secret=CLIENT_SECRET&code=ACCESS_CODE&redirect_uri=REDIRECT_URI

        The server will verify the access code you received from point 1 and used in point 2 and it will call the redirect URI you provided. The JSON response you receive will contain a private token that you will need to make API requests on behalf of the user.

    • Client side Authorization:

      1. Redirect users to our authorization URL, while including your API key and redirect URI as query parameters:

        https://www.bookinglive.io/oauth/authorize?response_type=token&client_id=CLIENT_ID&redirect_uri=REDIRECT_URI

        When the user authorizes your app, your redirect URI will receive a request with the private ACCESS_TOKEN included as a query parameter.

  5. Make an API Request

    • Authorization header

      in order to make a successful call to our API, you must include the Authorization header containing the ACCESS_TOKEN.

      Authorization: Bearer {TOKEN}

      For each of the users you would like to perform the API requests on behalf of, repeat the setup process.

Advice and recommended practises

  • Do not use the private tokens directly in client side code calls e.g... via ajax calls. These are meant for server-to-server communication only.
  • Delete unnecessary and unneeded API keys to minimize the risk of attack and exposure with the use of the key.

Responses

Errors

When an error occurs during an API request, you will receive:

  • An HTTP error status (400-500 range)
  • A JSON response containing more information about the error HTTP Response Code: 403 e.g.. Cancelling an Order with an invalid user id
{
    "success": false,
    "data": [],
    "errors": {
        "name": "ACCESS_DENIED",
        "message": "INVALID USER"
    }
}

Success

HTTP Response Code: 200 e.g.. Cancelling an order

{
    "success": true,
    "data": {
          "id": "5406b987-d1d3-61ea-b072-0528a00a88d2",
          "status": "cancelled"
    },
    "errors": [],
}

Reference


1. Make a Booking


GET - Retrieve Purchaser List


Requires authentication

HTTP Request

GET api/v1/booking/{order}/customer-list


$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://bookinglive.io/api/v1/booking/1/customer-list',
    [

            'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'Authorization' => 'Bearer {token}',
        ],

    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://connect.lndo.site/api/v1/booking/1/customer-list"
);

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

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

Example response (404):

{
    "success": false,
    "meta": {
        "locale": "en-GB",
        "language": "en",
        "encoding": "UTF-8",
        "domain": "messages",
        "supported_locales": [
            "en-GB",
            "en-US",
            "de-MO"
        ]
    },
    "data": [],
    "error": {
        "reason": "IDENTIFIER_NOT_FOUND"
    }
}

POST - Create new purchaser


Requires authentication

HTTP Request

POST api/v1/booking/{order}/save-customer

Body Parameters

Parameter Type Status Description
purchaser string required

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://bookinglive.io/api/v1/booking/1/save-customer',
    [

            'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'Authorization' => 'Bearer {token}',
        ],

        'json' => [
            'purchaser' => 'excepturi',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://connect.lndo.site/api/v1/booking/1/save-customer"
);

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

let body = {
    "purchaser": "excepturi"
}

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

Example response (404):

{
    "success": false,
    "meta": {
        "locale": "en-GB",
        "language": "en",
        "encoding": "UTF-8",
        "domain": "messages",
        "supported_locales": [
            "en-GB",
            "en-US",
            "de-MO"
        ]
    },
    "data": [],
    "error": {
        "reason": "IDENTIFIER_NOT_FOUND"
    }
}

GET - Retrieve Attendee information and setup form for Booking


Requires authentication

HTTP Request

GET api/v1/booking/{order}/attendees


$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://bookinglive.io/api/v1/booking/1/attendees',
    [

            'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'Authorization' => 'Bearer {token}',
        ],

    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://connect.lndo.site/api/v1/booking/1/attendees"
);

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

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

Example response (404):

{
    "success": false,
    "meta": {
        "locale": "en-GB",
        "language": "en",
        "encoding": "UTF-8",
        "domain": "messages",
        "supported_locales": [
            "en-GB",
            "en-US",
            "de-MO"
        ]
    },
    "data": [],
    "error": {
        "reason": "IDENTIFIER_NOT_FOUND"
    }
}

POST - Create Attendees and link to booking


Requires authentication

HTTP Request

POST api/v1/booking/{order}/save-attendees


$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://bookinglive.io/api/v1/booking/1/save-attendees',
    [

            'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'Authorization' => 'Bearer {token}',
        ],

    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://connect.lndo.site/api/v1/booking/1/save-attendees"
);

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

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

Example response (404):

{
    "success": false,
    "meta": {
        "locale": "en-GB",
        "language": "en",
        "encoding": "UTF-8",
        "domain": "messages",
        "supported_locales": [
            "en-GB",
            "en-US",
            "de-MO"
        ]
    },
    "data": [],
    "error": {
        "reason": "IDENTIFIER_NOT_FOUND"
    }
}

GET - Retrieve the basket


Requires authentication

HTTP Request

GET api/v1/booking/{order}/basket


$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://bookinglive.io/api/v1/booking/1/basket',
    [

            'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'Authorization' => 'Bearer {token}',
        ],

    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://connect.lndo.site/api/v1/booking/1/basket"
);

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

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

Example response (200):

{
    "success": true,
    "data": {
        "totalPrice": "0.00",
        "slots": [],
        "extras": []
    },
    "errors": [],
    "meta": {
        "locale": "en-GB",
        "language": "en",
        "encoding": "UTF-8",
        "domain": "messages",
        "supported_locales": [
            "en-GB",
            "en-US",
            "de-MO"
        ]
    },
    "error": null
}

2. Bookings


GET - A list of availabkle timeslots for an item


Requires authentication

HTTP Request

GET api/v1/booking/item/{item}

URL Parameters

Parameter Status Description
item optional string required Item ID.
order_id optional string optional Order ID.

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://bookinglive.io/api/v1/booking/item/bff1f8e1-bccf-61e8-4ed4-9c53130e9d51',
    [

            'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'Authorization' => 'Bearer {token}',
        ],

    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://connect.lndo.site/api/v1/booking/item/bff1f8e1-bccf-61e8-4ed4-9c53130e9d51"
);

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

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

Example response (404):

{
    "success": false,
    "meta": {
        "locale": "en-GB",
        "language": "en",
        "encoding": "UTF-8",
        "domain": "messages",
        "supported_locales": [
            "en-GB",
            "en-US",
            "de-MO"
        ]
    },
    "data": [],
    "error": {
        "reason": "IDENTIFIER_NOT_FOUND"
    }
}

POST - Create Order for a given timeslot


Requires authentication

HTTP Request

POST api/v1/booking

URL Parameters

Parameter Status Description
order_id optional string optional Order ID.

Body Parameters

Parameter Type Status Description
prices object required array of objects representing price points.
timeslots object required array of objects representing timeslots.

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://bookinglive.io/api/v1/booking',
    [

            'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'Authorization' => 'Bearer {token}',
        ],

        'json' => [
            'prices' => '[{"quantity":"2","id":"bff1f8e1-bccf-61e8-4ed4-9c53130e9d51"}]',
            'timeslots' => '[{"id":"bff1f8e1-bccf-61e8-4ed4-9c53130e9d51"}]',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://connect.lndo.site/api/v1/booking"
);

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

let body = {
    "prices": "[{\"quantity\":\"2\",\"id\":\"bff1f8e1-bccf-61e8-4ed4-9c53130e9d51\"}]",
    "timeslots": "[{\"id\":\"bff1f8e1-bccf-61e8-4ed4-9c53130e9d51\"}]"
}

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

Example response (500):

{
    "message": "Server Error"
}

GET - Retrieve Extras


Requires authentication

HTTP Request

GET api/v1/booking/{id}/extras

URL Parameters

Parameter Status Description
id optional string required Order ID.

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://bookinglive.io/api/v1/booking/bff1f8e1-bccf-61e8-4ed4-9c53130e9d51/extras',
    [

            'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'Authorization' => 'Bearer {token}',
        ],

    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://connect.lndo.site/api/v1/booking/bff1f8e1-bccf-61e8-4ed4-9c53130e9d51/extras"
);

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

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

Example response (500):

{
    "message": "Server Error"
}

POST - Add extras to Order


Requires authentication

HTTP Request

POST api/v1/booking/{id}/extras

URL Parameters

Parameter Status Description
id optional string required Order ID.

Body Parameters

Parameter Type Status Description
extras object required array of objects representing extras.

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://bookinglive.io/api/v1/booking/bff1f8e1-bccf-61e8-4ed4-9c53130e9d51/extras',
    [

            'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'Authorization' => 'Bearer {token}',
        ],

        'json' => [
            'extras' => '[{"quantity":"2","id":"bff1f8e1-bccf-61e8-4ed4-9c53130e9d51"}] or [{"attendeeId":"bff1f8e1-bccf-61e8-4ed4-9c53130e9d51", "timeslotId":"bff1f8e1-bccf-61e8-4ed4-9c53130e9d51","id":"bff1f8e1-bccf-61e8-4ed4-9c53130e9d51"}]',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://connect.lndo.site/api/v1/booking/bff1f8e1-bccf-61e8-4ed4-9c53130e9d51/extras"
);

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

let body = {
    "extras": "[{\"quantity\":\"2\",\"id\":\"bff1f8e1-bccf-61e8-4ed4-9c53130e9d51\"}] or [{\"attendeeId\":\"bff1f8e1-bccf-61e8-4ed4-9c53130e9d51\", \"timeslotId\":\"bff1f8e1-bccf-61e8-4ed4-9c53130e9d51\",\"id\":\"bff1f8e1-bccf-61e8-4ed4-9c53130e9d51\"}]"
}

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

Example response (422):

{
    "success": false,
    "meta": {
        "locale": "en-GB",
        "language": "en",
        "encoding": "UTF-8",
        "domain": "messages",
        "supported_locales": [
            "en-GB",
            "en-US",
            "de-MO"
        ]
    },
    "error": {
        "extras": [
            {
                "name": "ARRAY",
                "message": "The extras must be an array."
            }
        ]
    }
}

GET - Retrieve all bookings

Retrieve all bookings under your user returning publicly relevant data
Requires authentication

HTTP Request

GET api/v1/bookings


$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://bookinglive.io/api/v1/bookings',
    [

            'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'Authorization' => 'Bearer {token}',
        ],

    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://connect.lndo.site/api/v1/bookings"
);

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

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

Example response (200):

{
    "success": true,
    "data": [
        {
            "id": "",
            "reference": "",
            "account_id": "",
            "contact_id": "",
            "status": "completed",
            "subtotal": 0,
            "calculated_fee": 0.24,
            "calculated_vat": 0,
            "total": 0
        }
    ],
    "errors": [],
    "meta": {
        "locale": "en-GB",
        "language": "en",
        "encoding": "UTF-8",
        "domain": "messages",
        "supported_locales": [
            "en-GB",
            "en-US",
            "de-MO"
        ]
    },
    "error": null
}

GET - Retrieve All Events From Every Order

Retrieve all events for all orders with associated upsells and attendees
Requires authentication

HTTP Request

GET api/v1/bookings/events


$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://bookinglive.io/api/v1/bookings/events',
    [

            'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'Authorization' => 'Bearer {token}',
        ],

    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://connect.lndo.site/api/v1/bookings/events"
);

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

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

Example response (200):

{
    "success": true,
    "data": [
        {
            "event_name": "",
            "event_description": "",
            "id": "",
            "quantity": 1,
            "price": 10
        }
    ],
    "errors": [],
    "meta": {
        "locale": "en-GB",
        "language": "en",
        "encoding": "UTF-8",
        "domain": "messages",
        "supported_locales": [
            "en-GB",
            "en-US",
            "de-MO"
        ]
    },
    "error": null
}

GET - Retrieve Booking

Retrieve a specific booking with an Order ID
Requires authentication

HTTP Request

GET api/v1/bookings/{id}

URL Parameters

Parameter Status Description
id optional string required Order ID.

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://bookinglive.io/api/v1/bookings/5406b987-d1d3-61ea-ca83-66586cf4bb69',
    [

            'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'Authorization' => 'Bearer {token}',
        ],

    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://connect.lndo.site/api/v1/bookings/5406b987-d1d3-61ea-ca83-66586cf4bb69"
);

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

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

Example response (200):

{
    "success": true,
    "data": {
        "id": "",
        "reference": "",
        "account_id": "",
        "contact_id": "",
        "status": "completed",
        "subtotal": 0,
        "calculated_fee": 0.24,
        "calculated_vat": 0,
        "total": 0
    },
    "errors": [],
    "meta": {
        "locale": "en-GB",
        "language": "en",
        "encoding": "UTF-8",
        "domain": "messages",
        "supported_locales": [
            "en-GB",
            "en-US",
            "de-MO"
        ]
    },
    "error": null
}

GET - Retrieve All Items For A Single Order

Retrieve all items for a single order including upsells and attendees under an Order ID
Requires authentication

HTTP Request

GET api/v1/bookings/items/{id}

Body Parameters

Parameter Type Status Description
id string required Order ID.

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://bookinglive.io/api/v1/bookings/items/1',
    [

            'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'Authorization' => 'Bearer {token}',
        ],

        'json' => [
            'id' => '5406b987-d1d3-61ea-ca83-66586cf4bb69',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://connect.lndo.site/api/v1/bookings/items/1"
);

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

let body = {
    "id": "5406b987-d1d3-61ea-ca83-66586cf4bb69"
}

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

Example response (200):

{
    "success": true,
    "data": {
        "total_results": 1,
        "per_page": 50,
        "current_page": 1,
        "last_page": 1,
        "has_more_pages": false,
        "items": []
    },
    "errors": [],
    "meta": {
        "locale": "en-GB",
        "language": "en",
        "encoding": "UTF-8",
        "domain": "messages",
        "supported_locales": [
            "en-GB",
            "en-US",
            "de-MO"
        ]
    },
    "error": null
}

GET - Cancel Booking

Cancel a booking under a specified Order ID
Requires authentication

HTTP Request

POST api/v1/bookings/cancel/{id}

URL Parameters

Parameter Status Description
id optional string required Order ID.

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://bookinglive.io/api/v1/bookings/cancel/5406b987-d1d3-61ea-ca83-66586cf4bb69',
    [

            'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'Authorization' => 'Bearer {token}',
        ],

    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://connect.lndo.site/api/v1/bookings/cancel/5406b987-d1d3-61ea-ca83-66586cf4bb69"
);

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

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

Example response (200):

{
    "success": true,
    "data": {
        "id": "",
        "status": "cancelled"
    },
    "errors": [],
    "meta": {
        "locale": "en-GB",
        "language": "en",
        "encoding": "UTF-8",
        "domain": "messages",
        "supported_locales": [
            "en-GB",
            "en-US",
            "de-MO"
        ]
    },
    "error": null
}

GET - Retrieve all Attendees

Retrieve all attendees under the Purchaser ID

HTTP Request

GET api/v1/attendees/all/{id}

URL Parameters

Parameter Status Description
id optional string required ID of the purchaser

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://bookinglive.io/api/v1/attendees/all/esse',
    [

            'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'Authorization' => 'Bearer {token}',
        ],

    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://connect.lndo.site/api/v1/attendees/all/esse"
);

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

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

Example response (200):

{
    "success": true,
    "data": [],
    "errors": [],
    "meta": {
        "locale": "en-GB",
        "language": "en",
        "encoding": "UTF-8",
        "domain": "messages",
        "supported_locales": [
            "en-GB",
            "en-US",
            "de-MO"
        ]
    },
    "error": null
}

3. Transactions


GET - Retrieve all transactions

Retrieve all the transactions under the tokenized user.
Requires authentication

HTTP Request

GET api/v1/transactions

URL Parameters

Parameter Status Description
status optional string optional this is the current status of the transaction
payment_method optional string optional payment methods.
transaction_start_date optional date optional start date of the transaction.
transaction_end_date optional date optional end date of the transaction.

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://bookinglive.io/api/v1/transactions',
    [

            'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'Authorization' => 'Bearer {token}',
        ],

    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://connect.lndo.site/api/v1/transactions"
);

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

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

Example response (200):

{
    "success": true,
    "data": {
        "downloadUrl": "http:\/\/bookinglive.io\/download\/transactions\/report\/a6c55967-eaaf-4d15-8edf-69d8c3de9011",
        "transactions": [],
        "totals": {
            "totalGross": 0,
            "totalNet": 0,
            "totalFee": 0,
            "totalStripe": 0,
            "totalVAT": 0
        }
    },
    "errors": [],
    "meta": {
        "locale": "en-GB",
        "language": "en",
        "encoding": "UTF-8",
        "domain": "messages",
        "supported_locales": [
            "en-GB",
            "en-US",
            "de-MO"
        ]
    },
    "error": null
}

4. Contacts


GET - Retrieve all contacts

Retrieve all contacts under the tokenized user.
Requires authentication

HTTP Request

GET api/v1/contacts


$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://bookinglive.io/api/v1/contacts',
    [

            'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'Authorization' => 'Bearer {token}',
        ],

    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://connect.lndo.site/api/v1/contacts"
);

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

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

Example response (200):

{
    "success": true,
    "data": {
        "total_results": 1,
        "per_page": 50,
        "current_page": 1,
        "last_page": 1,
        "has_more_pages": false,
        "page_results": [
            {
                "account": null,
                "account_id": "bff1f8e1-bccf-61e8-4ed4-9c53130e9d51",
                "address": [],
                "company": null,
                "email": "james.bond@example.com",
                "firstname": "James",
                "id": "5406b987-d1d3-61ea-98f5-1c496074b325",
                "lastname": "Bond",
                "position": null,
                "reference": "CR0-00001",
                "telephone": "07700000000",
                "temp_email": null,
                "title": null
            }
        ]
    },
    "errors": [],
    "meta": {
        "locale": "en-GB",
        "language": "en",
        "encoding": "UTF-8",
        "domain": "messages",
        "supported_locales": [
            "en-GB",
            "en-US",
            "de-MO"
        ]
    },
    "error": null
}

GET - Retrieve a contact

Retrieve a single contacts details with a specified ID
Requires authentication

HTTP Request

GET api/v1/contacts/{contact_id}

URL Parameters

Parameter Status Description
id optional string required Contact ID.

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://bookinglive.io/api/v1/contacts/1',
    [

            'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'Authorization' => 'Bearer {token}',
        ],

    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://connect.lndo.site/api/v1/contacts/1"
);

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

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

Example response (200):

{
    "success": true,
    "data": {
        "account": null,
        "account_id": "bff1f8e1-bccf-61e8-4ed4-9c53130e9d51",
        "address": [],
        "company": null,
        "email": "james.bond@example.com",
        "firstname": "James",
        "id": "5406b987-d1d3-61ea-98f5-1c496074b325",
        "lastname": "Bond",
        "position": null,
        "reference": "CR0-00001",
        "telephone": "07700000000",
        "temp_email": null,
        "title": null
    },
    "errors": [],
    "meta": {
        "locale": "en-GB",
        "language": "en",
        "encoding": "UTF-8",
        "domain": "messages",
        "supported_locales": [
            "en-GB",
            "en-US",
            "de-MO"
        ]
    },
    "error": null
}

5. Customers


GET - Retrieve customer

Retrieve a single customers details based on the customer ID
Requires authentication

HTTP Request

GET api/v1/customers/{id}

URL Parameters

Parameter Status Description
id optional string required Customer ID.

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://bookinglive.io/api/v1/customers/5406b987-d1d3-61ea-c1e2-91ed21428747',
    [

            'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'Authorization' => 'Bearer {token}',
        ],

    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://connect.lndo.site/api/v1/customers/5406b987-d1d3-61ea-c1e2-91ed21428747"
);

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

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

Example response (200):

{
    "success": true,
    "data": {
        "id": "5406b987-d1d3-61ea-c1e2-91ed21428747",
        "email": "example@example.com",
        "title": "Mr",
        "firstname": "John",
        "lastname": "Smith",
        "company": "Example Inc",
        "position": "Administrator",
        "telephone": "0117 933 8632",
        "reference": "CR00-0000",
        "account_id": "1",
        "orders": 0,
        "total": 0,
        "average": 0
    },
    "errors": [],
    "meta": {
        "locale": "en-GB",
        "language": "en",
        "encoding": "UTF-8",
        "domain": "messages",
        "supported_locales": [
            "en-GB",
            "en-US",
            "de-MO"
        ]
    },
    "error": null
}

GET - Retrieve all customers

Retrieve all the customers registered under the tokenized user
Requires authentication

HTTP Request

GET api/v1/customers


$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://bookinglive.io/api/v1/customers',
    [

            'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'Authorization' => 'Bearer {token}',
        ],

    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://connect.lndo.site/api/v1/customers"
);

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

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

Example response (200):

{
    "success": true,
    "data": [
        {
            "id": "5406b987-d1d3-61ea-c1e2-91ed21428747",
            "email": "example@example.com",
            "title": "Mr",
            "firstname": "John",
            "lastname": "Smith",
            "company": "Example Inc",
            "position": "Administrator",
            "telephone": "0117 933 8632",
            "reference": "CR00-0000",
            "account_id": "1",
            "orders": 0,
            "total": 0,
            "average": 0
        }
    ],
    "errors": [],
    "meta": {
        "locale": "en-GB",
        "language": "en",
        "encoding": "UTF-8",
        "domain": "messages",
        "supported_locales": [
            "en-GB",
            "en-US",
            "de-MO"
        ]
    },
    "error": null
}

6. Accounts


GET - Retrieve Account

Retrieve a single account details with a specified account ID
Requires authentication

HTTP Request

GET api/v1/account/{id}

URL Parameters

Parameter Status Description
id required ID.

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://bookinglive.io/api/v1/account/5406b987-d1d3-61ea-c1e2-91dc8986a193',
    [

            'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'Authorization' => 'Bearer {token}',
        ],

    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://connect.lndo.site/api/v1/account/5406b987-d1d3-61ea-c1e2-91dc8986a193"
);

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

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

Example response (200):

{
    "success": true,
    "data": {
        "currency_code": "",
        "iframe_embed_code": "",
        "public_share_link": "",
        "integrations": "",
        "name": "string",
        "url": "string",
        "reference": "string",
        "terms_conditions": "string",
        "accepted_locale": "bool",
        "include_confirmation_email": "bool"
    },
    "errors": [],
    "meta": {
        "locale": "en-GB",
        "language": "en",
        "encoding": "UTF-8",
        "domain": "messages",
        "supported_locales": [
            "en-GB",
            "en-US",
            "de-MO"
        ]
    },
    "error": null
}

POST - Update Account

Update an accounts details
Requires authentication

HTTP Request

POST api/v1/account/{id}

URL Parameters

Parameter Status Description
id optional string required ID.

Body Parameters

Parameter Type Status Description
terms_conditions_type string required the terms and conditions type should only contain either "url" or "text".
name string required the account name.
currency_code string optional optional the currency code you want to use.

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://bookinglive.io/api/v1/account/bff1f8e1-bccf-61e8-4ed4-9c44d51eba23',
    [

            'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'Authorization' => 'Bearer {token}',
        ],

        'json' => [
            'terms_conditions_type' => 'url',
            'name' => 'Horse Riding',
            'currency_code' => 'GBP',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://connect.lndo.site/api/v1/account/bff1f8e1-bccf-61e8-4ed4-9c44d51eba23"
);

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

let body = {
    "terms_conditions_type": "url",
    "name": "Horse Riding",
    "currency_code": "GBP"
}

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

Example response (200):

{
    "success": true,
    "data": [],
    "errors": [],
    "meta": {
        "locale": "en-GB",
        "language": "en",
        "encoding": "UTF-8",
        "domain": "messages",
        "supported_locales": [
            "en-GB",
            "en-US",
            "de-MO"
        ]
    },
    "error": null
}

7. Upsell


GET - Retrieve Upsells

Retrieve all upsell details under the tokenized user
Requires authentication

HTTP Request

GET api/v1/upsells

Body Parameters

Parameter Type Status Description
per_page numeric optional optional amount of upsells per page.
page numeric optional optional the page you want to return.

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://bookinglive.io/api/v1/upsells',
    [

            'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'Authorization' => 'Bearer {token}',
        ],

        'json' => [
            'per_page' => '50',
            'page' => '1',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://connect.lndo.site/api/v1/upsells"
);

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

let body = {
    "per_page": "50",
    "page": "1"
}

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

Example response (200):

{
    "success": true,
    "data": {
        "total_results": 1,
        "per_page": "50",
        "current_page": 1,
        "last_page": 1,
        "has_more_pages": false,
        "page_results": [
            {
                "id": "cb3b8781-a911-61ea-ccbf-9532d684ba1a",
                "account_id": "cb3b8781-a911-61ea-ccbf-950fb852a624",
                "type": "freeform",
                "default_price": 2,
                "price_per": "element",
                "description": "Description for freeform upsell",
                "name": "Freeform upsell"
            }
        ]
    },
    "errors": [],
    "meta": {
        "locale": "en-GB",
        "language": "en",
        "encoding": "UTF-8",
        "domain": "messages",
        "supported_locales": [
            "en-GB",
            "en-US",
            "de-MO"
        ]
    },
    "error": null
}

GET - Retrieve Upsells

Retrieve all upsell details under the tokenized user
Requires authentication

HTTP Request

GET api/v1/upsell/all

Body Parameters

Parameter Type Status Description
per_page numeric optional optional amount of upsells per page.
page numeric optional optional the page you want to return.

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://bookinglive.io/api/v1/upsell/all',
    [

            'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'Authorization' => 'Bearer {token}',
        ],

        'json' => [
            'per_page' => '50',
            'page' => '1',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://connect.lndo.site/api/v1/upsell/all"
);

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

let body = {
    "per_page": "50",
    "page": "1"
}

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

Example response (200):

{
    "success": true,
    "data": {
        "total_results": 1,
        "per_page": "50",
        "current_page": 1,
        "last_page": 1,
        "has_more_pages": false,
        "page_results": [
            {
                "id": "cb3b8781-a911-61ea-ccbf-9532d684ba1a",
                "account_id": "cb3b8781-a911-61ea-ccbf-950fb852a624",
                "type": "freeform",
                "default_price": 2,
                "price_per": "element",
                "description": "Description for freeform upsell",
                "name": "Freeform upsell"
            }
        ]
    },
    "errors": [],
    "meta": {
        "locale": "en-GB",
        "language": "en",
        "encoding": "UTF-8",
        "domain": "messages",
        "supported_locales": [
            "en-GB",
            "en-US",
            "de-MO"
        ]
    },
    "error": null
}

GET - Retrieve Upsell

Retrieve Upsell details based on the upsell ID
Requires authentication

HTTP Request

GET api/v1/upsell/{upsell}

URL Parameters

Parameter Status Description
id optional string required Upsell ID.

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://bookinglive.io/api/v1/upsell/1',
    [

            'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'Authorization' => 'Bearer {token}',
        ],

    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://connect.lndo.site/api/v1/upsell/1"
);

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

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

Example response (200):

{
    "success": true,
    "data": {
        "id": "cb3b8781-a911-61ea-ccbf-9532d684ba1a",
        "account_id": "cb3b8781-a911-61ea-ccbf-950fb852a624",
        "type": "freeform",
        "default_price": 2,
        "price_per": "element",
        "description": "Description for freeform upsell",
        "name": "Freeform upsell"
    },
    "errors": [],
    "meta": {
        "locale": "en-GB",
        "language": "en",
        "encoding": "UTF-8",
        "domain": "messages",
        "supported_locales": [
            "en-GB",
            "en-US",
            "de-MO"
        ]
    },
    "error": null
}

POST - Update upsell

Update an upsell under the the upsell ID.
Requires authentication

HTTP Request

POST api/v1/upsell/update/{id}

URL Parameters

Parameter Status Description
id optional string required Upsell ID

Body Parameters

Parameter Type Status Description
items array required List of Items the upsell applies to.
name string required upsell name.
default_price string required number
description string required description for the upsell
type string required type of upsell.

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://bookinglive.io/api/v1/upsell/update/bff1f8e1-bccf-61e8-4ed4-9c6aa8ca8b32',
    [

            'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'Authorization' => 'Bearer {token}',
        ],

        'json' => [
            'items' => '[\'bff1f8e1-bccf-61e8-4ed4-9c5510e6b74c\']',
            'name' => '\'Kit upsell\'',
            'default_price' => 'delectus',
            'description' => 'quasi',
            'type' => 'options:- freeform, kit',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://connect.lndo.site/api/v1/upsell/update/bff1f8e1-bccf-61e8-4ed4-9c6aa8ca8b32"
);

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

let body = {
    "items": "['bff1f8e1-bccf-61e8-4ed4-9c5510e6b74c']",
    "name": "'Kit upsell'",
    "default_price": "delectus",
    "description": "quasi",
    "type": "options:- freeform, kit"
}

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

Example response (200):

{
    "success": true,
    "data": [],
    "errors": [],
    "meta": {
        "locale": "en-GB",
        "language": "en",
        "encoding": "UTF-8",
        "domain": "messages",
        "supported_locales": [
            "en-GB",
            "en-US",
            "de-MO"
        ]
    },
    "error": null
}

8. Integrations


GET - Retrieve all available integrations

from here you can view the list of connectable integrations we store
Requires authentication

HTTP Request

GET api/v1/integrations

URL Parameters

Parameter Status Description
requiresConfig optional optional boolean.
categories optional optional string.

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://bookinglive.io/api/v1/integrations',
    [

            'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'Authorization' => 'Bearer {token}',
        ],

    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://connect.lndo.site/api/v1/integrations"
);

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

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

Example response (200):

{
    "success": true,
    "data": [
        {
            "id": "",
            "name": "Stripe",
            "description": "Stripe Payments"
        }
    ],
    "errors": [],
    "meta": {
        "locale": "en-GB",
        "language": "en",
        "encoding": "UTF-8",
        "domain": "messages",
        "supported_locales": [
            "en-GB",
            "en-US",
            "de-MO"
        ]
    },
    "error": null
}

GET - Retrieve specific integration

from here you can view the specific connectable integrations
Requires authentication

HTTP Request

GET api/v1/integrations/{handle}

URL Parameters

Parameter Status Description
requiresConfig optional optional boolean.
categories optional optional string.
id optional string required Integration ID

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://bookinglive.io/api/v1/integrations/1',
    [

            'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'Authorization' => 'Bearer {token}',
        ],

    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://connect.lndo.site/api/v1/integrations/1"
);

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

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

Example response (500):

{
    "message": "Server Error"
}

GET - Retrieve all available integrations

from here you can view the list of connectable integrations we store
Requires authentication

HTTP Request

GET api/v1/integrations/available

URL Parameters

Parameter Status Description
requiresConfig optional optional boolean.
categories optional optional string.

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://bookinglive.io/api/v1/integrations/available',
    [

            'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'Authorization' => 'Bearer {token}',
        ],

    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://connect.lndo.site/api/v1/integrations/available"
);

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

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

Example response (500):

{
    "message": "Server Error"
}

GET - Retrieve specific integration

from here you can view the specific connectable integrations
Requires authentication

HTTP Request

GET api/v1/integrations/available/{handle}

URL Parameters

Parameter Status Description
requiresConfig optional optional boolean.
categories optional optional string.
id optional string required Integration ID

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://bookinglive.io/api/v1/integrations/available/1',
    [

            'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'Authorization' => 'Bearer {token}',
        ],

    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://connect.lndo.site/api/v1/integrations/available/1"
);

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

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

Example response (500):

{
    "message": "Server Error"
}

GET - Retrieve category list

from here you can retrieve all the categories available
Requires authentication

HTTP Request

GET api/v1/integrations/categories


$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://bookinglive.io/api/v1/integrations/categories',
    [

            'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'Authorization' => 'Bearer {token}',
        ],

    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://connect.lndo.site/api/v1/integrations/categories"
);

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

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

Example response (500):

{
    "message": "Server Error"
}

GET - Retrieve activated Integration

Retrieve the specified integration that you would have already connected to.
Requires authentication

HTTP Request

GET api/v1/integrations/user/{handle}

URL Parameters

Parameter Status Description
integration required id.
id optional string required Integration ID

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://bookinglive.io/api/v1/integrations/user/1',
    [

            'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'Authorization' => 'Bearer {token}',
        ],

    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://connect.lndo.site/api/v1/integrations/user/1"
);

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

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

Example response (200):

{
    "success": true,
    "data": [],
    "errors": [],
    "meta": {
        "locale": "en-GB",
        "language": "en",
        "encoding": "UTF-8",
        "domain": "messages",
        "supported_locales": [
            "en-GB",
            "en-US",
            "de-MO"
        ]
    },
    "error": null
}

9. Items


Fetch All Items

Retrieves all the items linked to your account
Requires authentication

HTTP Request

GET api/v1/items


$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://bookinglive.io/api/v1/items',
    [

            'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'Authorization' => 'Bearer {token}',
        ],

    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://connect.lndo.site/api/v1/items"
);

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

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

Example response (200):

{
    "success": true,
    "data": {
        "total_results": 1,
        "per_page": 100,
        "current_page": 1,
        "last_page": 1,
        "has_more_pages": false,
        "page_results": [
            {
                "id": "",
                "account_id": "",
                "form_id": null,
                "item_type": "appointment",
                "event_type": "simple",
                "interface": "admin",
                "flexi": false,
                "solo": false,
                "name": "Horse Riding Induction Appointment",
                "description": "Induction for horse riding",
                "require_attendee_info": true,
                "created_at": "2020-05-03 13:19:29",
                "updated_at": "2020-05-03 13:19:29",
                "deleted_at": null,
                "entity": "item",
                "video_id": null,
                "video_url": null,
                "terms_conditions_url": null,
                "terms_conditions": null,
                "terms_conditions_type": null,
                "zoom_enabled": false,
                "images": {
                    "desktop": [],
                    "mobile": [],
                    "thumbs": []
                },
                "stripe_connected": false,
                "resources": [],
                "pictures": []
            }
        ]
    },
    "errors": [],
    "meta": {
        "locale": "en-GB",
        "language": "en",
        "encoding": "UTF-8",
        "domain": "messages",
        "supported_locales": [
            "en-GB",
            "en-US",
            "de-MO"
        ]
    },
    "error": null
}

GET - Retrieve Item

this will return the item details
Requires authentication

HTTP Request

GET api/v1/items/{id}

URL Parameters

Parameter Status Description
id required ID.

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://bookinglive.io/api/v1/items/5406b987-d1d3-61ea-ca83-665406beb951',
    [

            'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'Authorization' => 'Bearer {token}',
        ],

    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://connect.lndo.site/api/v1/items/5406b987-d1d3-61ea-ca83-665406beb951"
);

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

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

Example response (200):

{
    "success": true,
    "data": {
        "id": "",
        "account_id": "",
        "form_id": null,
        "item_type": "appointment",
        "event_type": "simple",
        "interface": "admin",
        "flexi": false,
        "solo": false,
        "name": "Horse Riding Induction Appointment",
        "description": "Induction for horse riding",
        "require_attendee_info": true,
        "created_at": "2020-05-03 13:19:29",
        "updated_at": "2020-05-03 13:19:29",
        "deleted_at": null,
        "entity": "item",
        "video_id": null,
        "video_url": null,
        "terms_conditions_url": null,
        "terms_conditions": null,
        "terms_conditions_type": null,
        "zoom_enabled": false,
        "images": {
            "desktop": [],
            "mobile": [],
            "thumbs": []
        },
        "stripe_connected": false,
        "resources": [],
        "pictures": []
    },
    "errors": [],
    "meta": {
        "locale": "en-GB",
        "language": "en",
        "encoding": "UTF-8",
        "domain": "messages",
        "supported_locales": [
            "en-GB",
            "en-US",
            "de-MO"
        ]
    },
    "error": null
}

Create item


Requires authentication

HTTP Request

PUT api/v1/items/{id}

Body Parameters

Parameter Type Status Description
name string required the name of your Booking Item.
description string required the description of your item to be displayed on the booking form.
upsells string optional optional Upsell ID.
prices object optional optional array of objects representing price points.

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'https://bookinglive.io/api/v1/items/1',
    [

            'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'Authorization' => 'Bearer {token}',
        ],

        'json' => [
            'name' => 'expedita',
            'description' => 'totam',
            'upsells' => 'bff1f8e1-bccf-61e8-4ed4-9c6aa8ca8b32',
            'prices' => '[{"type":"Adult","cost":"25"}]',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://connect.lndo.site/api/v1/items/1"
);

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

let body = {
    "name": "expedita",
    "description": "totam",
    "upsells": "bff1f8e1-bccf-61e8-4ed4-9c6aa8ca8b32",
    "prices": "[{\"type\":\"Adult\",\"cost\":\"25\"}]"
}

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

Example response (422):

{
    "success": false,
    "meta": {
        "locale": "en-GB",
        "language": "en",
        "encoding": "UTF-8",
        "domain": "messages",
        "supported_locales": [
            "en-GB",
            "en-US",
            "de-MO"
        ]
    },
    "error": null,
    "errors": {
        "prices": [
            {
                "name": "ARRAY",
                "message": "The prices must be an array."
            }
        ]
    }
}

POST - Update Item


Requires authentication

HTTP Request

POST api/v1/items/{id}

URL Parameters

Parameter Status Description
item required ID

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://bookinglive.io/api/v1/items/1',
    [

            'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'Authorization' => 'Bearer {token}',
        ],

    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://connect.lndo.site/api/v1/items/1"
);

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

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

Example response (200):

{
    "success": true,
    "data": [],
    "errors": [],
    "meta": {
        "locale": "en-GB",
        "language": "en",
        "encoding": "UTF-8",
        "domain": "messages",
        "supported_locales": [
            "en-GB",
            "en-US",
            "de-MO"
        ]
    },
    "error": null
}

DELETE - Delete Item


Requires authentication

HTTP Request

DELETE api/v1/items/{id}

URL Parameters

Parameter Status Description
item required ID

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'https://bookinglive.io/api/v1/items/1',
    [

            'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'Authorization' => 'Bearer {token}',
        ],

    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://connect.lndo.site/api/v1/items/1"
);

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

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

Example response (200):

{
    "success": true,
    "data": [],
    "errors": [],
    "meta": {
        "locale": "en-GB",
        "language": "en",
        "encoding": "UTF-8",
        "domain": "messages",
        "supported_locales": [
            "en-GB",
            "en-US",
            "de-MO"
        ]
    },
    "error": null
}

Company


api/v1/{account}/booking/item/{item}

HTTP Request

GET api/v1/{account}/booking/item/{item}


$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://bookinglive.io/api/v1/1/booking/item/1',
    [

            'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'Authorization' => 'Bearer {token}',
        ],

    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://connect.lndo.site/api/v1/1/booking/item/1"
);

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

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

Example response (404):

{
    "success": false,
    "meta": {
        "locale": "en-GB",
        "language": "en",
        "encoding": "UTF-8",
        "domain": "messages",
        "supported_locales": [
            "en-GB",
            "en-US",
            "de-MO"
        ]
    },
    "data": [],
    "error": {
        "reason": "IDENTIFIER_NOT_FOUND"
    }
}

api/v1/{account}/booking

HTTP Request

POST api/v1/{account}/booking


$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://bookinglive.io/api/v1/1/booking',
    [

            'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'Authorization' => 'Bearer {token}',
        ],

    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://connect.lndo.site/api/v1/1/booking"
);

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

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

Example response (404):

{
    "success": false,
    "meta": {
        "locale": "en-GB",
        "language": "en",
        "encoding": "UTF-8",
        "domain": "messages",
        "supported_locales": [
            "en-GB",
            "en-US",
            "de-MO"
        ]
    },
    "data": [],
    "error": {
        "reason": "IDENTIFIER_NOT_FOUND"
    }
}

api/v1/{account}/booking/{order}/attendees

HTTP Request

GET api/v1/{account}/booking/{order}/attendees


$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://bookinglive.io/api/v1/1/booking/1/attendees',
    [

            'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'Authorization' => 'Bearer {token}',
        ],

    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://connect.lndo.site/api/v1/1/booking/1/attendees"
);

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

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

Example response (404):

{
    "success": false,
    "meta": {
        "locale": "en-GB",
        "language": "en",
        "encoding": "UTF-8",
        "domain": "messages",
        "supported_locales": [
            "en-GB",
            "en-US",
            "de-MO"
        ]
    },
    "data": [],
    "error": {
        "reason": "IDENTIFIER_NOT_FOUND"
    }
}

api/v1/{account}/booking/{order}/save-attendees

HTTP Request

POST api/v1/{account}/booking/{order}/save-attendees


$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://bookinglive.io/api/v1/1/booking/1/save-attendees',
    [

            'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'Authorization' => 'Bearer {token}',
        ],

    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://connect.lndo.site/api/v1/1/booking/1/save-attendees"
);

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

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

Example response (404):

{
    "success": false,
    "meta": {
        "locale": "en-GB",
        "language": "en",
        "encoding": "UTF-8",
        "domain": "messages",
        "supported_locales": [
            "en-GB",
            "en-US",
            "de-MO"
        ]
    },
    "data": [],
    "error": {
        "reason": "IDENTIFIER_NOT_FOUND"
    }
}

api/v1/{account}/booking/{order}/extras

HTTP Request

GET api/v1/{account}/booking/{order}/extras


$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://bookinglive.io/api/v1/1/booking/1/extras',
    [

            'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'Authorization' => 'Bearer {token}',
        ],

    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://connect.lndo.site/api/v1/1/booking/1/extras"
);

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

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

Example response (404):

{
    "success": false,
    "meta": {
        "locale": "en-GB",
        "language": "en",
        "encoding": "UTF-8",
        "domain": "messages",
        "supported_locales": [
            "en-GB",
            "en-US",
            "de-MO"
        ]
    },
    "data": [],
    "error": {
        "reason": "IDENTIFIER_NOT_FOUND"
    }
}

api/v1/{account}/booking/{order}/extras

HTTP Request

POST api/v1/{account}/booking/{order}/extras


$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://bookinglive.io/api/v1/1/booking/1/extras',
    [

            'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'Authorization' => 'Bearer {token}',
        ],

    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://connect.lndo.site/api/v1/1/booking/1/extras"
);

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

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

Example response (404):

{
    "success": false,
    "meta": {
        "locale": "en-GB",
        "language": "en",
        "encoding": "UTF-8",
        "domain": "messages",
        "supported_locales": [
            "en-GB",
            "en-US",
            "de-MO"
        ]
    },
    "data": [],
    "error": {
        "reason": "IDENTIFIER_NOT_FOUND"
    }
}

api/v1/{account}/booking/{order}/basket

HTTP Request

GET api/v1/{account}/booking/{order}/basket


$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://bookinglive.io/api/v1/1/booking/1/basket',
    [

            'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'Authorization' => 'Bearer {token}',
        ],

    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://connect.lndo.site/api/v1/1/booking/1/basket"
);

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

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

Example response (500):

{
    "message": "Server Error"
}

general


GET /api/v1/integrations/{handle}/config

HTTP Request

GET api/v1/integrations/{handle}/config


$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://bookinglive.io/api/v1/integrations/1/config',
    [

            'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'Authorization' => 'Bearer {token}',
        ],

    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://connect.lndo.site/api/v1/integrations/1/config"
);

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

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

Example response (500):

{
    "message": "Server Error"
}

POST /api/v1/integrations/{handle}/config

HTTP Request

POST api/v1/integrations/{handle}/config


$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://bookinglive.io/api/v1/integrations/1/config',
    [

            'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'Authorization' => 'Bearer {token}',
        ],

    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
    "http://connect.lndo.site/api/v1/integrations/1/config"
);

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

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

Example response (500):

{
    "message": "Server Error"
}