Booking Flow

Offering Availability

Endpoints for retrieving offering availability.

get/shop/item-availability/table-reservation-slots/{tableReservationTypeId}

Get available table reservation slots on a single date.

getTableReservationSlots

This endpoint retrieves a list of slots for the reservation type on the given date.

Path parameters

tableReservationTypeIdobject-idrequired
The ID of the TableReservationType.

Query parameters

datedaterequired
The date the reservation is for.
num_guestsintegerrequired
The number of guests the reservation is for.

Responses

200
The table reservation slots were successfully retrieved
401
The user is unauthenticated
404
The resource couldn't be found

curl "https://api.playground.try.be/shop/item-availability/table-reservation-slots/abc123?date=2026-01-15&num_guests=value" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json"

const response = await fetch('https://api.playground.try.be/shop/item-availability/table-reservation-slots/abc123?date=2026-01-15&num_guests=value', {
  method: 'GET',
  headers: {
    Authorization: 'Bearer YOUR_API_KEY',
    Accept: 'application/json',
  },
})

if (!response.ok) {
  throw new Error(`Trybe API ${response.status}: ${await response.text()}`)
}

const data = await response.json()

import httpx

response = httpx.get(
    "https://api.playground.try.be/shop/item-availability/table-reservation-slots/abc123?date=2026-01-15&num_guests=value",
    headers={
        "Authorization": "Bearer YOUR_API_KEY",
        "Accept": "application/json",
    },
)
response.raise_for_status()
data = response.json()

<?php

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://api.playground.try.be/shop/item-availability/table-reservation-slots/abc123?date=2026-01-15&num_guests=value', [
    'headers' => [
        'Authorization' => 'Bearer YOUR_API_KEY',
        'Accept' => 'application/json',
    ],
]);

$data = json_decode($response->getBody(), true);

package main

import (
	"encoding/json"
	"net/http"
)

func main() {
	req, _ := http.NewRequest("GET", "https://api.playground.try.be/shop/item-availability/table-reservation-slots/abc123?date=2026-01-15&num_guests=value", nil)
	req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
	req.Header.Set("Accept", "application/json")
	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()
	var data map[string]interface{}
	json.NewDecoder(resp.Body).Decode(&data)
}

The table reservation slots were successfully retrieved

{
  "data": [
    {
      "start_time": "2024-04-01T12:00:00+01:00",
      "end_time": "2024-04-01T13:00:00+01:00",
      "duration": 60,
      "is_fixed_end_time": true,
      "price": 1,
      "is_available": true,
      "requires_credit_card": false,
      "options": [
        {
          "id": "1234",
          "name": "Afternoon Tea promotion",
          "optional": false,
          "provider_id": "00000000-0000-0000-0000-000000000000",
          "type": "promotion"
        }
      ]
    }
  ]
}

{
  "message": "Unauthenticated"
}

{
  "message": "The requested resource could not be found"
}

get/shop/appointment-slots/{appointmentTypeId}/{date}

List appointment slots on a single date

listAppointmentSlots

Use this endpoint to list every potential start time for a given AppointmentType on a single date, together with each slot's bookability metadata.

The response is an array of AppointmentSlot entries. Each slot includes the start and end time, the duration and end buffer, the practitioners and rooms that could be used to deliver it, the quantity currently available (quantity_available) versus the theoretical maximum (total_quantity), and the price in the smallest currency unit. Slots that aren't currently bookable expose a machine-readable no_availability_reason (e.g. time_passed, no_practitioners_available, not_yet_bookable) and a human-readable no_availability_message.

To check availability across a sliding date-time window — useful for appointment enquiries where the customer is flexible on date — use actionCheckAppointmentEnquiryAvailability instead.

Path parameters

appointmentTypeIdmongo-idrequired
The ID of the AppointmentType to check availability for.
datedaterequired
The date to check availability on, in YYYY-MM-DD format. The date is interpreted in the timezone of the site the appointment type belongs to.

Query parameters

practitioner_idmongo-idoptional
Optionally restrict the results to slots that can be offered by a specific practitioner. When omitted, all eligible practitioners are considered.
quantityintegeroptional
The number of appointment slots required at the same start time. Used when booking multiple guests onto the same appointment type. Defaults to 1.

Responses

