Booking Flow

Availability

Retrieve availability for an offering.

get/shop/item-availability/appointment-enquiries/{appointmentTypeId}

Check ability to enquire at the given times

actionCheckAppointmentEnquiryAvailability

Use this endpoint to check availability for an appointment enquiry

Path parameters

appointmentTypeIdmongo-idoptional
The ID of the appointment type the enquiry is for.

Query parameters

date_time_fromstringrequired
The earliest time the appointment could start.
date_time_tostringrequired
The latest time the appointment could end.

Responses

200
Results of the availability check for an appointment enquiry
401
The user is unauthenticated
404
The resource couldn't be found
422
The request didn't pass validation

curl "https://api.playground.try.be/shop/item-availability/appointment-enquiries/abc123?date_time_from=value&date_time_to=value" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json"

const response = await fetch('https://api.playground.try.be/shop/item-availability/appointment-enquiries/abc123?date_time_from=value&date_time_to=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/appointment-enquiries/abc123?date_time_from=value&date_time_to=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/appointment-enquiries/abc123?date_time_from=value&date_time_to=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/appointment-enquiries/abc123?date_time_from=value&date_time_to=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)
}

Results of the availability check for an appointment enquiry

{
  "data": {
    "can_enquire": false,
    "cannot_enquire_reason": "no_slots_found",
    "cannot_enquire_message": "The appointment already has availability to book at this time.",
    "bookable_slots": [
      {
        "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"
}

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

get/shop/availability-details

Get availability details for a date

getAvailabilityDetails

Returns an exhaustive availability snapshot for a single site/date, combining opening hours, calendar availability, practitioner and room schedules, equipment, and the periods already occupied by existing bookings or blocks.

The endpoint powers Trybe's calendar day view and the booking workflow's "explain" panel — the same payload is used to render why a slot is or isn't bookable.

Scope the response to a single offering by supplying both offering_type and offering_id. When omitted, the response includes every practitioner, room and equipment item at the site and skips offering-specific calendars.

The current user must have the reservations.manage permission on the site to call this endpoint.

Query parameters

site_idstringrequired
Filter results by the site they belong to
datedate-timerequired
The date on which to inspect availability. Expressed as an ISO-8601 date-time anchored in the site's local timezone. Only the date portion is significant — the endpoint always returns availability for the full day.
offering_typestringoptional
The type of offering to scope availability to. Required when offering_id is provided. When omitted, the response includes every practitioner, room and equipment item at the site and skips offering-specific calendars.
Possible values:appointmentarea_bookingsessioncourseproductpackagevoucher
offering_idobject-idoptional
The identifier of an offering (e.g. an AppointmentType or AreaBookingType) to focus the response on. When supplied together with offering_type, the response includes the offering's calendar availability and only the practitioners, rooms and equipment associated with that offering.

Responses

200
The availability details were successfully retrieved.
400
The request failed.
401
The user is unauthenticated
403
The authenticated user does not have permission.
422
The request didn't pass validation

curl "https://api.playground.try.be/shop/availability-details?site_id=site_abc123&date=2024-06-12T00%3A00%3A00%2B01%3A00" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json"

const response = await fetch('https://api.playground.try.be/shop/availability-details?site_id=site_abc123&date=2024-06-12T00%3A00%3A00%2B01%3A00', {
  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/availability-details?site_id=site_abc123&date=2024-06-12T00%3A00%3A00%2B01%3A00",
    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/availability-details?site_id=site_abc123&date=2024-06-12T00%3A00%3A00%2B01%3A00', [
    '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/availability-details?site_id=site_abc123&date=2024-06-12T00%3A00%3A00%2B01%3A00", 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 availability details were successfully retrieved.

{
  "data": {
    "opening_hours": [
      {
        "start_time": "2026-01-15T09:30:00+00:00",
        "end_time": "2026-01-15T09:30:00+00:00"
      }
    ],
    "offering": {
      "id": "64a9f3b2c3d8e1f4a5b6c7d8",
      "offering_type": "appointment",
      "name": "Alex Morgan",
      "duration": 1,
      "end_buffer": 1,
      "min_advance_bookings_interval": 1,
      "max_advance_bookings_interval": 1,
      "start_time_interval": 1
    },
    "calendar_availability": {
      "date": "2026-01-15",
      "available": false
    },
    "scheduled_availability": [
      {
        "start_time": "2026-01-15T09:30:00+00:00",
        "end_time": "2026-01-15T09:30:00+00:00"
      }
    ],
    "scheduled_slots": [
      {
        "start_time": "2026-01-15T09:30:00+00:00",
        "end_time": "2026-01-15T09:30:00+00:00"
      }
    ],
    "rooms": [
      {
        "room": {
          "id": "64a9f3b2c3d8e1f4a5b6c7d8",
          "name": "Alex Morgan"
        },
        "availability_rules": [
          {
            "start_time": "2026-01-15T09:30:00+00:00",
            "end_time": "2026-01-15T09:30:00+00:00"
          }
        ],
        "scheduled_slots": [
          {
            "start_time": "2026-01-15T09:30:00+00:00",
            "end_time": "2026-01-15T09:30:00+00:00"
          }
        ]
      }
    ],
    "practitioners": [
      {
        "practitioner": {
          "id": "64a9f3b2c3d8e1f4a5b6c7d8",
          "name": "Alex Morgan"
        },
        "availability_rules": [
          {
            "start_time": "2026-01-15T09:30:00+00:00",
            "end_time": "2026-01-15T09:30:00+00:00"
          }
        ],
        "scheduled_slots": [
          {
            "start_time": "2026-01-15T09:30:00+00:00",
            "end_time": "2026-01-15T09:30:00+00:00"
          }
        ],
        "restrictions": [
          {}
        ]
      }
    ],
    "equipment": [
      {
        "equipment": {
          "id": "64a9f3b2c3d8e1f4a5b6c7d8",
          "name": "Alex Morgan"
        }
      }
    ],
    "occupied_periods": [
      {
        "start_time": "2026-01-15T09:30:00+00:00",
        "end_time": "2026-01-15T09:30:00+00:00",
        "practitioner_ids": [
          "64a9f3b2c3d8e1f4a5b6c7d8"
        ],
        "room_id": "64a9f3b2c3d8e1f4a5b6c7d8"
      }
    ]
  }
}

{
  "message": "string"
}

{
  "message": "Unauthenticated"
}

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

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

get/shop/item-availability/appointment-slots/{siteId}/{appointmentTypeId}

List appointment slots

listAppointmentSlotsByRange

Returns every bookable slot for the given AppointmentType at the given site between date_time_from and date_time_to. Each entry includes the slot's start/end time, eligible practitioners, current capacity, and the per-slot price.

For ranges of one day or less the server runs a live availability check; longer ranges fall back to the cached schedule.

exclude_appointments / exclude_basket_items let you ignore existing bookings or basket items during an edit flow so the item being edited doesn't block itself.

Path parameters

siteIduuidrequired
The ID of the site the offering belongs to.
appointmentTypeIdmongo-idrequired
The ID of the appointment type to check availability for.

Query parameters

date_time_fromstringrequired
Earliest date-time to consider, in ISO-8601 format in the offering's site timezone (e.g. 2026-06-01T09:00:00+01:00).
date_time_tostringrequired
Latest date-time to consider. Must be strictly after date_time_from. For per-day endpoints, the range may not exceed a single day.
durationintegeroptional
Override the offering's default duration, in minutes. Must be positive.
practitioner_idstringoptional
Limit slots to a single practitioner. The practitioner must be eligible to deliver the appointment type.
exclude_appointmentsstringoptional
Comma-separated list of existing appointment IDs to ignore when calculating resource conflicts. Use this when re-checking availability during an appointment-edit flow so the appointment being edited doesn't block itself.
exclude_basket_itemsstringoptional
Comma-separated list of basket-item IDs to ignore. Mirrors exclude_appointments / exclude_bookings but for items already in the caller's basket.
basket_idstringoptional
Basket ID to scope the check to. The server reads the basket's coupon codes (for price computation) and excludes its items when computing conflicts.
guest_idstringoptional
Guest ID to attribute the slot to. Drives per-guest booking limits.
required_quantityintegeroptional
Number of guests/instances the slot must accommodate. Defaults to 1.

Responses

200
A list of bookable AppointmentAvailabilitySlots plus a meta block with the practitioner roster and selection mode.
401
The user is unauthenticated
404
The resource couldn't be found
422
The request didn't pass validation

curl "https://api.playground.try.be/shop/item-availability/appointment-slots/00000000-0000-0000-0000-000000000000/abc123?date_time_from=value&date_time_to=value" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json"

const response = await fetch('https://api.playground.try.be/shop/item-availability/appointment-slots/00000000-0000-0000-0000-000000000000/abc123?date_time_from=value&date_time_to=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/appointment-slots/00000000-0000-0000-0000-000000000000/abc123?date_time_from=value&date_time_to=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/appointment-slots/00000000-0000-0000-0000-000000000000/abc123?date_time_from=value&date_time_to=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/appointment-slots/00000000-0000-0000-0000-000000000000/abc123?date_time_from=value&date_time_to=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)
}

A list of bookable `AppointmentAvailabilitySlot`s plus a `meta` block with the practitioner roster and selection mode.

{
  "data": [
    {
      "start_time": "2026-01-15T09:30:00+00:00",
      "end_time": "2026-01-15T09:30:00+00:00",
      "duration": 1,
      "end_buffer": 1,
      "practitioner_ids": [
        "string"
      ],
      "room_ids": [
        "string"
      ],
      "equipment_ids": [
        "string"
      ],
      "total_quantity": 1,
      "quantity_available": 1,
      "is_valid": true,
      "currency": "gbp",
      "price": 1,
      "nonoptimal_practitioner_allocation": false,
      "nonoptimal_practitioner_ids": [
        "string"
      ],
      "bookable_from": "2026-01-15T09:30:00+00:00",
      "bookable_to": "2026-01-15T09:30:00+00:00",
      "no_availability_reason": "string",
      "no_availability_message": "string"
    }
  ],
  "meta": {
    "practitioners": [
      {}
    ],
    "practitioner_selection": "string",
    "no_availability_reason": "string"
  }
}

{
  "message": "Unauthenticated"
}

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

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

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

List area-booking slots

listAreaBookingSlotsByRange

Returns every bookable slot for the given AreaBookingType between date_time_from and date_time_to. The range may not exceed one day — large windows are rejected with 400 Bad Request.

Slots are ordered earliest first; ties on start time are broken by shortest duration first. Pass quantity to size the slot up for multiple guests (mutually exclusive with guest_id).

Path parameters

areaBookingTypeIdmongo-idrequired
The ID of the area booking type to check availability for.

Query parameters

date_time_fromstringrequired
Earliest date-time to consider, in ISO-8601 format in the offering's site timezone (e.g. 2026-06-01T09:00:00+01:00).
date_time_tostringrequired
Latest date-time to consider. Must be strictly after date_time_from. For per-day endpoints, the range may not exceed a single day.
durationintegeroptional
Override the offering's default duration, in minutes. Must be positive.
exclude_bookingsstringoptional
Comma-separated list of existing area-booking IDs to ignore when calculating area conflicts.
exclude_basket_itemsstringoptional
Comma-separated list of basket-item IDs to ignore. Mirrors exclude_appointments / exclude_bookings but for items already in the caller's basket.
basket_idstringoptional
Basket ID to scope the check to. The server reads the basket's coupon codes (for price computation) and excludes its items when computing conflicts.
guest_idstringoptional
Guest ID to attribute the slot to. Drives per-guest booking limits.
quantityintegeroptional
Number of guests/instances the slot must accommodate. Defaults to 1.

Responses

200
A list of AreaBookingAvailabilitySlots for the requested day. Slots are ordered earliest first, then shortest first when start times match.
400
The request failed.
401
The user is unauthenticated
404
The resource couldn't be found
422
The request didn't pass validation

curl "https://api.playground.try.be/shop/item-availability/area-booking-slots/abc123?date_time_from=value&date_time_to=value" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json"

const response = await fetch('https://api.playground.try.be/shop/item-availability/area-booking-slots/abc123?date_time_from=value&date_time_to=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/area-booking-slots/abc123?date_time_from=value&date_time_to=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/area-booking-slots/abc123?date_time_from=value&date_time_to=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/area-booking-slots/abc123?date_time_from=value&date_time_to=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)
}

A list of `AreaBookingAvailabilitySlot`s for the requested day. Slots are ordered earliest first, then shortest first when start times match.

{
  "data": [
    {
      "start_time": "2026-01-15T09:30:00+00:00",
      "end_time": "2026-01-15T09:30:00+00:00",
      "duration": 1,
      "area_ids": [
        "string"
      ],
      "total_quantity": 1,
      "quantity_available": 1,
      "is_valid": true,
      "currency": "gbp",
      "price": 1,
      "no_availability_reason": "string",
      "no_availability_message": "string"
    }
  ]
}

{
  "message": "string"
}

{
  "message": "Unauthenticated"
}

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

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

post/shop/item-availability/multi-appointment-slots

List combined slots for multiple appointment types

actionCheckMultiAppointmentAvailability

Returns the set of start times on a given day where every requested AppointmentType can be booked back-to-back at the same site. Used by the booking UI when a customer adds multiple appointments to their basket and expects them to chain together.

The response is a list of MultiAppointmentSlotGroups — one per viable start time, each containing the individual slots in order.

Deprecated. The server logs every call to this endpoint as a deprecated request. Prefer building the chain with per-type appointment-slots calls if you are starting from scratch.

Request body

site_idstringrequired
ID of the site to search at.
datedaterequired
Day to slot the appointments into, ISO-8601 YYYY-MM-DD in the site's timezone.
itemsobject[]required
One entry per appointment type to chain. Order matters — each item slots immediately after the previous one.
practitioner_idstringoptional
Constrain every appointment to the same practitioner.
basket_idstringoptional
Basket to exclude from the conflict calculation (useful when re-checking after an edit).

Responses

200
A list of MultiAppointmentSlotGroups — one per common start time that can host every requested appointment type in sequence.
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/item-availability/multi-appointment-slots" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json" \
  -H "Content-Type: application/json" \
  -d '{
  "site_id": "5dcb47800000000000000010",
  "date": "2026-01-15",
  "items": [
    {
      "appointment_type_id": "00000000-0000-0000-0000-000000000000",
      "duration": 1,
      "quantity": 1
    }
  ],
  "practitioner_id": "5dcb47800000000000000020",
  "basket_id": "60c0c01d92ec44e252235966"
}'

const response = await fetch('https://api.playground.try.be/shop/item-availability/multi-appointment-slots', {
  method: 'POST',
  headers: {
    Authorization: 'Bearer YOUR_API_KEY',
    'Content-Type': 'application/json',
    Accept: 'application/json',
  },
  body: JSON.stringify({
    "site_id": "5dcb47800000000000000010",
    "date": "2026-01-15",
    "items": [
      {
        "appointment_type_id": "00000000-0000-0000-0000-000000000000",
        "duration": 1,
        "quantity": 1
      }
    ],
    "practitioner_id": "5dcb47800000000000000020",
    "basket_id": "60c0c01d92ec44e252235966"
  }),
})

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/item-availability/multi-appointment-slots",
    headers={
        "Authorization": "Bearer YOUR_API_KEY",
        "Accept": "application/json",
        "Content-Type": "application/json",
    },
    json={
        "site_id": "5dcb47800000000000000010",
        "date": "2026-01-15",
        "items": [
            {
                "appointment_type_id": "00000000-0000-0000-0000-000000000000",
                "duration": 1,
                "quantity": 1
            }
        ],
        "practitioner_id": "5dcb47800000000000000020",
        "basket_id": "60c0c01d92ec44e252235966"
    },
)
response.raise_for_status()
data = response.json()

<?php

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api.playground.try.be/shop/item-availability/multi-appointment-slots', [
    'headers' => [
        'Authorization' => 'Bearer YOUR_API_KEY',
        'Accept' => 'application/json',
        'Content-Type' => 'application/json',
    ],
    'json' => [
            'site_id' => '5dcb47800000000000000010',
            'date' => '2026-01-15',
            'items' => [
                [
                    'appointment_type_id' => '00000000-0000-0000-0000-000000000000',
                    'duration' => 1,
                    'quantity' => 1
                ]
            ],
            'practitioner_id' => '5dcb47800000000000000020',
            'basket_id' => '60c0c01d92ec44e252235966'
        ],
]);

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

package main

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

func main() {
	payload, _ := json.Marshal(map[string]interface{}{
		"site_id": "5dcb47800000000000000010",
		"date": "2026-01-15",
		"items": []interface{}{
			map[string]interface{}{
				"appointment_type_id": "00000000-0000-0000-0000-000000000000",
				"duration": 1,
				"quantity": 1,
			},
		},
		"practitioner_id": "5dcb47800000000000000020",
		"basket_id": "60c0c01d92ec44e252235966",
	})
	req, _ := http.NewRequest("POST", "https://api.playground.try.be/shop/item-availability/multi-appointment-slots", 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)
}

A list of `MultiAppointmentSlotGroup`s — one per common start time that can host every requested appointment type in sequence.

{
  "data": [
    {
      "start_time": "2026-01-15T09:30:00+00:00",
      "nonoptimal_practitioner_allocation": false,
      "total_cost": 1,
      "appointments": [
        {
          "appointment_type_id": "00000000-0000-0000-0000-000000000000",
          "start_time": "2026-01-15T09:30:00+00:00",
          "end_time": "2026-01-15T09:30:00+00:00",
          "duration": 1,
          "end_buffer": 1,
          "practitioner_id": "00000000-0000-0000-0000-000000000000",
          "price": 1
        }
      ]
    }
  ]
}

{
  "message": "Unauthenticated"
}

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

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

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

get/shop/item-availability/offering-dates

List availability by day for an offering

listOfferingDateAvailability

Returns one OfferingDateAvailability per day in the date_from..date_to range, indicating whether the offering has any bookable slots on that day plus the cheapest slot price. Use this to drive a calendar UI that greys-out unbookable days without firing a slot-level query per day.

The maximum supported range is 31 days. Larger ranges return 400 Bad Request.

Supports appointment, session, package, and area_booking offering types.

Query parameters

date_fromdaterequired
First date in the requested window (inclusive), ISO-8601 YYYY-MM-DD in the offering's site timezone.
date_todaterequired
Last date in the requested window (inclusive). For most offerings the range may not exceed 31 days.
offering_idstringrequired
The offering whose date-by-date availability should be returned. Must be paired with offering_type so the platform knows which catalogue to look the ID up in (appointments, sessions or packages). Returns 422 if the ID does not resolve to a live offering of the supplied type.
offering_typestringrequired
The kind of offering offering_id refers to.
Possible values:appointmentsessionpackagearea_booking
quantityintegeroptional
Number of guests/instances the slot must accommodate. Defaults to 1.
partner_idstringoptional
Restrict the check to the given partner's allotment. Pass the partner's partner_id (e.g. ota).

Responses

200
Per-day availability for an offering across the requested date range. Each entry is one calendar day.
400
The request failed.
401
The user is unauthenticated
404
The resource couldn't be found
422
The request didn't pass validation

curl "https://api.playground.try.be/shop/item-availability/offering-dates?date_from=2026-01-15&date_to=2026-01-15&offering_id=5dcb47800000000000000010&offering_type=appointment" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json"

const response = await fetch('https://api.playground.try.be/shop/item-availability/offering-dates?date_from=2026-01-15&date_to=2026-01-15&offering_id=5dcb47800000000000000010&offering_type=appointment', {
  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/offering-dates?date_from=2026-01-15&date_to=2026-01-15&offering_id=5dcb47800000000000000010&offering_type=appointment",
    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/offering-dates?date_from=2026-01-15&date_to=2026-01-15&offering_id=5dcb47800000000000000010&offering_type=appointment', [
    '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/offering-dates?date_from=2026-01-15&date_to=2026-01-15&offering_id=5dcb47800000000000000010&offering_type=appointment", 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 for an offering across the requested date range. Each entry is one calendar day.

{
  "data": [
    {
      "date": "2026-01-15",
      "has_availability": true,
      "practitioner_ids": [
        "string"
      ],
      "can_enquire": false,
      "bookable_from": "2026-01-15T09:30:00+00:00",
      "bookable_to": "2026-01-15T09:30:00+00:00",
      "price_from": 1
    }
  ],
  "meta": {}
}

{
  "message": "string"
}

{
  "message": "Unauthenticated"
}

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

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

get/shop/item-availability/package-slots/{packageId}/choices/{choiceId}

List bookable slots for a package choice

listPackageChoiceSlots

Returns every bookable slot for one of the items in a Package's choice list. Each entry includes the package_item_id so the caller can attribute the slot back to the right choice when adding to a basket.

The slot shape mirrors the per-offering availability endpoints (appointment-slots, area-booking-slots, etc.) — the underlying offering type drives which fields are populated.

Path parameters

packageIdmongo-idrequired
The ID of the package to check availability for.
choiceIdmongo-idrequired
The ID of the package item choice (the slot in the package that's being filled).

Query parameters

date_time_fromstringrequired
Earliest date-time to consider, in ISO-8601 format in the offering's site timezone (e.g. 2026-06-01T09:00:00+01:00).
date_time_tostringrequired
Latest date-time to consider. Must be strictly after date_time_from. For per-day endpoints, the range may not exceed a single day.
basket_idstringoptional
Basket ID to scope the check to. The server reads the basket's coupon codes (for price computation) and excludes its items when computing conflicts.
guest_idstringoptional
Guest ID to attribute the slot to. Drives per-guest booking limits.

Responses

200
Bookable slots for a single package choice, indexed by package_item_id.
401
The user is unauthenticated
404
The resource couldn't be found
422
The request didn't pass validation

curl "https://api.playground.try.be/shop/item-availability/package-slots/abc123/choices/abc123?date_time_from=value&date_time_to=value" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json"

const response = await fetch('https://api.playground.try.be/shop/item-availability/package-slots/abc123/choices/abc123?date_time_from=value&date_time_to=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/package-slots/abc123/choices/abc123?date_time_from=value&date_time_to=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/package-slots/abc123/choices/abc123?date_time_from=value&date_time_to=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/package-slots/abc123/choices/abc123?date_time_from=value&date_time_to=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)
}

Bookable slots for a single package choice, indexed by `package_item_id`.

{
  "data": [
    {
      "package_item_id": "00000000-0000-0000-0000-000000000000",
      "start_time": "2026-01-15T09:30:00+00:00",
      "end_time": "2026-01-15T09:30:00+00:00",
      "duration": 1,
      "practitioner_ids": [
        "string"
      ],
      "quantity_available": 1,
      "is_valid": true
    }
  ]
}

{
  "message": "Unauthenticated"
}

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

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

get/shop/item-availability/products/{productId}

Get product stock availability

getProductAvailability

Returns the current sellable stock for the given Product at its site. Stock-tracking products return their on-hand count; non-tracking products return a large sentinel quantity_available (effectively unlimited).

Use this just before adding a product to a basket to confirm the unit is still purchasable.

Path parameters

productIdmongo-idrequired
The ID of the product to check availability for.

Responses

200
Current stock availability for the requested Product.
401
The user is unauthenticated
404
The resource couldn't be found

curl "https://api.playground.try.be/shop/item-availability/products/abc123" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json"

const response = await fetch('https://api.playground.try.be/shop/item-availability/products/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/item-availability/products/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/item-availability/products/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/item-availability/products/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)
}

Current stock availability for the requested `Product`.

{
  "data": {
    "product_id": "00000000-0000-0000-0000-000000000000",
    "site_id": "00000000-0000-0000-0000-000000000000",
    "quantity_available": 1,
    "can_purchase": false,
    "no_availability_reason": "string"
  }
}

{
  "message": "Unauthenticated"
}

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

get/shop/item-availability/sessions/{siteId}/{sessionTypeId}

List session occurrences

listSessionOccurrences

Returns every scheduled SessionType occurrence between date_time_from and date_time_to, with current capacity and pricing. Use this to build the customer-facing session calendar.

Unlike appointments, session occurrences are pre-scheduled — the endpoint reads the published rota rather than computing slots from rules.

Path parameters

siteIduuidrequired
The ID of the site the offering belongs to.
sessionTypeIdmongo-idrequired
The ID of the session type to check availability for.

Query parameters

date_time_fromstringrequired
Earliest date-time to consider, in ISO-8601 format in the offering's site timezone (e.g. 2026-06-01T09:00:00+01:00).
date_time_tostringrequired
Latest date-time to consider. Must be strictly after date_time_from. For per-day endpoints, the range may not exceed a single day.

Responses

200
A list of SessionAvailabilityOccurrences for the requested window.
401
The user is unauthenticated
404
The resource couldn't be found
422
The request didn't pass validation

curl "https://api.playground.try.be/shop/item-availability/sessions/00000000-0000-0000-0000-000000000000/abc123?date_time_from=value&date_time_to=value" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json"

const response = await fetch('https://api.playground.try.be/shop/item-availability/sessions/00000000-0000-0000-0000-000000000000/abc123?date_time_from=value&date_time_to=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/sessions/00000000-0000-0000-0000-000000000000/abc123?date_time_from=value&date_time_to=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/sessions/00000000-0000-0000-0000-000000000000/abc123?date_time_from=value&date_time_to=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/sessions/00000000-0000-0000-0000-000000000000/abc123?date_time_from=value&date_time_to=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)
}

A list of `SessionAvailabilityOccurrence`s for the requested window.

{
  "data": [
    {
      "id": "00000000-0000-0000-0000-000000000000",
      "start_time": "2026-01-15T09:30:00+00:00",
      "end_time": "2026-01-15T09:30:00+00:00",
      "duration": 1,
      "capacity": 1,
      "quantity_available": 1,
      "is_bookable": true,
      "currency": "gbp",
      "price": 1,
      "no_availability_reason": "string"
    }
  ]
}

{
  "message": "Unauthenticated"
}

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

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