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.
practitioner_idsstringoptional
Comma-separated requested practitioner IDs bound to the exact quote, in place of practitioner_id when an appointment is held to several practitioners. Only slots in which all of these practitioners are available are listed.
replacement_item_idstringoptional
Existing standalone appointment item to replace. Requires basket_id; the item must belong to that basket and site. The quote binds this item identity and excludes only its booking from pricing demand. General availability exclusions do not affect pricing demand. Submit the token to this item's update endpoint.
practitioner_genderstringoptional
Requested practitioner gender bound to the exact appointment quote. Availability is independently verified on acceptance.
Possible values:malefemale
equipment_idsstringoptional
Comma-separated requested equipment IDs bound to the exact quote. Only slots in which all of this equipment is available are listed. Availability is independently verified on acceptance.
room_idstringoptional
Requested room for the exact priced selection. Only slots in which this room is available are listed.
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.
400
The request could not be completed.
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,
      "pricing": {
        "kind": "preview",
        "unit_amount": 1,
        "item_amount": 1,
        "currency": "GBP",
        "calculated_at": "2026-01-15T09:30:00+00:00",
        "acceptance_deadline": "2026-01-15T09:30:00+00:00",
        "acceptance_token": "string"
      },
      "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",
      "warnings": [
        {
          "code": "no_practitioner_assigned",
          "message": "string",
          "practitioner_id": "00000000-0000-0000-0000-000000000000"
        }
      ]
    }
  ],
  "meta": {
    "practitioners": [
      {
        "id": "64a9f3b2c3d8e1f4a5b6c7d8",
        "name": "Alex Morgan",
        "gender": "string",
        "external_id": "00000000-0000-0000-0000-000000000000"
      }
    ],
    "practitioner_selection": "by_name",
    "no_availability_reason": "string"
  }
}

{
  "message": "string",
  "reason_code": "string",
  "requote_required": true
}

{
  "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 AreaBookingSlots 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 `AreaBookingSlot`s for the requested day. Slots are ordered earliest first, then shortest first when start times match.

{
  "data": [
    {
      "start_time": "2026-06-12T10:00:00+01:00",
      "end_time": "2026-06-12T11:30:00+01:00",
      "duration": 90,
      "end_buffer": 15,
      "area_ids": [
        "64a9f3b2c3d8e1f4a5b6c7d8"
      ],
      "areas": [
        {
          "id": "64a9f3b2c3d8e1f4a5b6c7d8",
          "name": "Alex Morgan",
          "is_available": true,
          "capacity": 1,
          "remaining_capacity": 1,
          "is_suggested": true
        }
      ],
      "total_quantity": 4,
      "quantity_available": 2,
      "price": 4500,
      "currency": "gbp",
      "is_available_for_quantity": true,
      "no_availability_reason": "time_passed",
      "no_availability_message": "No matching areas are available at this time."
    }
  ]
}

{
  "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
Preferred practitioner for the chain. Types offered by this practitioner are constrained to them; other types retain their own practitioners. Accept each returned practitioner_id.
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",
      "offering_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",
        "offering_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",
                "offering_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',
                    'offering_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",
				"offering_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,
          "request_index": 0,
          "quantity": 1,
          "pricing": {
            "kind": "preview",
            "unit_amount": 1,
            "item_amount": 1,
            "currency": "GBP",
            "calculated_at": "2026-01-15T09:30:00+00:00",
            "acceptance_deadline": "2026-01-15T09:30:00+00:00",
            "acceptance_token": "string"
          }
        }
      ]
    }
  ]
}

{
  "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, for each option of a Package choice, the bookable slots on the requested day. Each option's slots mirror the per-offering availability endpoints (appointment-slots, area-booking-slots, etc.) — the option's item_type drives which fields are populated.

Pass package_item_id or basket_item_id when editing an existing item so its own booking does not block the check.

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

datedaterequired
The day to list slots for, ISO-8601 YYYY-MM-DD in the package site's timezone.
option_idstringoptional
Only return slots for the given option of the choice.
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.
basket_item_idstringoptional
ID of the basket item being edited. Its own bookings are excluded so its times still appear available, and package rules are taken into account. The basket is inferred from it.
package_item_idstringoptional
ID of the package item being edited. Takes precedence over basket_item_id and basket_id.

Responses

200
The options of a single package choice, each with its bookable slots on the requested day.
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=2026-01-15" \
  -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=2026-01-15', {
  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=2026-01-15",
    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=2026-01-15', [
    '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=2026-01-15", 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 options of a single package choice, each with its bookable slots on the requested day.

{
  "data": [
    {
      "id": "00000000-0000-0000-0000-000000000000",
      "item_type": "string",
      "item_name": "string",
      "price_change": 12.34,
      "quantity_available": 1,
      "slots": [
        {
          "start_time": "2026-01-15T09:30:00+00:00",
          "end_time": "2026-01-15T09:30:00+00:00"
        }
      ],
      "suggested_slots": [
        {
          "start_time": "2026-01-15T09:30:00+00:00",
          "end_time": "2026-01-15T09:30:00+00:00"
        }
      ],
      "practitioners": [
        {
          "id": "64a9f3b2c3d8e1f4a5b6c7d8",
          "name": "Alex Morgan",
          "gender": "string",
          "external_id": "00000000-0000-0000-0000-000000000000"
        }
      ],
      "practitioner_selection": "by_name",
      "max_guests": 1,
      "practitioners_per_guest": 1
    }
  ]
}

{
  "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 (or the whole calendar days between date_from and date_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.

Send either the date_time_from/date_time_to pair or the date-only date_from/date_to pair. Prefer the date-only pair when you want whole site-local days: the server resolves the day boundaries with the site's timezone rules, so the client never has to compute a UTC offset itself.

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_fromstringoptional
Earliest date-time to consider, in ISO-8601 format in the offering's site timezone (e.g. 2026-06-01T09:00:00+01:00). Required unless date_from is sent.
date_time_tostringoptional
Latest date-time to consider. Must be strictly after date_time_from. Required unless date_to is sent.
date_fromdateoptional
First date in the requested window (inclusive), ISO-8601 YYYY-MM-DD in the offering's site timezone. The server resolves the day's boundaries using the site's timezone rules. Required unless date_time_from is sent.
date_todateoptional
Last date in the requested window (inclusive). Must be on or after date_from. Required unless date_time_to is sent.
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_idstring[]optional
Comma-separated IDs of the guests the occurrence is for. Drives per-guest booking limits.
quantityintegeroptional
Number of guests/instances the slot must accommodate. Defaults to 1.
basket_item_idstringoptional
Selected Session Basket Item being replaced. Only its booking is excluded from demand; sibling bookings still count. The item must belong to basket_id at this Site.

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" \
  -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', {
  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",
    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', [
    '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", 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,
      "remaining_capacity": 1,
      "quantity_available": 1,
      "waitlist_enabled": false,
      "is_valid": true,
      "is_bookable": true,
      "currency": "gbp",
      "price": 1,
      "pricing": {
        "kind": "preview",
        "unit_amount": 1,
        "item_amount": 1,
        "currency": "GBP",
        "calculated_at": "2026-01-15T09:30:00+00:00",
        "acceptance_deadline": "2026-01-15T09:30:00+00:00",
        "acceptance_token": "string"
      },
      "practitioner_id": "00000000-0000-0000-0000-000000000000",
      "practitioner": {},
      "room_id": "00000000-0000-0000-0000-000000000000",
      "room": {},
      "no_availability_reason": "string",
      "no_availability_message": "string"
    }
  ]
}

{
  "message": "Unauthenticated"
}

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

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