200
The list of available appointment slots was successfully retrieved.
401
The user is unauthenticated
404
The resource couldn't be found

curl "https://api.playground.try.be/shop/appointment-slots/abc123/2026-06-12" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json"

const response = await fetch('https://api.playground.try.be/shop/appointment-slots/abc123/2026-06-12', {
  method: 'GET',
  headers: {
    Authorization: 'Bearer YOUR_API_KEY',
    Accept: 'application/json',
  },
})

if (!response.ok) {
  throw new Error(`Trybe API ${response.status}: ${await response.text()}`)
}

const data = await response.json()

import httpx

response = httpx.get(
    "https://api.playground.try.be/shop/appointment-slots/abc123/2026-06-12",
    headers={
        "Authorization": "Bearer YOUR_API_KEY",
        "Accept": "application/json",
    },
)
response.raise_for_status()
data = response.json()

<?php

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://api.playground.try.be/shop/appointment-slots/abc123/2026-06-12', [
    'headers' => [
        'Authorization' => 'Bearer YOUR_API_KEY',
        'Accept' => 'application/json',
    ],
]);

$data = json_decode($response->getBody(), true);

package main

import (
	"encoding/json"
	"net/http"
)

func main() {
	req, _ := http.NewRequest("GET", "https://api.playground.try.be/shop/appointment-slots/abc123/2026-06-12", nil)
	req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
	req.Header.Set("Accept", "application/json")
	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()
	var data map[string]interface{}
	json.NewDecoder(resp.Body).Decode(&data)
}

The list of available appointment slots was successfully retrieved.

{
  "data": [
    {
      "start_time": "2026-01-15T09:30:00+00:00",
      "end_time": "2026-01-15T09:30:00+00:00",
      "duration": 60,
      "end_buffer": 15,
      "practitioner_ids": [
        "64a9f3b2c3d8e1f4a5b6c7d8"
      ],
      "room_ids": [
        "64a9f3b2c3d8e1f4a5b6c7d8"
      ],
      "equipment_ids": [
        "64a9f3b2c3d8e1f4a5b6c7d8"
      ],
      "suggested_combinations": [
        {
          "room_id": "64a9f3b2c3d8e1f4a5b6c7d8",
          "practitioner_ids": [
            "64a9f3b2c3d8e1f4a5b6c7d8"
          ]
        }
      ],
      "total_quantity": 5,
      "quantity_available": 3,
      "is_valid": true,
      "price": 8995,
      "currency": "gbp",
      "nonoptimal_practitioner_allocation": false,
      "nonoptimal_practitioner_ids": [
        "string"
      ],
      "no_availability_reason": "time_passed",
      "no_availability_message": "No practitioners are available.",
      "bookable_from": "2026-01-15T09:30:00+00:00",
      "bookable_to": "2026-01-15T09:30:00+00:00"
    }
  ]
}

{
  "message": "Unauthenticated"
}

{
  "message": "The requested resource could not be found"
}

get/shop/area-booking-slots/{areaBookingTypeId}

List area-booking slots across a date range

listAreaBookingSlots

Use this endpoint to list every potential start time for a given AreaBookingType across a date range, with each slot's pricing and availability metadata.

The response contains an array of AreaBookingSlot entries. Each slot lists the start and end time, the duration in minutes, the areas that could deliver it, the quantity currently available versus the theoretical maximum, and the price in the smallest currency unit. Slots that aren't currently bookable include a machine-readable no_availability_reason (e.g. time_passed, no_areas_available, not_yet_bookable) and a human-readable no_availability_message you can surface in your UI.

For single-date appointment availability, see listAppointmentSlots or getTableReservationSlots.

Path parameters

areaBookingTypeIdmongo-idrequired
The ID of the AreaBookingType to check availability for.

Query parameters

date_fromdaterequired
The earliest start date to return slots for, in YYYY-MM-DD format.
date_todaterequired
The latest start date to return slots for, in YYYY-MM-DD format. The range is inclusive. We recommend keeping the range to 14 days or fewer for performance reasons.
quantityintegeroptional
The number of area-booking slots required at the same start time. Used when booking multiple guests onto the same area. Defaults to 1.
area_idmongo-idoptional
Optionally restrict the results to slots that can be served by a specific area. When omitted, all eligible areas configured on the booking type are considered.

Responses

200
The list of available area-booking slots was successfully retrieved.
401
The user is unauthenticated
404
The resource couldn't be found

curl "https://api.playground.try.be/shop/area-booking-slots/abc123?date_from=2026-06-01&date_to=2026-06-14" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json"

const response = await fetch('https://api.playground.try.be/shop/area-booking-slots/abc123?date_from=2026-06-01&date_to=2026-06-14', {
  method: 'GET',
  headers: {
    Authorization: 'Bearer YOUR_API_KEY',
    Accept: 'application/json',
  },
})

if (!response.ok) {
  throw new Error(`Trybe API ${response.status}: ${await response.text()}`)
}

const data = await response.json()

import httpx

response = httpx.get(
    "https://api.playground.try.be/shop/area-booking-slots/abc123?date_from=2026-06-01&date_to=2026-06-14",
    headers={
        "Authorization": "Bearer YOUR_API_KEY",
        "Accept": "application/json",
    },
)
response.raise_for_status()
data = response.json()

<?php

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://api.playground.try.be/shop/area-booking-slots/abc123?date_from=2026-06-01&date_to=2026-06-14', [
    'headers' => [
        'Authorization' => 'Bearer YOUR_API_KEY',
        'Accept' => 'application/json',
    ],
]);

$data = json_decode($response->getBody(), true);

package main

import (
	"encoding/json"
	"net/http"
)

func main() {
	req, _ := http.NewRequest("GET", "https://api.playground.try.be/shop/area-booking-slots/abc123?date_from=2026-06-01&date_to=2026-06-14", nil)
	req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
	req.Header.Set("Accept", "application/json")
	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()
	var data map[string]interface{}
	json.NewDecoder(resp.Body).Decode(&data)
}

The list of available area-booking slots was successfully retrieved.

{
  "data": [
    {
      "start_time": "2026-06-12T10:00:00+01:00",
      "end_time": "2026-06-12T11:30:00+01:00",
      "duration": 90,
      "area_ids": [
        "64a9f3b2c3d8e1f4a5b6c7d8"
      ],
      "total_quantity": 4,
      "quantity_available": 2,
      "price": 4500,
      "currency": "gbp",
      "is_available": true,
      "no_availability_reason": "time_passed",
      "no_availability_message": "No matching areas are available at this time.",
      "bookable_from": "2026-01-15T09:30:00+00:00",
      "bookable_to": "2026-01-15T09:30:00+00:00"
    }
  ]
}

{
  "message": "Unauthenticated"
}

{
  "message": "The requested resource could not be found"
}

get/shop/offering-availability

Get monthly availability for an offering

listOfferingAvailability

Returns one entry per calendar day in the month containing date, indicating whether the supplied offering is bookable and whether any availability rule covers the day at all. Intended for powering calendar-month pickers in booking UIs without iterating every individual slot.

The check honours every available rule on the offering, then subtracts unavailable rules; if any window survives for a given day the day's is_available is true.

Requires the RESERVATIONS_VIEW permission on the offering's site.

Query parameters

datedaterequired
Any ISO 8601 calendar date inside the month to summarise. The response covers the full month containing this date, computed in the offering's timezone.
offering_typestringrequired
The offering type the offering_id belongs to.
Possible values:appointmentarea_bookingpackagesession
offering_idstringrequired
ID of the offering to summarise.

Responses

200
Per-day availability summary for every day in the targeted month.
401
The user is unauthenticated
403
The authenticated user does not have permission.
404
The resource couldn't be found
422
The request didn't pass validation

curl "https://api.playground.try.be/shop/offering-availability?date=2026-05-01&offering_type=appointment&offering_id=abc123" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json"

const response = await fetch('https://api.playground.try.be/shop/offering-availability?date=2026-05-01&offering_type=appointment&offering_id=abc123', {
  method: 'GET',
  headers: {
    Authorization: 'Bearer YOUR_API_KEY',
    Accept: 'application/json',
  },
})

if (!response.ok) {
  throw new Error(`Trybe API ${response.status}: ${await response.text()}`)
}

const data = await response.json()

import httpx

response = httpx.get(
    "https://api.playground.try.be/shop/offering-availability?date=2026-05-01&offering_type=appointment&offering_id=abc123",
    headers={
        "Authorization": "Bearer YOUR_API_KEY",
        "Accept": "application/json",
    },
)
response.raise_for_status()
data = response.json()

<?php

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://api.playground.try.be/shop/offering-availability?date=2026-05-01&offering_type=appointment&offering_id=abc123', [
    'headers' => [
        'Authorization' => 'Bearer YOUR_API_KEY',
        'Accept' => 'application/json',
    ],
]);

$data = json_decode($response->getBody(), true);

package main

import (
	"encoding/json"
	"net/http"
)

func main() {
	req, _ := http.NewRequest("GET", "https://api.playground.try.be/shop/offering-availability?date=2026-05-01&offering_type=appointment&offering_id=abc123", nil)
	req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
	req.Header.Set("Accept", "application/json")
	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()
	var data map[string]interface{}
	json.NewDecoder(resp.Body).Decode(&data)
}

Per-day availability summary for every day in the targeted month.

{
  "data": [
    {
      "date": "2026-05-23",
      "is_available": true,
      "is_offered": true
    }
  ]
}

{
  "message": "Unauthenticated"
}

{
  "message": "This action is unauthorized."
}

{
  "message": "The requested resource could not be found"
}

{
  "errors": {},
  "message": "The request didn't pass validation"
}

post/shop/offering-availability/add-day-unavailability

Mark a day as unavailable for an offering

actionAddOfferingDayUnavailability

Creates (or no-ops on, if one already exists) a one-day "unavailable" availability rule on the offering. Equivalent to going into the offering's availability calendar and toggling the targeted day off.

Idempotent: if the same (date, offering) already has an unavailable rule, the existing rule is returned without modification.

Requires the SETTINGS_MANAGE permission on the offering's site.

Request body

datedaterequired
ISO 8601 calendar date to mark unavailable, in the offering's timezone.
offering_typestringrequired
The offering type the offering_id belongs to.
Possible values:appointmentarea_bookingpackagesession
offering_idstringrequired
ID of the offering to update.

Responses

204
The day was successfully marked unavailable.
401
The user is unauthenticated
403
The authenticated user does not have permission.
404
The resource couldn't be found
422
The request didn't pass validation

curl -X POST "https://api.playground.try.be/shop/offering-availability/add-day-unavailability" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json" \
  -H "Content-Type: application/json" \
  -d '{
  "date": "2026-12-25",
  "offering_type": "appointment",
  "offering_id": "5dcb47800000000000000019"
}'

const response = await fetch('https://api.playground.try.be/shop/offering-availability/add-day-unavailability', {
  method: 'POST',
  headers: {
    Authorization: 'Bearer YOUR_API_KEY',
    'Content-Type': 'application/json',
    Accept: 'application/json',
  },
  body: JSON.stringify({
    "date": "2026-12-25",
    "offering_type": "appointment",
    "offering_id": "5dcb47800000000000000019"
  }),
})

if (!response.ok) {
  throw new Error(`Trybe API ${response.status}: ${await response.text()}`)
}

const data = await response.json()

import httpx

response = httpx.post(
    "https://api.playground.try.be/shop/offering-availability/add-day-unavailability",
    headers={
        "Authorization": "Bearer YOUR_API_KEY",
        "Accept": "application/json",
        "Content-Type": "application/json",
    },
    json={
        "date": "2026-12-25",
        "offering_type": "appointment",
        "offering_id": "5dcb47800000000000000019"
    },
)
response.raise_for_status()
data = response.json()

<?php

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api.playground.try.be/shop/offering-availability/add-day-unavailability', [
    'headers' => [
        'Authorization' => 'Bearer YOUR_API_KEY',
        'Accept' => 'application/json',
        'Content-Type' => 'application/json',
    ],
    'json' => [
            'date' => '2026-12-25',
            'offering_type' => 'appointment',
            'offering_id' => '5dcb47800000000000000019'
        ],
]);

$data = json_decode($response->getBody(), true);

package main

import (
	"bytes"
	"encoding/json"
	"net/http"
)

func main() {
	payload, _ := json.Marshal(map[string]interface{}{
		"date": "2026-12-25",
		"offering_type": "appointment",
		"offering_id": "5dcb47800000000000000019",
	})
	req, _ := http.NewRequest("POST", "https://api.playground.try.be/shop/offering-availability/add-day-unavailability", bytes.NewBuffer(payload))
	req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
	req.Header.Set("Accept", "application/json")
	req.Header.Set("Content-Type", "application/json")
	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()
	var data map[string]interface{}
	json.NewDecoder(resp.Body).Decode(&data)
}

The day was successfully marked unavailable.

// empty response

{
  "message": "Unauthenticated"
}

{
  "message": "This action is unauthorized."
}

{
  "message": "The requested resource could not be found"
}

{
  "errors": {},
  "message": "The request didn't pass validation"
}

post/shop/offering-availability/remove-day-unavailability

Clear unavailability for a day on an offering

actionRemoveOfferingDayUnavailability

Removes every unavailable availability rule that covers the targeted day on the offering. If a rule spans more than the targeted day (e.g. a multi-day block), it is split into surrounding rules that preserve the unavailability on the days that weren't targeted.

The operation is serialised via a per-offering lock to prevent concurrent edits clobbering each other; if another request is currently modifying the same offering, the call returns 429 Too Many Requests.

Requires the SETTINGS_MANAGE permission on the offering's site.

Request body

datedaterequired
ISO 8601 calendar date to mark unavailable, in the offering's timezone.
offering_typestringrequired
The offering type the offering_id belongs to.
Possible values:appointmentarea_bookingpackagesession
offering_idstringrequired
ID of the offering to update.

Responses

204
The day's unavailability rules were successfully cleared.
401
The user is unauthenticated
403
The authenticated user does not have permission.
404
The resource couldn't be found
422
The request didn't pass validation
429
Another request is currently modifying availability rules for this offering. Retry after a short backoff.

curl -X POST "https://api.playground.try.be/shop/offering-availability/remove-day-unavailability" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json" \
  -H "Content-Type: application/json" \
  -d '{
  "date": "2026-12-25",
  "offering_type": "appointment",
  "offering_id": "5dcb47800000000000000019"
}'

const response = await fetch('https://api.playground.try.be/shop/offering-availability/remove-day-unavailability', {
  method: 'POST',
  headers: {
    Authorization: 'Bearer YOUR_API_KEY',
    'Content-Type': 'application/json',
    Accept: 'application/json',
  },
  body: JSON.stringify({
    "date": "2026-12-25",
    "offering_type": "appointment",
    "offering_id": "5dcb47800000000000000019"
  }),
})

if (!response.ok) {
  throw new Error(`Trybe API ${response.status}: ${await response.text()}`)
}

const data = await response.json()

import httpx

response = httpx.post(
    "https://api.playground.try.be/shop/offering-availability/remove-day-unavailability",
    headers={
        "Authorization": "Bearer YOUR_API_KEY",
        "Accept": "application/json",
        "Content-Type": "application/json",
    },
    json={
        "date": "2026-12-25",
        "offering_type": "appointment",
        "offering_id": "5dcb47800000000000000019"
    },
)
response.raise_for_status()
data = response.json()

<?php

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api.playground.try.be/shop/offering-availability/remove-day-unavailability', [
    'headers' => [
        'Authorization' => 'Bearer YOUR_API_KEY',
        'Accept' => 'application/json',
        'Content-Type' => 'application/json',
    ],
    'json' => [
            'date' => '2026-12-25',
            'offering_type' => 'appointment',
            'offering_id' => '5dcb47800000000000000019'
        ],
]);

$data = json_decode($response->getBody(), true);

package main

import (
	"bytes"
	"encoding/json"
	"net/http"
)

func main() {
	payload, _ := json.Marshal(map[string]interface{}{
		"date": "2026-12-25",
		"offering_type": "appointment",
		"offering_id": "5dcb47800000000000000019",
	})
	req, _ := http.NewRequest("POST", "https://api.playground.try.be/shop/offering-availability/remove-day-unavailability", bytes.NewBuffer(payload))
	req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
	req.Header.Set("Accept", "application/json")
	req.Header.Set("Content-Type", "application/json")
	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()
	var data map[string]interface{}
	json.NewDecoder(resp.Body).Decode(&data)
}

The day's unavailability rules were successfully cleared.

// empty response

{
  "message": "Unauthenticated"
}

{
  "message": "This action is unauthorized."
}

{
  "message": "The requested resource could not be found"
}

{
  "errors": {},
  "message": "The request didn't pass validation"
}

{
  "message": "string"
}