Calendar & Scheduling

Practitioners

A Practitioner is a bookable staff member — typically a therapist, instructor, or stylist — that appointments and sessions can be assigned to. Practitioners own a working rota, optional commission rules, and the set of appointment / session types they're qualified to deliver. The booking flow filters availability by practitioner, and order line items record the practitioner who delivered the service for reporting and payroll.

The Practitioner object

Attributes

idobject-idrequired
Stable identifier for the practitioner. Used when assigning sessions, appointments and rotas to the practitioner, and when the booking storefront resolves a slot to a specific staff member.
appointment_restrictionsobject[]required
avataroptional
can_offer_tagsstring[]required
genderstringoptionalnullable
Self-identified gender of the practitioner, surfaced to guests who filter the booking storefront by practitioner gender. Free text — common values are female, male and non-binary. null when the practitioner hasn't supplied a value.
namestringrequired
Public display name of the practitioner. Shown to guests on the booking storefront and on receipts. Should be the name the practitioner wants to appear in front of guests — typically first name plus last initial or full name.
organisation_iduuidrequired
Organisation the practitioner belongs to. Practitioners are scoped to a single organisation and are not visible to API callers from other organisations.
site_idsstring[]required
tag_idsstring[]required
tagsobject[]required
zonesobject[]required
user_iduuidrequirednullable
Staff User linked to this practitioner record, if any. Linking lets the user manage their own rota and view their appointments from the staff console. null for practitioners that don't have a login account.
created_atrequired
updated_atrequired

{
  "id": "5dcb47800000000000000000",
  "appointment_restrictions": [
    {
      "id": "5dcb47800000000000000011",
      "applies_to_type": "specific",
      "appointment_type_ids": [
        "5dcb47800000000000000010"
      ],
      "appointment_types": [
        {
          "id": "00000000-0000-0000-0000-000000000000",
          "name": "Alex Morgan"
        }
      ],
      "categories": [
        {
          "id": "00000000-0000-0000-0000-000000000000",
          "name": "Alex Morgan"
        }
      ],
      "category_ids": [
        "5dcb47800000000000000010"
      ],
      "date_from": "2020-06-20",
      "date_to": "2020-06-20",
      "max_duration": 180,
      "occupied_mins": 60,
      "type": "cannot_offer"
    }
  ],
  "avatar": "string",
  "can_offer_tags": [
    "string"
  ],
  "gender": "female",
  "name": "Jane Doe",
  "organisation_id": "5f8a1b2c-9d3e-4a5b-8c6d-7e8f9a0b1c2d",
  "site_ids": [
    "00000000-0000-0000-0000-000000000000"
  ],
  "tag_ids": [
    "string"
  ],
  "tags": [
    "string"
  ],
  "zones": [
    "string"
  ],
  "user_id": "5f8a1b2c-9d3e-4a5b-8c6d-7e8f9a0b1c2d",
  "created_at": "string",
  "updated_at": "string"
}

get/shop/practitioners

Get all practitioners

listAllPractitioners

Use this endpoint to retrieve all practitioners (paginated)

Query parameters

pageintegeroptional
The page to retrieve results from
per_pageintegeroptional
The number of results to return per page
site_idstringoptional
Filter results by the site they belong to
querystringoptional
Filter practitioners by their name
zone_idsstring[]optional
Filter practitioners by a comma separated list of zone ids they are linked to

Responses

200
A list of practitioners (paginated)
401
The user is unauthenticated

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

const response = await fetch('https://api.playground.try.be/shop/practitioners', {
  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/practitioners",
    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/practitioners', [
    '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/practitioners", 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 practitioners (paginated)

{
  "links": {
    "first": "http://example.com?page=1",
    "next": "https://example.com?page=3",
    "prev": "https://example.com?page=1",
    "last": "https://example.com?page=4"
  },
  "meta": {
    "from": 1,
    "to": 2,
    "total": 2,
    "current_page": 1,
    "last_page": 2,
    "per_page": 15,
    "path": "http://example.com/api"
  },
  "data": [
    {
      "id": "5dcb47800000000000000000",
      "appointment_restrictions": [
        {
          "id": "5dcb47800000000000000011",
          "applies_to_type": "specific",
          "appointment_type_ids": [
            "5dcb47800000000000000010"
          ],
          "appointment_types": [
            {
              "id": "00000000-0000-0000-0000-000000000000"
            }
          ],
          "categories": [
            {
              "id": "00000000-0000-0000-0000-000000000000"
            }
          ],
          "category_ids": [
            "5dcb47800000000000000010"
          ],
          "date_from": "2020-06-20",
          "date_to": "2020-06-20",
          "max_duration": 180,
          "occupied_mins": 60,
          "type": "cannot_offer"
        }
      ],
      "avatar": {
        "id": "00000000-0000-0000-0000-000000000000",
        "file_name": "super-cool-photo.jpg",
        "mime_type": "image/jpeg",
        "original_url": "https://example.com/media/super-cool-photo.jpg",
        "size": 84256,
        "url": "https://example.com/media/super-cool-photo-thumbnail@2x.jpg"
      },
      "can_offer_tags": [
        "string"
      ],
      "gender": "female",
      "name": "Jane Doe",
      "organisation_id": "5f8a1b2c-9d3e-4a5b-8c6d-7e8f9a0b1c2d",
      "site_ids": [
        "00000000-0000-0000-0000-000000000000"
      ],
      "tag_ids": [
        "string"
      ],
      "tags": [
        {
          "id": "00000000-0000-0000-0000-000000000000",
          "name": "Alex Morgan",
          "organisation_id": "00000000-0000-0000-0000-000000000000"
        }
      ],
      "zones": [
        {
          "id": "5f1234567890abcdef123456",
          "name": "Pool Deck",
          "organisation_id": "22222222-2222-2222-2222-222222222222",
          "site_id": "11111111-1111-1111-1111-111111111111"
        }
      ],
      "user_id": "5f8a1b2c-9d3e-4a5b-8c6d-7e8f9a0b1c2d",
      "created_at": "2025-02-04T12:00:00+01:00",
      "updated_at": "2025-02-04T12:00:00+01:00"
    }
  ]
}

{
  "message": "Unauthenticated"
}

post/shop/practitioners

Create a practitioner

createPractitioner

Creates a new Practitioner attached to one or more sites. The minimum body is name + site_ids; everything else has a sensible default or null-equivalent. Returns the freshly created practitioner.

The first entry in site_ids becomes the practitioner's "default" site — zones, commission packages, and the user-uniqueness check are evaluated against this site. The practitioner's timezone is inherited from the default site at creation time.

Requires the SETTINGS_MANAGE permission on every site listed in site_ids.

Query parameters

site_idstringrequired
Filter results by the site they belong to

Request body

namestringrequired
Display name of the practitioner shown to customers in the booking flow and to staff in the admin UI.
site_idsstring[]required
One or more site IDs the practitioner works at. Must contain at least one site; the first entry becomes the practitioner's "default" site for zone- and commission-package lookups. The caller's user must be a member of every site listed.
organisation_iduuidoptional
Optional organisation to attribute this practitioner to. The caller's user must belong to the organisation. Defaults to the caller's primary organisation when omitted.
tag_idsstring[]optional
IDs of practitioner tags this person is associated with. Tags must already exist in the caller's primary organisation AND be marked applies_to: Practitioner — others are rejected with 422.
avatar_idobject-idoptionalnullable
ID of an uploaded Media to use as the practitioner's avatar. Shown next to the practitioner's name in the booking widget and admin UI.
zone_idsstring[]optional
IDs of zones the practitioner is associated with. Zones must belong to the first site in site_ids — zones from other sites are rejected with 422.
genderstringoptionalnullable
Optional gender used by the booking flow to honour customer preferences (e.g. "I'd prefer a female therapist").
Possible values:malefemalenon_binary
commission_package_idobject-idoptionalnullable
Optional CommissionPackage to attach to the practitioner. Drives payroll/commission reporting. Must belong to the first site in site_ids.
user_iduuidoptionalnullable
Optional underlying User to link to this practitioner. The user must share an organisation with the caller. A given user can be linked to at most one practitioner per site — attempting to reuse a user on the same site is rejected with 422.

Responses

201
The practitioner was created.
401
The user is unauthenticated
403
The authenticated user does not have permission.
422
The request didn't pass validation

curl -X POST "https://api.playground.try.be/shop/practitioners?site_id=site_abc123" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json" \
  -H "Content-Type: application/json" \
  -d '{
  "name": "Jane Doe",
  "site_ids": [
    "6f1234567890abcdef123456"
  ],
  "organisation_id": "00000000-0000-0000-0000-000000000000",
  "tag_ids": [
    "64a9f3b2c3d8e1f4a5b6c7d8"
  ],
  "avatar_id": "5f1234567890abcdef123456",
  "zone_ids": [
    "64a9f3b2c3d8e1f4a5b6c7d8"
  ],
  "gender": "male",
  "commission_package_id": "64a9f3b2c3d8e1f4a5b6c7d8",
  "user_id": "00000000-0000-0000-0000-000000000000"
}'

const response = await fetch('https://api.playground.try.be/shop/practitioners?site_id=site_abc123', {
  method: 'POST',
  headers: {
    Authorization: 'Bearer YOUR_API_KEY',
    'Content-Type': 'application/json',
    Accept: 'application/json',
  },
  body: JSON.stringify({
    "name": "Jane Doe",
    "site_ids": [
      "6f1234567890abcdef123456"
    ],
    "organisation_id": "00000000-0000-0000-0000-000000000000",
    "tag_ids": [
      "64a9f3b2c3d8e1f4a5b6c7d8"
    ],
    "avatar_id": "5f1234567890abcdef123456",
    "zone_ids": [
      "64a9f3b2c3d8e1f4a5b6c7d8"
    ],
    "gender": "male",
    "commission_package_id": "64a9f3b2c3d8e1f4a5b6c7d8",
    "user_id": "00000000-0000-0000-0000-000000000000"
  }),
})

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/practitioners?site_id=site_abc123",
    headers={
        "Authorization": "Bearer YOUR_API_KEY",
        "Accept": "application/json",
        "Content-Type": "application/json",
    },
    json={
        "name": "Jane Doe",
        "site_ids": [
            "6f1234567890abcdef123456"
        ],
        "organisation_id": "00000000-0000-0000-0000-000000000000",
        "tag_ids": [
            "64a9f3b2c3d8e1f4a5b6c7d8"
        ],
        "avatar_id": "5f1234567890abcdef123456",
        "zone_ids": [
            "64a9f3b2c3d8e1f4a5b6c7d8"
        ],
        "gender": "male",
        "commission_package_id": "64a9f3b2c3d8e1f4a5b6c7d8",
        "user_id": "00000000-0000-0000-0000-000000000000"
    },
)
response.raise_for_status()
data = response.json()

<?php

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api.playground.try.be/shop/practitioners?site_id=site_abc123', [
    'headers' => [
        'Authorization' => 'Bearer YOUR_API_KEY',
        'Accept' => 'application/json',
        'Content-Type' => 'application/json',
    ],
    'json' => [
            'name' => 'Jane Doe',
            'site_ids' => [
                '6f1234567890abcdef123456'
            ],
            'organisation_id' => '00000000-0000-0000-0000-000000000000',
            'tag_ids' => [
                '64a9f3b2c3d8e1f4a5b6c7d8'
            ],
            'avatar_id' => '5f1234567890abcdef123456',
            'zone_ids' => [
                '64a9f3b2c3d8e1f4a5b6c7d8'
            ],
            'gender' => 'male',
            'commission_package_id' => '64a9f3b2c3d8e1f4a5b6c7d8',
            'user_id' => '00000000-0000-0000-0000-000000000000'
        ],
]);

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

package main

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

func main() {
	payload, _ := json.Marshal(map[string]interface{}{
		"name": "Jane Doe",
		"site_ids": []interface{}{
			"6f1234567890abcdef123456",
		},
		"organisation_id": "00000000-0000-0000-0000-000000000000",
		"tag_ids": []interface{}{
			"64a9f3b2c3d8e1f4a5b6c7d8",
		},
		"avatar_id": "5f1234567890abcdef123456",
		"zone_ids": []interface{}{
			"64a9f3b2c3d8e1f4a5b6c7d8",
		},
		"gender": "male",
		"commission_package_id": "64a9f3b2c3d8e1f4a5b6c7d8",
		"user_id": "00000000-0000-0000-0000-000000000000",
	})
	req, _ := http.NewRequest("POST", "https://api.playground.try.be/shop/practitioners?site_id=site_abc123", 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 practitioner was created.

{
  "data": {
    "id": "5dcb47800000000000000000",
    "appointment_restrictions": [
      {
        "id": "5dcb47800000000000000011",
        "applies_to_type": "specific",
        "appointment_type_ids": [
          "5dcb47800000000000000010"
        ],
        "appointment_types": [
          {
            "id": "00000000-0000-0000-0000-000000000000",
            "name": "Alex Morgan"
          }
        ],
        "categories": [
          {
            "id": "00000000-0000-0000-0000-000000000000",
            "name": "Alex Morgan"
          }
        ],
        "category_ids": [
          "5dcb47800000000000000010"
        ],
        "date_from": "2020-06-20",
        "date_to": "2020-06-20",
        "max_duration": 180,
        "occupied_mins": 60,
        "type": "cannot_offer"
      }
    ],
    "avatar": {
      "id": "00000000-0000-0000-0000-000000000000",
      "file_name": "super-cool-photo.jpg",
      "mime_type": "image/jpeg",
      "original_url": "https://example.com/media/super-cool-photo.jpg",
      "size": 84256,
      "url": "https://example.com/media/super-cool-photo-thumbnail@2x.jpg"
    },
    "can_offer_tags": [
      "string"
    ],
    "gender": "female",
    "name": "Jane Doe",
    "organisation_id": "5f8a1b2c-9d3e-4a5b-8c6d-7e8f9a0b1c2d",
    "site_ids": [
      "00000000-0000-0000-0000-000000000000"
    ],
    "tag_ids": [
      "string"
    ],
    "tags": [
      {
        "id": "00000000-0000-0000-0000-000000000000",
        "name": "Alex Morgan",
        "organisation_id": "00000000-0000-0000-0000-000000000000"
      }
    ],
    "zones": [
      {
        "id": "5f1234567890abcdef123456",
        "name": "Pool Deck",
        "organisation_id": "22222222-2222-2222-2222-222222222222",
        "site_id": "11111111-1111-1111-1111-111111111111"
      }
    ],
    "user_id": "5f8a1b2c-9d3e-4a5b-8c6d-7e8f9a0b1c2d",
    "created_at": "2025-02-04T12:00:00+01:00",
    "updated_at": "2025-02-04T12:00:00+01:00"
  }
}

{
  "message": "Unauthenticated"
}

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

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

get/shop/practitioners/{practitionerId}

Retrieve a Practitioner

getPractitioner

Use this endpoint to retrieve a single Practitioner model.

Path parameters

practitionerIdstringrequired
Identifier of the practitioner. Practitioners are the staff members or therapists who deliver appointments; this ID is used to manage their rotas, availability, and assignment to bookings.

Responses

200
Successfully retrieved the Practitioner
401
The user is unauthenticated
403
The authenticated user does not have permission.
404
The resource couldn't be found

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

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

Successfully retrieved the Practitioner

{
  "data": {
    "id": "5dcb47800000000000000000",
    "appointment_restrictions": [
      {
        "id": "5dcb47800000000000000011",
        "applies_to_type": "specific",
        "appointment_type_ids": [
          "5dcb47800000000000000010"
        ],
        "appointment_types": [
          {
            "id": "00000000-0000-0000-0000-000000000000",
            "name": "Alex Morgan"
          }
        ],
        "categories": [
          {
            "id": "00000000-0000-0000-0000-000000000000",
            "name": "Alex Morgan"
          }
        ],
        "category_ids": [
          "5dcb47800000000000000010"
        ],
        "date_from": "2020-06-20",
        "date_to": "2020-06-20",
        "max_duration": 180,
        "occupied_mins": 60,
        "type": "cannot_offer"
      }
    ],
    "avatar": {
      "id": "00000000-0000-0000-0000-000000000000",
      "file_name": "super-cool-photo.jpg",
      "mime_type": "image/jpeg",
      "original_url": "https://example.com/media/super-cool-photo.jpg",
      "size": 84256,
      "url": "https://example.com/media/super-cool-photo-thumbnail@2x.jpg"
    },
    "can_offer_tags": [
      "string"
    ],
    "gender": "female",
    "name": "Jane Doe",
    "organisation_id": "5f8a1b2c-9d3e-4a5b-8c6d-7e8f9a0b1c2d",
    "site_ids": [
      "00000000-0000-0000-0000-000000000000"
    ],
    "tag_ids": [
      "string"
    ],
    "tags": [
      {
        "id": "00000000-0000-0000-0000-000000000000",
        "name": "Alex Morgan",
        "organisation_id": "00000000-0000-0000-0000-000000000000"
      }
    ],
    "zones": [
      {
        "id": "5f1234567890abcdef123456",
        "name": "Pool Deck",
        "organisation_id": "22222222-2222-2222-2222-222222222222",
        "site_id": "11111111-1111-1111-1111-111111111111"
      }
    ],
    "user_id": "5f8a1b2c-9d3e-4a5b-8c6d-7e8f9a0b1c2d",
    "created_at": "2025-02-04T12:00:00+01:00",
    "updated_at": "2025-02-04T12:00:00+01:00"
  }
}

{
  "message": "Unauthenticated"
}

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

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

put/shop/practitioners/{practitionerId}

Update a practitioner

updatePractitioner

Partially updates a Practitioner. Every field is optional; only fields you send are written. Fields you omit retain their current values. Requires the SETTINGS_MANAGE permission on the practitioner's first site.

email (if sent) must be unique across all practitioners in the caller's organisations — duplicate emails are rejected with 422. user_id (if sent non-null) must share an organisation with the practitioner and not already be linked to another practitioner on the same site.

Path parameters

practitionerIdstringrequired
Identifier of the practitioner. Practitioners are the staff members or therapists who deliver appointments; this ID is used to manage their rotas, availability, and assignment to bookings.

Request body

namestringoptional
Display name of the practitioner.
emailemailoptional
Optional contact email for the practitioner. Must be unique across all practitioners in the caller's organisations.
can_offer_tagsstring[]optional
Free-form list of tag names the practitioner is qualified to deliver. Used by older integrations; new callers should prefer the tag_ids association on practitioners/{id}/appointment-restrictions instead.
tag_idsstring[]optional
IDs of practitioner tags this person belongs to. Tags must already exist in the caller's primary organisation AND be marked applies_to: Practitioner.
zone_idsstring[]optional
IDs of zones the practitioner is associated with. Zones must belong to the practitioner's first site.
scheduling_week_interval_startdateoptional
ISO 8601 date marking the first week of the practitioner's recurring schedule. Combined with scheduling_week_interval to compute multi-week rotas.
scheduling_week_intervalintegeroptional
Length of the recurring schedule in weeks (1-10). 1 means a weekly schedule; 4 means a 4-weekly rota repeating from scheduling_week_interval_start.
avatar_idobject-idoptionalnullable
ID of an uploaded Media to use as the practitioner's avatar.
orderintegeroptional
Sort order for the practitioner within the site. Lower numbers sort first. Use PUT /shop/practitioners/order to reorder a batch of practitioners in one request.
genderstringoptionalnullable
Optional gender; see Create.
Possible values:malefemalenon_binary
commission_package_idobject-idoptionalnullable
Optional CommissionPackage to attach.
user_iduuidoptionalnullable
Optional underlying User to link to. The user must share an organisation with the practitioner. A given user can be linked to at most one practitioner per site.

Responses

200
The practitioner was updated.
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 PUT "https://api.playground.try.be/shop/practitioners/abc123" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json" \
  -H "Content-Type: application/json" \
  -d '{
  "name": "Jane Doe",
  "email": "jane.doe@example.com",
  "can_offer_tags": [
    "string"
  ],
  "tag_ids": [
    "64a9f3b2c3d8e1f4a5b6c7d8"
  ],
  "zone_ids": [
    "64a9f3b2c3d8e1f4a5b6c7d8"
  ],
  "scheduling_week_interval_start": "2026-01-05",
  "scheduling_week_interval": 1,
  "avatar_id": "64a9f3b2c3d8e1f4a5b6c7d8",
  "order": 3,
  "gender": "male",
  "commission_package_id": "64a9f3b2c3d8e1f4a5b6c7d8",
  "user_id": "00000000-0000-0000-0000-000000000000"
}'

const response = await fetch('https://api.playground.try.be/shop/practitioners/abc123', {
  method: 'PUT',
  headers: {
    Authorization: 'Bearer YOUR_API_KEY',
    'Content-Type': 'application/json',
    Accept: 'application/json',
  },
  body: JSON.stringify({
    "name": "Jane Doe",
    "email": "jane.doe@example.com",
    "can_offer_tags": [
      "string"
    ],
    "tag_ids": [
      "64a9f3b2c3d8e1f4a5b6c7d8"
    ],
    "zone_ids": [
      "64a9f3b2c3d8e1f4a5b6c7d8"
    ],
    "scheduling_week_interval_start": "2026-01-05",
    "scheduling_week_interval": 1,
    "avatar_id": "64a9f3b2c3d8e1f4a5b6c7d8",
    "order": 3,
    "gender": "male",
    "commission_package_id": "64a9f3b2c3d8e1f4a5b6c7d8",
    "user_id": "00000000-0000-0000-0000-000000000000"
  }),
})

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

const data = await response.json()

import httpx

response = httpx.put(
    "https://api.playground.try.be/shop/practitioners/abc123",
    headers={
        "Authorization": "Bearer YOUR_API_KEY",
        "Accept": "application/json",
        "Content-Type": "application/json",
    },
    json={
        "name": "Jane Doe",
        "email": "jane.doe@example.com",
        "can_offer_tags": [
            "string"
        ],
        "tag_ids": [
            "64a9f3b2c3d8e1f4a5b6c7d8"
        ],
        "zone_ids": [
            "64a9f3b2c3d8e1f4a5b6c7d8"
        ],
        "scheduling_week_interval_start": "2026-01-05",
        "scheduling_week_interval": 1,
        "avatar_id": "64a9f3b2c3d8e1f4a5b6c7d8",
        "order": 3,
        "gender": "male",
        "commission_package_id": "64a9f3b2c3d8e1f4a5b6c7d8",
        "user_id": "00000000-0000-0000-0000-000000000000"
    },
)
response.raise_for_status()
data = response.json()

<?php

$client = new \GuzzleHttp\Client();

$response = $client->request('PUT', 'https://api.playground.try.be/shop/practitioners/abc123', [
    'headers' => [
        'Authorization' => 'Bearer YOUR_API_KEY',
        'Accept' => 'application/json',
        'Content-Type' => 'application/json',
    ],
    'json' => [
            'name' => 'Jane Doe',
            'email' => 'jane.doe@example.com',
            'can_offer_tags' => [
                'string'
            ],
            'tag_ids' => [
                '64a9f3b2c3d8e1f4a5b6c7d8'
            ],
            'zone_ids' => [
                '64a9f3b2c3d8e1f4a5b6c7d8'
            ],
            'scheduling_week_interval_start' => '2026-01-05',
            'scheduling_week_interval' => 1,
            'avatar_id' => '64a9f3b2c3d8e1f4a5b6c7d8',
            'order' => 3,
            'gender' => 'male',
            'commission_package_id' => '64a9f3b2c3d8e1f4a5b6c7d8',
            'user_id' => '00000000-0000-0000-0000-000000000000'
        ],
]);

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

package main

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

func main() {
	payload, _ := json.Marshal(map[string]interface{}{
		"name": "Jane Doe",
		"email": "jane.doe@example.com",
		"can_offer_tags": []interface{}{
			"string",
		},
		"tag_ids": []interface{}{
			"64a9f3b2c3d8e1f4a5b6c7d8",
		},
		"zone_ids": []interface{}{
			"64a9f3b2c3d8e1f4a5b6c7d8",
		},
		"scheduling_week_interval_start": "2026-01-05",
		"scheduling_week_interval": 1,
		"avatar_id": "64a9f3b2c3d8e1f4a5b6c7d8",
		"order": 3,
		"gender": "male",
		"commission_package_id": "64a9f3b2c3d8e1f4a5b6c7d8",
		"user_id": "00000000-0000-0000-0000-000000000000",
	})
	req, _ := http.NewRequest("PUT", "https://api.playground.try.be/shop/practitioners/abc123", 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 practitioner was updated.

{
  "data": {
    "id": "5dcb47800000000000000000",
    "appointment_restrictions": [
      {
        "id": "5dcb47800000000000000011",
        "applies_to_type": "specific",
        "appointment_type_ids": [
          "5dcb47800000000000000010"
        ],
        "appointment_types": [
          {
            "id": "00000000-0000-0000-0000-000000000000",
            "name": "Alex Morgan"
          }
        ],
        "categories": [
          {
            "id": "00000000-0000-0000-0000-000000000000",
            "name": "Alex Morgan"
          }
        ],
        "category_ids": [
          "5dcb47800000000000000010"
        ],
        "date_from": "2020-06-20",
        "date_to": "2020-06-20",
        "max_duration": 180,
        "occupied_mins": 60,
        "type": "cannot_offer"
      }
    ],
    "avatar": {
      "id": "00000000-0000-0000-0000-000000000000",
      "file_name": "super-cool-photo.jpg",
      "mime_type": "image/jpeg",
      "original_url": "https://example.com/media/super-cool-photo.jpg",
      "size": 84256,
      "url": "https://example.com/media/super-cool-photo-thumbnail@2x.jpg"
    },
    "can_offer_tags": [
      "string"
    ],
    "gender": "female",
    "name": "Jane Doe",
    "organisation_id": "5f8a1b2c-9d3e-4a5b-8c6d-7e8f9a0b1c2d",
    "site_ids": [
      "00000000-0000-0000-0000-000000000000"
    ],
    "tag_ids": [
      "string"
    ],
    "tags": [
      {
        "id": "00000000-0000-0000-0000-000000000000",
        "name": "Alex Morgan",
        "organisation_id": "00000000-0000-0000-0000-000000000000"
      }
    ],
    "zones": [
      {
        "id": "5f1234567890abcdef123456",
        "name": "Pool Deck",
        "organisation_id": "22222222-2222-2222-2222-222222222222",
        "site_id": "11111111-1111-1111-1111-111111111111"
      }
    ],
    "user_id": "5f8a1b2c-9d3e-4a5b-8c6d-7e8f9a0b1c2d",
    "created_at": "2025-02-04T12:00:00+01:00",
    "updated_at": "2025-02-04T12:00:00+01:00"
  }
}

{
  "message": "Unauthenticated"
}

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

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

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

delete/shop/practitioners/{practitionerId}

Delete a practitioner

deletePractitioner

Soft-deletes a Practitioner. Existing past appointments and sessions are unaffected; the practitioner is removed from new booking flows.

422 Unprocessable Entity if the practitioner has future appointments or sessions still on the books — reassign or cancel those bookings first. The response lists appointments and/or sessions validation errors so callers know what to clear up.

Requires the SETTINGS_MANAGE permission on the practitioner's first site.

Path parameters

practitionerIdstringrequired
Identifier of the practitioner. Practitioners are the staff members or therapists who deliver appointments; this ID is used to manage their rotas, availability, and assignment to bookings.

Responses

204
Practitioner deleted successfully.
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 DELETE "https://api.playground.try.be/shop/practitioners/abc123" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json"

const response = await fetch('https://api.playground.try.be/shop/practitioners/abc123', {
  method: 'DELETE',
  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.delete(
    "https://api.playground.try.be/shop/practitioners/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('DELETE', 'https://api.playground.try.be/shop/practitioners/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("DELETE", "https://api.playground.try.be/shop/practitioners/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)
}

Practitioner deleted successfully.

// 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/practitioners/{practitionerId}/copy

Duplicate a practitioner

copyPractitioner

Creates a copy of an existing Practitioner. The copy inherits the source's full configuration (avatar, tags, zones, scheduling rules) except the underlying user_id association — the new practitioner starts without a linked user. Useful when staffing up similar roles or seeding a new site from a model practitioner.

Requires the SETTINGS_MANAGE permission on the source's site.

Path parameters

practitionerIdstringrequired
Identifier of the practitioner. Practitioners are the staff members or therapists who deliver appointments; this ID is used to manage their rotas, availability, and assignment to bookings.

Request body

namestringrequired
Display name for the new practitioner copy. Shown to customers in the booking flow and to staff in the admin UI.
can_offer_tagsstring[]optional
Tag names the practitioner can deliver appointments for. The exact set of tags is controlled by practitioner-tags; this field references them by name for back-compat with older callers.
tag_idsstring[]optional
IDs of practitioner tags the new copy belongs to. Tags must exist in the caller's organisation AND be marked as applies_to: Practitioner — others are rejected with 422.
zone_idsstring[]optional
IDs of zones the new practitioner is associated with. Zones must belong to the source practitioner's site.
scheduling_week_interval_startdateoptional
ISO 8601 date marking the first week of the practitioner's recurring schedule. Used together with scheduling_week_interval to compute multi-week rotas.
scheduling_week_intervalintegeroptional
Length of the recurring schedule in weeks (1-10). 1 means a weekly schedule; 4 means a 4-weekly rota repeating cyclically from scheduling_week_interval_start.
avatar_idstringoptionalnullable
ID of an uploaded Media to use as the practitioner's avatar.

Responses

201
The practitioner was copied.
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/practitioners/abc123/copy" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json" \
  -H "Content-Type: application/json" \
  -d '{
  "name": "Sam Practitioner (Junior)",
  "can_offer_tags": [
    "string"
  ],
  "tag_ids": [
    "64a9f3b2c3d8e1f4a5b6c7d8"
  ],
  "zone_ids": [
    "64a9f3b2c3d8e1f4a5b6c7d8"
  ],
  "scheduling_week_interval_start": "2026-01-05",
  "scheduling_week_interval": 1,
  "avatar_id": "5f1234567890abcdef123456"
}'

const response = await fetch('https://api.playground.try.be/shop/practitioners/abc123/copy', {
  method: 'POST',
  headers: {
    Authorization: 'Bearer YOUR_API_KEY',
    'Content-Type': 'application/json',
    Accept: 'application/json',
  },
  body: JSON.stringify({
    "name": "Sam Practitioner (Junior)",
    "can_offer_tags": [
      "string"
    ],
    "tag_ids": [
      "64a9f3b2c3d8e1f4a5b6c7d8"
    ],
    "zone_ids": [
      "64a9f3b2c3d8e1f4a5b6c7d8"
    ],
    "scheduling_week_interval_start": "2026-01-05",
    "scheduling_week_interval": 1,
    "avatar_id": "5f1234567890abcdef123456"
  }),
})

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/practitioners/abc123/copy",
    headers={
        "Authorization": "Bearer YOUR_API_KEY",
        "Accept": "application/json",
        "Content-Type": "application/json",
    },
    json={
        "name": "Sam Practitioner (Junior)",
        "can_offer_tags": [
            "string"
        ],
        "tag_ids": [
            "64a9f3b2c3d8e1f4a5b6c7d8"
        ],
        "zone_ids": [
            "64a9f3b2c3d8e1f4a5b6c7d8"
        ],
        "scheduling_week_interval_start": "2026-01-05",
        "scheduling_week_interval": 1,
        "avatar_id": "5f1234567890abcdef123456"
    },
)
response.raise_for_status()
data = response.json()

<?php

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api.playground.try.be/shop/practitioners/abc123/copy', [
    'headers' => [
        'Authorization' => 'Bearer YOUR_API_KEY',
        'Accept' => 'application/json',
        'Content-Type' => 'application/json',
    ],
    'json' => [
            'name' => 'Sam Practitioner (Junior)',
            'can_offer_tags' => [
                'string'
            ],
            'tag_ids' => [
                '64a9f3b2c3d8e1f4a5b6c7d8'
            ],
            'zone_ids' => [
                '64a9f3b2c3d8e1f4a5b6c7d8'
            ],
            'scheduling_week_interval_start' => '2026-01-05',
            'scheduling_week_interval' => 1,
            'avatar_id' => '5f1234567890abcdef123456'
        ],
]);

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

package main

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

func main() {
	payload, _ := json.Marshal(map[string]interface{}{
		"name": "Sam Practitioner (Junior)",
		"can_offer_tags": []interface{}{
			"string",
		},
		"tag_ids": []interface{}{
			"64a9f3b2c3d8e1f4a5b6c7d8",
		},
		"zone_ids": []interface{}{
			"64a9f3b2c3d8e1f4a5b6c7d8",
		},
		"scheduling_week_interval_start": "2026-01-05",
		"scheduling_week_interval": 1,
		"avatar_id": "5f1234567890abcdef123456",
	})
	req, _ := http.NewRequest("POST", "https://api.playground.try.be/shop/practitioners/abc123/copy", 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 practitioner was copied.

{
  "data": {
    "id": "5dcb47800000000000000000",
    "appointment_restrictions": [
      {
        "id": "5dcb47800000000000000011",
        "applies_to_type": "specific",
        "appointment_type_ids": [
          "5dcb47800000000000000010"
        ],
        "appointment_types": [
          {
            "id": "00000000-0000-0000-0000-000000000000",
            "name": "Alex Morgan"
          }
        ],
        "categories": [
          {
            "id": "00000000-0000-0000-0000-000000000000",
            "name": "Alex Morgan"
          }
        ],
        "category_ids": [
          "5dcb47800000000000000010"
        ],
        "date_from": "2020-06-20",
        "date_to": "2020-06-20",
        "max_duration": 180,
        "occupied_mins": 60,
        "type": "cannot_offer"
      }
    ],
    "avatar": {
      "id": "00000000-0000-0000-0000-000000000000",
      "file_name": "super-cool-photo.jpg",
      "mime_type": "image/jpeg",
      "original_url": "https://example.com/media/super-cool-photo.jpg",
      "size": 84256,
      "url": "https://example.com/media/super-cool-photo-thumbnail@2x.jpg"
    },
    "can_offer_tags": [
      "string"
    ],
    "gender": "female",
    "name": "Jane Doe",
    "organisation_id": "5f8a1b2c-9d3e-4a5b-8c6d-7e8f9a0b1c2d",
    "site_ids": [
      "00000000-0000-0000-0000-000000000000"
    ],
    "tag_ids": [
      "string"
    ],
    "tags": [
      {
        "id": "00000000-0000-0000-0000-000000000000",
        "name": "Alex Morgan",
        "organisation_id": "00000000-0000-0000-0000-000000000000"
      }
    ],
    "zones": [
      {
        "id": "5f1234567890abcdef123456",
        "name": "Pool Deck",
        "organisation_id": "22222222-2222-2222-2222-222222222222",
        "site_id": "11111111-1111-1111-1111-111111111111"
      }
    ],
    "user_id": "5f8a1b2c-9d3e-4a5b-8c6d-7e8f9a0b1c2d",
    "created_at": "2025-02-04T12:00:00+01:00",
    "updated_at": "2025-02-04T12:00:00+01:00"
  }
}

{
  "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/practitioners/{practitionerId}/appointment-restrictions

List appointment restrictions for a practitioner

listPractitionerAppointmentRestrictions

Returns the PractitionerAppointmentRestrictions configured on a practitioner. Restrictions either block the practitioner from certain appointment types or cap how long those appointments can be, optionally limited to a date range.

The list is paginated. Requires the RESERVATIONS_VIEW permission on the practitioner's site.

Path parameters

practitionerIdstringrequired
Identifier of the practitioner. Practitioners are the staff members or therapists who deliver appointments; this ID is used to manage their rotas, availability, and assignment to bookings.

Query parameters

pageintegeroptional
The page to retrieve results from
per_pageintegeroptional
The number of results to return per page

Responses

200
A paginated list of PractitionerAppointmentRestriction objects belonging to the practitioner.
401
The user is unauthenticated
403
The authenticated user does not have permission.
404
The resource couldn't be found

curl "https://api.playground.try.be/shop/practitioners/abc123/appointment-restrictions" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json"

const response = await fetch('https://api.playground.try.be/shop/practitioners/abc123/appointment-restrictions', {
  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/practitioners/abc123/appointment-restrictions",
    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/practitioners/abc123/appointment-restrictions', [
    '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/practitioners/abc123/appointment-restrictions", 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 paginated list of `PractitionerAppointmentRestriction` objects belonging to the practitioner.

{
  "data": [
    {
      "id": "64a9f3b2c3d8e1f4a5b6c7d8",
      "type": "cannot_offer",
      "applies_to_type": "specific",
      "appointment_type_ids": [
        "64a9f3b2c3d8e1f4a5b6c7d8"
      ],
      "appointment_types": [
        {
          "id": "64a9f3b2c3d8e1f4a5b6c7d8",
          "name": "Deep Tissue Massage"
        }
      ],
      "category_ids": [
        "64a9f3b2c3d8e1f4a5b6c7d8"
      ],
      "categories": [
        {
          "id": "64a9f3b2c3d8e1f4a5b6c7d8",
          "name": "Massages"
        }
      ],
      "date_from": "2026-06-01",
      "date_to": "2026-08-31",
      "max_duration": 60,
      "occupied_mins": 30
    }
  ],
  "meta": {
    "from": 1,
    "to": 2,
    "total": 2,
    "current_page": 1,
    "last_page": 2,
    "per_page": 15,
    "path": "http://example.com/api"
  },
  "links": {
    "first": "http://example.com?page=1",
    "next": "https://example.com?page=3",
    "prev": "https://example.com?page=1",
    "last": "https://example.com?page=4"
  }
}

{
  "message": "Unauthenticated"
}

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

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

post/shop/practitioners/{practitionerId}/appointment-restrictions

Create an appointment restriction for a practitioner

createPractitionerAppointmentRestriction

Adds a new PractitionerAppointmentRestriction to the practitioner. Use type: cannot_offer to stop the practitioner taking matching appointments outright, or type: max_duration with max_duration (minutes) to cap how long matching appointments can run.

Requires the SETTINGS_MANAGE permission on the practitioner's site.

Path parameters

practitionerIdstringrequired
Identifier of the practitioner. Practitioners are the staff members or therapists who deliver appointments; this ID is used to manage their rotas, availability, and assignment to bookings.

Request body

typestringrequired
The kind of restriction. cannot_offer blocks matching appointments outright; max_duration caps how long they can be.
Possible values:cannot_offermax_duration
applies_to_typestringrequired
How the restriction picks which appointment types it applies to. specific uses the supplied appointment_type_ids; categories uses category_ids.
Possible values:specificcategories
appointment_type_idsstring[]optional
IDs of the appointment types this restriction applies to. Required when applies_to_type is specific; prohibited when it is categories.
category_idsstring[]optional
IDs of the categories this restriction applies to. Required when applies_to_type is categories; prohibited when it is specific.
date_fromdateoptionalnullable
First date the restriction takes effect (inclusive), parsed in the practitioner's timezone. Omit or send null to apply with no start bound.
date_todateoptionalnullable
Last date the restriction takes effect (inclusive), parsed in the practitioner's timezone. Omit or send null for an open-ended restriction.
max_durationintegeroptional
Maximum appointment duration in minutes. Required when type is max_duration; ignored otherwise.

Responses

201
A single PractitionerAppointmentRestriction.
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/practitioners/abc123/appointment-restrictions" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json" \
  -H "Content-Type: application/json" \
  -d '{
  "type": "cannot_offer",
  "applies_to_type": "specific",
  "appointment_type_ids": [
    "5e932c0901d210625e3a8766"
  ],
  "category_ids": [
    "64a9f3b2c3d8e1f4a5b6c7d8"
  ],
  "date_from": "2026-06-01",
  "date_to": "2026-08-31",
  "max_duration": 60
}'

const response = await fetch('https://api.playground.try.be/shop/practitioners/abc123/appointment-restrictions', {
  method: 'POST',
  headers: {
    Authorization: 'Bearer YOUR_API_KEY',
    'Content-Type': 'application/json',
    Accept: 'application/json',
  },
  body: JSON.stringify({
    "type": "cannot_offer",
    "applies_to_type": "specific",
    "appointment_type_ids": [
      "5e932c0901d210625e3a8766"
    ],
    "category_ids": [
      "64a9f3b2c3d8e1f4a5b6c7d8"
    ],
    "date_from": "2026-06-01",
    "date_to": "2026-08-31",
    "max_duration": 60
  }),
})

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/practitioners/abc123/appointment-restrictions",
    headers={
        "Authorization": "Bearer YOUR_API_KEY",
        "Accept": "application/json",
        "Content-Type": "application/json",
    },
    json={
        "type": "cannot_offer",
        "applies_to_type": "specific",
        "appointment_type_ids": [
            "5e932c0901d210625e3a8766"
        ],
        "category_ids": [
            "64a9f3b2c3d8e1f4a5b6c7d8"
        ],
        "date_from": "2026-06-01",
        "date_to": "2026-08-31",
        "max_duration": 60
    },
)
response.raise_for_status()
data = response.json()

<?php

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api.playground.try.be/shop/practitioners/abc123/appointment-restrictions', [
    'headers' => [
        'Authorization' => 'Bearer YOUR_API_KEY',
        'Accept' => 'application/json',
        'Content-Type' => 'application/json',
    ],
    'json' => [
            'type' => 'cannot_offer',
            'applies_to_type' => 'specific',
            'appointment_type_ids' => [
                '5e932c0901d210625e3a8766'
            ],
            'category_ids' => [
                '64a9f3b2c3d8e1f4a5b6c7d8'
            ],
            'date_from' => '2026-06-01',
            'date_to' => '2026-08-31',
            'max_duration' => 60
        ],
]);

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

package main

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

func main() {
	payload, _ := json.Marshal(map[string]interface{}{
		"type": "cannot_offer",
		"applies_to_type": "specific",
		"appointment_type_ids": []interface{}{
			"5e932c0901d210625e3a8766",
		},
		"category_ids": []interface{}{
			"64a9f3b2c3d8e1f4a5b6c7d8",
		},
		"date_from": "2026-06-01",
		"date_to": "2026-08-31",
		"max_duration": 60,
	})
	req, _ := http.NewRequest("POST", "https://api.playground.try.be/shop/practitioners/abc123/appointment-restrictions", 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 single `PractitionerAppointmentRestriction`.

{
  "data": {
    "id": "64a9f3b2c3d8e1f4a5b6c7d8",
    "type": "cannot_offer",
    "applies_to_type": "specific",
    "appointment_type_ids": [
      "64a9f3b2c3d8e1f4a5b6c7d8"
    ],
    "appointment_types": [
      {
        "id": "64a9f3b2c3d8e1f4a5b6c7d8",
        "name": "Deep Tissue Massage"
      }
    ],
    "category_ids": [
      "64a9f3b2c3d8e1f4a5b6c7d8"
    ],
    "categories": [
      {
        "id": "64a9f3b2c3d8e1f4a5b6c7d8",
        "name": "Massages"
      }
    ],
    "date_from": "2026-06-01",
    "date_to": "2026-08-31",
    "max_duration": 60,
    "occupied_mins": 30
  }
}

{
  "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/practitioners/{practitionerId}/appointment-restrictions/{appointmentRestrictionId}

Retrieve a practitioner appointment restriction

getPractitionerAppointmentRestriction

Returns a single PractitionerAppointmentRestriction belonging to the given practitioner. Requires the RESERVATIONS_VIEW permission on the practitioner's site.

Path parameters

practitionerIdstringrequired
Identifier of the practitioner. Practitioners are the staff members or therapists who deliver appointments; this ID is used to manage their rotas, availability, and assignment to bookings.
appointmentRestrictionIdobject-idrequired
The unique identifier of the appointment restriction.

Responses

200
A single PractitionerAppointmentRestriction.
401
The user is unauthenticated
403
The authenticated user does not have permission.
404
The resource couldn't be found

curl "https://api.playground.try.be/shop/practitioners/abc123/appointment-restrictions/abc123" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json"

const response = await fetch('https://api.playground.try.be/shop/practitioners/abc123/appointment-restrictions/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/practitioners/abc123/appointment-restrictions/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/practitioners/abc123/appointment-restrictions/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/practitioners/abc123/appointment-restrictions/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 single `PractitionerAppointmentRestriction`.

{
  "data": {
    "id": "64a9f3b2c3d8e1f4a5b6c7d8",
    "type": "cannot_offer",
    "applies_to_type": "specific",
    "appointment_type_ids": [
      "64a9f3b2c3d8e1f4a5b6c7d8"
    ],
    "appointment_types": [
      {
        "id": "64a9f3b2c3d8e1f4a5b6c7d8",
        "name": "Deep Tissue Massage"
      }
    ],
    "category_ids": [
      "64a9f3b2c3d8e1f4a5b6c7d8"
    ],
    "categories": [
      {
        "id": "64a9f3b2c3d8e1f4a5b6c7d8",
        "name": "Massages"
      }
    ],
    "date_from": "2026-06-01",
    "date_to": "2026-08-31",
    "max_duration": 60,
    "occupied_mins": 30
  }
}

{
  "message": "Unauthenticated"
}

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

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

put/shop/practitioners/{practitionerId}/appointment-restrictions/{appointmentRestrictionId}

Update a practitioner appointment restriction

updatePractitionerAppointmentRestriction

Replaces an existing PractitionerAppointmentRestriction. The server validates the same shape as on create, so type and applies_to_type are required and the conditional fields (appointment_type_ids, category_ids, max_duration) must be sent based on those values.

Requires the SETTINGS_MANAGE permission on the practitioner's site.

Path parameters

practitionerIdstringrequired
Identifier of the practitioner. Practitioners are the staff members or therapists who deliver appointments; this ID is used to manage their rotas, availability, and assignment to bookings.
appointmentRestrictionIdobject-idrequired
The unique identifier of the appointment restriction.

Request body

typestringrequired
The kind of restriction. See create for semantics.
Possible values:cannot_offermax_duration
applies_to_typestringrequired
How the restriction picks which appointment types it applies to.
Possible values:specificcategories
appointment_type_idsstring[]optional
Required when applies_to_type is specific; prohibited when it is categories.
category_idsstring[]optional
Required when applies_to_type is categories; prohibited when it is specific.
date_fromdateoptionalnullable
First date the restriction takes effect (inclusive). null clears the start date.
date_todateoptionalnullable
Last date the restriction takes effect (inclusive). null clears the end date.
max_durationintegeroptional
Required when type is max_duration.

Responses

200
A single PractitionerAppointmentRestriction.
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 PUT "https://api.playground.try.be/shop/practitioners/abc123/appointment-restrictions/abc123" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json" \
  -H "Content-Type: application/json" \
  -d '{
  "type": "max_duration",
  "applies_to_type": "categories",
  "appointment_type_ids": [
    "64a9f3b2c3d8e1f4a5b6c7d8"
  ],
  "category_ids": [
    "5e932c0901d210625e3a8766"
  ],
  "date_from": "2026-06-01",
  "date_to": "2026-08-31",
  "max_duration": 90
}'

const response = await fetch('https://api.playground.try.be/shop/practitioners/abc123/appointment-restrictions/abc123', {
  method: 'PUT',
  headers: {
    Authorization: 'Bearer YOUR_API_KEY',
    'Content-Type': 'application/json',
    Accept: 'application/json',
  },
  body: JSON.stringify({
    "type": "max_duration",
    "applies_to_type": "categories",
    "appointment_type_ids": [
      "64a9f3b2c3d8e1f4a5b6c7d8"
    ],
    "category_ids": [
      "5e932c0901d210625e3a8766"
    ],
    "date_from": "2026-06-01",
    "date_to": "2026-08-31",
    "max_duration": 90
  }),
})

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

const data = await response.json()

import httpx

response = httpx.put(
    "https://api.playground.try.be/shop/practitioners/abc123/appointment-restrictions/abc123",
    headers={
        "Authorization": "Bearer YOUR_API_KEY",
        "Accept": "application/json",
        "Content-Type": "application/json",
    },
    json={
        "type": "max_duration",
        "applies_to_type": "categories",
        "appointment_type_ids": [
            "64a9f3b2c3d8e1f4a5b6c7d8"
        ],
        "category_ids": [
            "5e932c0901d210625e3a8766"
        ],
        "date_from": "2026-06-01",
        "date_to": "2026-08-31",
        "max_duration": 90
    },
)
response.raise_for_status()
data = response.json()

<?php

$client = new \GuzzleHttp\Client();

$response = $client->request('PUT', 'https://api.playground.try.be/shop/practitioners/abc123/appointment-restrictions/abc123', [
    'headers' => [
        'Authorization' => 'Bearer YOUR_API_KEY',
        'Accept' => 'application/json',
        'Content-Type' => 'application/json',
    ],
    'json' => [
            'type' => 'max_duration',
            'applies_to_type' => 'categories',
            'appointment_type_ids' => [
                '64a9f3b2c3d8e1f4a5b6c7d8'
            ],
            'category_ids' => [
                '5e932c0901d210625e3a8766'
            ],
            'date_from' => '2026-06-01',
            'date_to' => '2026-08-31',
            'max_duration' => 90
        ],
]);

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

package main

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

func main() {
	payload, _ := json.Marshal(map[string]interface{}{
		"type": "max_duration",
		"applies_to_type": "categories",
		"appointment_type_ids": []interface{}{
			"64a9f3b2c3d8e1f4a5b6c7d8",
		},
		"category_ids": []interface{}{
			"5e932c0901d210625e3a8766",
		},
		"date_from": "2026-06-01",
		"date_to": "2026-08-31",
		"max_duration": 90,
	})
	req, _ := http.NewRequest("PUT", "https://api.playground.try.be/shop/practitioners/abc123/appointment-restrictions/abc123", 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 single `PractitionerAppointmentRestriction`.

{
  "data": {
    "id": "64a9f3b2c3d8e1f4a5b6c7d8",
    "type": "cannot_offer",
    "applies_to_type": "specific",
    "appointment_type_ids": [
      "64a9f3b2c3d8e1f4a5b6c7d8"
    ],
    "appointment_types": [
      {
        "id": "64a9f3b2c3d8e1f4a5b6c7d8",
        "name": "Deep Tissue Massage"
      }
    ],
    "category_ids": [
      "64a9f3b2c3d8e1f4a5b6c7d8"
    ],
    "categories": [
      {
        "id": "64a9f3b2c3d8e1f4a5b6c7d8",
        "name": "Massages"
      }
    ],
    "date_from": "2026-06-01",
    "date_to": "2026-08-31",
    "max_duration": 60,
    "occupied_mins": 30
  }
}

{
  "message": "Unauthenticated"
}

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

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

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

delete/shop/practitioners/{practitionerId}/appointment-restrictions/{appointmentRestrictionId}

Delete a practitioner appointment restriction

deletePractitionerAppointmentRestriction

Removes a PractitionerAppointmentRestriction from a practitioner. Future availability checks no longer apply the rule; existing bookings are unaffected.

Requires the SETTINGS_MANAGE permission on the practitioner's site.

Path parameters

practitionerIdstringrequired
Identifier of the practitioner. Practitioners are the staff members or therapists who deliver appointments; this ID is used to manage their rotas, availability, and assignment to bookings.
appointmentRestrictionIdobject-idrequired
The unique identifier of the appointment restriction.

Responses

204
Appointment restriction deleted successfully.
401
The user is unauthenticated
403
The authenticated user does not have permission.
404
The resource couldn't be found

curl -X DELETE "https://api.playground.try.be/shop/practitioners/abc123/appointment-restrictions/abc123" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json"

const response = await fetch('https://api.playground.try.be/shop/practitioners/abc123/appointment-restrictions/abc123', {
  method: 'DELETE',
  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.delete(
    "https://api.playground.try.be/shop/practitioners/abc123/appointment-restrictions/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('DELETE', 'https://api.playground.try.be/shop/practitioners/abc123/appointment-restrictions/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("DELETE", "https://api.playground.try.be/shop/practitioners/abc123/appointment-restrictions/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)
}

Appointment restriction deleted successfully.

// empty response

{
  "message": "Unauthenticated"
}

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

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

get/shop/practitioners/{practitionerId}/custom-availability

List custom availability rules for a practitioner

listPractitionerCustomAvailability

Returns the PractitionerCustomAvailability rules for the practitioner. Each rule is an ad-hoc override to the regular rota — either opening an extra window (is_available: true) or blocking one off (is_available: false).

Use the date, date_time_from, date_time_to, and is_available query parameters to narrow the result set. Results are paginated.

Path parameters

practitionerIdstringrequired
Identifier of the practitioner. Practitioners are the staff members or therapists who deliver appointments; this ID is used to manage their rotas, availability, and assignment to bookings.

Query parameters

datedateoptional
Return only rules that overlap this calendar day (in the practitioner's timezone).
date_time_fromdate-timeoptional
Return only rules ending after this ISO 8601 timestamp.
date_time_todate-timeoptional
Return only rules starting before this ISO 8601 timestamp.
is_availablebooleanoptional
Filter by whether the rule opens (true) or blocks (false) bookings.
pageintegeroptional
The page to retrieve results from
per_pageintegeroptional
The number of results to return per page

Responses

200
A paginated list of PractitionerCustomAvailability rules for the practitioner.
401
The user is unauthenticated
403
The authenticated user does not have permission.
404
The resource couldn't be found

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

const response = await fetch('https://api.playground.try.be/shop/practitioners/abc123/custom-availability', {
  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/practitioners/abc123/custom-availability",
    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/practitioners/abc123/custom-availability', [
    '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/practitioners/abc123/custom-availability", 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 paginated list of `PractitionerCustomAvailability` rules for the practitioner.

{
  "data": [
    {
      "id": "64a9f3b2c3d8e1f4a5b6c7d8",
      "has_availability_id": "64a9f3b2c3d8e1f4a5b6c7d8",
      "date_time_from": "2026-06-01T09:00:00+01:00",
      "date_time_to": "2026-06-01T17:00:00+01:00",
      "is_available": true
    }
  ],
  "meta": {
    "from": 1,
    "to": 2,
    "total": 2,
    "current_page": 1,
    "last_page": 2,
    "per_page": 15,
    "path": "http://example.com/api"
  },
  "links": {
    "first": "http://example.com?page=1",
    "next": "https://example.com?page=3",
    "prev": "https://example.com?page=1",
    "last": "https://example.com?page=4"
  }
}

{
  "message": "Unauthenticated"
}

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

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

post/shop/practitioners/{practitionerId}/custom-availability

Create a custom availability rule for a practitioner

createPractitionerCustomAvailability

Creates a new PractitionerCustomAvailability rule. Use this to open an extra working window (is_available: true) or to block one off (is_available: false, e.g. leave or sickness).

The server validates that no confirmed appointments or sessions fall inside is_available: false windows, and automatically merges adjacent or overlapping rules with the same is_available value. The response is the resulting rule, which may have been merged with neighbours.

Path parameters

practitionerIdstringrequired
Identifier of the practitioner. Practitioners are the staff members or therapists who deliver appointments; this ID is used to manage their rotas, availability, and assignment to bookings.

Request body

date_time_fromdate-timerequired
Start of the window, as an ISO 8601 date-time. Times without an explicit offset are interpreted in the practitioner's timezone.
date_time_todate-timerequired
End of the window, as an ISO 8601 date-time. Must be after date_time_from.
is_availablebooleanrequired
true opens an extra working window; false blocks bookings (e.g. leave). false rules will fail validation if existing confirmed appointments or sessions overlap the window.

Responses

201
A single PractitionerCustomAvailability rule.
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/practitioners/abc123/custom-availability" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json" \
  -H "Content-Type: application/json" \
  -d '{
  "date_time_from": "2026-06-01T09:00:00+01:00",
  "date_time_to": "2026-06-01T17:00:00+01:00",
  "is_available": false
}'

const response = await fetch('https://api.playground.try.be/shop/practitioners/abc123/custom-availability', {
  method: 'POST',
  headers: {
    Authorization: 'Bearer YOUR_API_KEY',
    'Content-Type': 'application/json',
    Accept: 'application/json',
  },
  body: JSON.stringify({
    "date_time_from": "2026-06-01T09:00:00+01:00",
    "date_time_to": "2026-06-01T17:00:00+01:00",
    "is_available": false
  }),
})

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/practitioners/abc123/custom-availability",
    headers={
        "Authorization": "Bearer YOUR_API_KEY",
        "Accept": "application/json",
        "Content-Type": "application/json",
    },
    json={
        "date_time_from": "2026-06-01T09:00:00+01:00",
        "date_time_to": "2026-06-01T17:00:00+01:00",
        "is_available": False
    },
)
response.raise_for_status()
data = response.json()

<?php

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api.playground.try.be/shop/practitioners/abc123/custom-availability', [
    'headers' => [
        'Authorization' => 'Bearer YOUR_API_KEY',
        'Accept' => 'application/json',
        'Content-Type' => 'application/json',
    ],
    'json' => [
            'date_time_from' => '2026-06-01T09:00:00+01:00',
            'date_time_to' => '2026-06-01T17:00:00+01:00',
            'is_available' => false
        ],
]);

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

package main

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

func main() {
	payload, _ := json.Marshal(map[string]interface{}{
		"date_time_from": "2026-06-01T09:00:00+01:00",
		"date_time_to": "2026-06-01T17:00:00+01:00",
		"is_available": false,
	})
	req, _ := http.NewRequest("POST", "https://api.playground.try.be/shop/practitioners/abc123/custom-availability", 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 single `PractitionerCustomAvailability` rule.

{
  "data": {
    "id": "64a9f3b2c3d8e1f4a5b6c7d8",
    "has_availability_id": "64a9f3b2c3d8e1f4a5b6c7d8",
    "date_time_from": "2026-06-01T09:00:00+01:00",
    "date_time_to": "2026-06-01T17:00:00+01:00",
    "is_available": true
  }
}

{
  "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/practitioners/{practitionerId}/custom-availability/{customAvailabilityId}

Retrieve a practitioner custom availability rule

getPractitionerCustomAvailability

Returns a single PractitionerCustomAvailability rule belonging to the practitioner.

Path parameters

practitionerIdstringrequired
Identifier of the practitioner. Practitioners are the staff members or therapists who deliver appointments; this ID is used to manage their rotas, availability, and assignment to bookings.
customAvailabilityIdobject-idrequired
The unique identifier of the custom availability rule.

Responses

200
A single PractitionerCustomAvailability rule.
401
The user is unauthenticated
403
The authenticated user does not have permission.
404
The resource couldn't be found

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

const response = await fetch('https://api.playground.try.be/shop/practitioners/abc123/custom-availability/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/practitioners/abc123/custom-availability/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/practitioners/abc123/custom-availability/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/practitioners/abc123/custom-availability/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 single `PractitionerCustomAvailability` rule.

{
  "data": {
    "id": "64a9f3b2c3d8e1f4a5b6c7d8",
    "has_availability_id": "64a9f3b2c3d8e1f4a5b6c7d8",
    "date_time_from": "2026-06-01T09:00:00+01:00",
    "date_time_to": "2026-06-01T17:00:00+01:00",
    "is_available": true
  }
}

{
  "message": "Unauthenticated"
}

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

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

put/shop/practitioners/{practitionerId}/custom-availability/{customAvailabilityId}

Update a practitioner custom availability rule

updatePractitionerCustomAvailability

Updates a PractitionerCustomAvailability rule. Every body field is optional; sent fields replace the existing values. date_time_to must remain strictly after date_time_from once the update is applied.

As on create, an update that overlaps or sits adjacent to another rule with the same is_available value triggers a merge. The response is the resulting rule.

Path parameters

practitionerIdstringrequired
Identifier of the practitioner. Practitioners are the staff members or therapists who deliver appointments; this ID is used to manage their rotas, availability, and assignment to bookings.
customAvailabilityIdobject-idrequired
The unique identifier of the custom availability rule.

Request body

date_time_fromdate-timeoptional
New start of the window. ISO 8601; defaults to the practitioner's timezone if no offset is given.
date_time_todate-timeoptional
New end of the window. Must be after date_time_from.
is_availablebooleanoptional
Whether the practitioner is bookable during the window.

Responses

200
A single PractitionerCustomAvailability rule.
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 PUT "https://api.playground.try.be/shop/practitioners/abc123/custom-availability/abc123" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json" \
  -H "Content-Type: application/json" \
  -d '{
  "date_time_from": "2026-06-01T10:00:00+01:00",
  "date_time_to": "2026-06-01T18:00:00+01:00",
  "is_available": true
}'

const response = await fetch('https://api.playground.try.be/shop/practitioners/abc123/custom-availability/abc123', {
  method: 'PUT',
  headers: {
    Authorization: 'Bearer YOUR_API_KEY',
    'Content-Type': 'application/json',
    Accept: 'application/json',
  },
  body: JSON.stringify({
    "date_time_from": "2026-06-01T10:00:00+01:00",
    "date_time_to": "2026-06-01T18:00:00+01:00",
    "is_available": true
  }),
})

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

const data = await response.json()

import httpx

response = httpx.put(
    "https://api.playground.try.be/shop/practitioners/abc123/custom-availability/abc123",
    headers={
        "Authorization": "Bearer YOUR_API_KEY",
        "Accept": "application/json",
        "Content-Type": "application/json",
    },
    json={
        "date_time_from": "2026-06-01T10:00:00+01:00",
        "date_time_to": "2026-06-01T18:00:00+01:00",
        "is_available": True
    },
)
response.raise_for_status()
data = response.json()

<?php

$client = new \GuzzleHttp\Client();

$response = $client->request('PUT', 'https://api.playground.try.be/shop/practitioners/abc123/custom-availability/abc123', [
    'headers' => [
        'Authorization' => 'Bearer YOUR_API_KEY',
        'Accept' => 'application/json',
        'Content-Type' => 'application/json',
    ],
    'json' => [
            'date_time_from' => '2026-06-01T10:00:00+01:00',
            'date_time_to' => '2026-06-01T18:00:00+01:00',
            'is_available' => true
        ],
]);

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

package main

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

func main() {
	payload, _ := json.Marshal(map[string]interface{}{
		"date_time_from": "2026-06-01T10:00:00+01:00",
		"date_time_to": "2026-06-01T18:00:00+01:00",
		"is_available": true,
	})
	req, _ := http.NewRequest("PUT", "https://api.playground.try.be/shop/practitioners/abc123/custom-availability/abc123", 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 single `PractitionerCustomAvailability` rule.

{
  "data": {
    "id": "64a9f3b2c3d8e1f4a5b6c7d8",
    "has_availability_id": "64a9f3b2c3d8e1f4a5b6c7d8",
    "date_time_from": "2026-06-01T09:00:00+01:00",
    "date_time_to": "2026-06-01T17:00:00+01:00",
    "is_available": true
  }
}

{
  "message": "Unauthenticated"
}

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

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

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

delete/shop/practitioners/{practitionerId}/custom-availability/{customAvailabilityId}

Delete a practitioner custom availability rule

deletePractitionerCustomAvailability

Removes a PractitionerCustomAvailability rule. The practitioner's availability immediately reverts to the regular rota for the period the rule covered. Existing bookings are not affected.

Path parameters

practitionerIdstringrequired
Identifier of the practitioner. Practitioners are the staff members or therapists who deliver appointments; this ID is used to manage their rotas, availability, and assignment to bookings.
customAvailabilityIdobject-idrequired
The unique identifier of the custom availability rule.

Responses

204
Custom availability rule deleted successfully.
401
The user is unauthenticated
403
The authenticated user does not have permission.
404
The resource couldn't be found

curl -X DELETE "https://api.playground.try.be/shop/practitioners/abc123/custom-availability/abc123" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json"

const response = await fetch('https://api.playground.try.be/shop/practitioners/abc123/custom-availability/abc123', {
  method: 'DELETE',
  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.delete(
    "https://api.playground.try.be/shop/practitioners/abc123/custom-availability/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('DELETE', 'https://api.playground.try.be/shop/practitioners/abc123/custom-availability/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("DELETE", "https://api.playground.try.be/shop/practitioners/abc123/custom-availability/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)
}

Custom availability rule deleted successfully.

// empty response

{
  "message": "Unauthenticated"
}

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

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

get/shop/practitioners/{practitionerId}/rota-for-date

Get the resolved rota for a single date

getPractitionerRotaForDate

Returns the working schedule for a single date for the given practitioner. The response blends the recurring rota with any custom availability rules that cover the date so the caller can render a day-view UI without doing the reconciliation locally.

for_date.rules_for_date is the recommended field to render — it points at whichever rule-set (custom_rules or rota_availability_rules) is authoritative for the day.

Requires the ROTAS_VIEW permission on the practitioner's first site.

Path parameters

practitionerIdstringrequired
Identifier of the practitioner. Practitioners are the staff members or therapists who deliver appointments; this ID is used to manage their rotas, availability, and assignment to bookings.

Query parameters

datedaterequired
The ISO 8601 date (YYYY-MM-DD) the caller wants rules for. The date is interpreted in the practitioner's timezone, NOT the caller's. There is no range support — pass one date per request.

Responses

200
The resolved schedule for the date.
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/practitioners/abc123/rota-for-date?date=2026-06-01" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json"

const response = await fetch('https://api.playground.try.be/shop/practitioners/abc123/rota-for-date?date=2026-06-01', {
  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/practitioners/abc123/rota-for-date?date=2026-06-01",
    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/practitioners/abc123/rota-for-date?date=2026-06-01', [
    '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/practitioners/abc123/rota-for-date?date=2026-06-01", 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 resolved schedule for the date.

{
  "data": {
    "id": "64a9f3b2c3d8e1f4a5b6c7d8",
    "practitioner_id": "64a9f3b2c3d8e1f4a5b6c7d8",
    "start_date": "2026-01-15T09:30:00+00:00",
    "end_date": "2026-01-15T09:30:00+00:00",
    "scheduling_week_interval": 2,
    "availability_rules": [
      {
        "week_num": 1,
        "weekday": "monday",
        "time_from": "09:00",
        "time_to": "17:00"
      }
    ]
  },
  "for_date": {
    "date": "2026-06-01",
    "week_number": 1,
    "rules_for_date": "custom_rules",
    "rota_availability_rules": [
      {
        "time_from": "09:00",
        "time_to": "17:00"
      }
    ],
    "custom_rules": [
      {
        "id": "64a9f3b2c3d8e1f4a5b6c7d8",
        "has_availability_id": "64a9f3b2c3d8e1f4a5b6c7d8",
        "date_time_from": "2026-06-01T09:00:00+01:00",
        "date_time_to": "2026-06-01T17:00:00+01:00",
        "is_available": 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/practitioners/{practitionerId}/rota-for-date

Override the rota for a single date

updatePractitionerRotaForDate

Sets the working schedule for a single date for the given practitioner via custom availability rules. The endpoint is idempotent for the requested date: existing custom rules covering the date are cleared (or trimmed if they extend beyond the date) before the new rules are applied.

Submitting an empty availability_rules array — or omitting the key — blocks the practitioner for the entire day. Submitting rules that match the regular rota leaves the rota in charge with no custom rules created.

Returns the same shape as the GET endpoint so callers can re-render without a follow-up fetch.

Requires the ROTAS_MANAGE permission on the practitioner's first site.

Path parameters

practitionerIdstringrequired
Identifier of the practitioner. Practitioners are the staff members or therapists who deliver appointments; this ID is used to manage their rotas, availability, and assignment to bookings.

Request body

datedaterequired
The ISO 8601 date (YYYY-MM-DD) to override, interpreted in the practitioner's timezone.
availability_rulesobject[]optional
The working windows to apply for the date. Each rule defines a start and end time. Submitting an empty array (or omitting the key) blocks the practitioner for the entire date.

Responses

200
The schedule was updated. The response is the same shape as GET /shop/practitioners/{practitionerId}/rota-for-date.
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/practitioners/abc123/rota-for-date" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json" \
  -H "Content-Type: application/json" \
  -d '{
  "date": "2026-06-01",
  "availability_rules": [
    {
      "time_from": "09:00",
      "time_to": "17:00",
      "is_available": true
    }
  ]
}'

const response = await fetch('https://api.playground.try.be/shop/practitioners/abc123/rota-for-date', {
  method: 'POST',
  headers: {
    Authorization: 'Bearer YOUR_API_KEY',
    'Content-Type': 'application/json',
    Accept: 'application/json',
  },
  body: JSON.stringify({
    "date": "2026-06-01",
    "availability_rules": [
      {
        "time_from": "09:00",
        "time_to": "17:00",
        "is_available": true
      }
    ]
  }),
})

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/practitioners/abc123/rota-for-date",
    headers={
        "Authorization": "Bearer YOUR_API_KEY",
        "Accept": "application/json",
        "Content-Type": "application/json",
    },
    json={
        "date": "2026-06-01",
        "availability_rules": [
            {
                "time_from": "09:00",
                "time_to": "17:00",
                "is_available": True
            }
        ]
    },
)
response.raise_for_status()
data = response.json()

<?php

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api.playground.try.be/shop/practitioners/abc123/rota-for-date', [
    'headers' => [
        'Authorization' => 'Bearer YOUR_API_KEY',
        'Accept' => 'application/json',
        'Content-Type' => 'application/json',
    ],
    'json' => [
            'date' => '2026-06-01',
            'availability_rules' => [
                [
                    'time_from' => '09:00',
                    'time_to' => '17:00',
                    'is_available' => true
                ]
            ]
        ],
]);

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

package main

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

func main() {
	payload, _ := json.Marshal(map[string]interface{}{
		"date": "2026-06-01",
		"availability_rules": []interface{}{
			map[string]interface{}{
				"time_from": "09:00",
				"time_to": "17:00",
				"is_available": true,
			},
		},
	})
	req, _ := http.NewRequest("POST", "https://api.playground.try.be/shop/practitioners/abc123/rota-for-date", 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 schedule was updated. The response is the same shape as `GET /shop/practitioners/{practitionerId}/rota-for-date`.

{
  "data": {
    "id": "64a9f3b2c3d8e1f4a5b6c7d8",
    "practitioner_id": "64a9f3b2c3d8e1f4a5b6c7d8",
    "start_date": "2026-01-15T09:30:00+00:00",
    "end_date": "2026-01-15T09:30:00+00:00",
    "scheduling_week_interval": 2,
    "availability_rules": [
      {
        "week_num": 1,
        "weekday": "monday",
        "time_from": "09:00",
        "time_to": "17:00"
      }
    ]
  },
  "for_date": {
    "date": "2026-06-01",
    "week_number": 1,
    "rules_for_date": "custom_rules",
    "rota_availability_rules": [
      {
        "time_from": "09:00",
        "time_to": "17:00"
      }
    ],
    "custom_rules": [
      {
        "id": "64a9f3b2c3d8e1f4a5b6c7d8",
        "has_availability_id": "64a9f3b2c3d8e1f4a5b6c7d8",
        "date_time_from": "2026-06-01T09:00:00+01:00",
        "date_time_to": "2026-06-01T17:00:00+01:00",
        "is_available": true
      }
    ]
  }
}

{
  "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/practitioners/order

List practitioners in display order

listPractitionersOrder

Returns a lightweight, non-paginated list of PractitionerSummary objects for the given site, sorted by each practitioner's order field then by name. Use this to render an ordering UI without pulling the full Practitioner payload for every entry.

Requires the RESERVATIONS_VIEW permission on the site.

Query parameters

site_idstringrequired
Filter results by the site they belong to

Responses

200
The practitioners for the site, sorted by order.
401
The user is unauthenticated
403
The authenticated user does not have permission.

curl "https://api.playground.try.be/shop/practitioners/order?site_id=site_abc123" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json"

const response = await fetch('https://api.playground.try.be/shop/practitioners/order?site_id=site_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/practitioners/order?site_id=site_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/practitioners/order?site_id=site_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/practitioners/order?site_id=site_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)
}

The practitioners for the site, sorted by `order`.

{
  "data": [
    {
      "id": "5dcb47800000000000000000",
      "name": "Jane Doe"
    }
  ]
}

{
  "message": "Unauthenticated"
}

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

put/shop/practitioners/order

Reorder practitioners for a site

updatePractitionersOrder

Reorders the practitioners at a site in one request. The order of practitioner_ids in the body determines each practitioner's order field (first ID → order: 0, second → order: 1, etc.). IDs not listed are unaffected and keep their existing order.

Returns the full ordered list (same shape as the GET response) so callers can re-render without a follow-up fetch.

Requires the SETTINGS_MANAGE permission on the site.

Request body

site_iduuidrequired
ID of the site whose practitioners are being reordered. All practitioner_ids must belong to this site.
practitioner_idsstring[]required
Practitioner IDs in the desired display order. Index in the array becomes the practitioner's order field.

Responses

200
The reordered list of practitioners.
401
The user is unauthenticated
403
The authenticated user does not have permission.
422
The request didn't pass validation

curl -X PUT "https://api.playground.try.be/shop/practitioners/order" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json" \
  -H "Content-Type: application/json" \
  -d '{
  "site_id": "6f1234567890abcdef123456",
  "practitioner_ids": [
    "64a9f3b2c3d8e1f4a5b6c7d8"
  ]
}'

const response = await fetch('https://api.playground.try.be/shop/practitioners/order', {
  method: 'PUT',
  headers: {
    Authorization: 'Bearer YOUR_API_KEY',
    'Content-Type': 'application/json',
    Accept: 'application/json',
  },
  body: JSON.stringify({
    "site_id": "6f1234567890abcdef123456",
    "practitioner_ids": [
      "64a9f3b2c3d8e1f4a5b6c7d8"
    ]
  }),
})

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

const data = await response.json()

import httpx

response = httpx.put(
    "https://api.playground.try.be/shop/practitioners/order",
    headers={
        "Authorization": "Bearer YOUR_API_KEY",
        "Accept": "application/json",
        "Content-Type": "application/json",
    },
    json={
        "site_id": "6f1234567890abcdef123456",
        "practitioner_ids": [
            "64a9f3b2c3d8e1f4a5b6c7d8"
        ]
    },
)
response.raise_for_status()
data = response.json()

<?php

$client = new \GuzzleHttp\Client();

$response = $client->request('PUT', 'https://api.playground.try.be/shop/practitioners/order', [
    'headers' => [
        'Authorization' => 'Bearer YOUR_API_KEY',
        'Accept' => 'application/json',
        'Content-Type' => 'application/json',
    ],
    'json' => [
            'site_id' => '6f1234567890abcdef123456',
            'practitioner_ids' => [
                '64a9f3b2c3d8e1f4a5b6c7d8'
            ]
        ],
]);

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

package main

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

func main() {
	payload, _ := json.Marshal(map[string]interface{}{
		"site_id": "6f1234567890abcdef123456",
		"practitioner_ids": []interface{}{
			"64a9f3b2c3d8e1f4a5b6c7d8",
		},
	})
	req, _ := http.NewRequest("PUT", "https://api.playground.try.be/shop/practitioners/order", 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 reordered list of practitioners.

{
  "data": [
    {
      "id": "5dcb47800000000000000000",
      "name": "Jane Doe"
    }
  ]
}

{
  "message": "Unauthenticated"
}

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

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

get/shop/practitioner-scheduled-availability

List a practitioner's scheduled availability

listPractitionerScheduledAvailability

Returns the resolved availability windows for one or more practitioners over the requested date range. Windows mix rota-derived "regular" availability with CustomAvailabilityRule overrides (which can be either available or explicitly unavailable); the response carries an availability_type flag so consumers can tell them apart.

Use either a date-range (date_from / date_to, inclusive of whole days in the practitioner's timezone) or a date-time range (date_time_from / date_time_to, half-open) — supply one pair or the other, not both.

Practitioners are processed in the order they appear in practitioner_ids; the response is sorted by start time within each practitioner. Returns an empty list if no practitioners were supplied.

Requires the view ability on every supplied practitioner. A single forbidden practitioner aborts the request with 403.

Query parameters

practitioner_idsstringrequired
Comma-separated list of practitioner IDs to compute availability for. The calling user must be able to view every practitioner; a single forbidden practitioner returns 403.
date_fromdateoptional
Restrict results to those on or after this date, ISO-8601 YYYY-MM-DD.
date_todateoptional
Restrict results to those on or before this date, ISO-8601 YYYY-MM-DD.
date_time_fromstringoptional
Inclusive start timestamp (YYYY-MM-DD HH:mm:ss) to compute availability for. Required when date_from/date_to are not supplied. Use this form for sub-day queries.
date_time_tostringoptional
Exclusive end timestamp. Required when date_from/date_to are not supplied. Must be strictly after date_time_from.

Responses

200
The resolved practitioner availability windows.
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/practitioner-scheduled-availability?practitioner_ids=5dcb47800000000000000001%2C5dcb47800000000000000002" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json"

const response = await fetch('https://api.playground.try.be/shop/practitioner-scheduled-availability?practitioner_ids=5dcb47800000000000000001%2C5dcb47800000000000000002', {
  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/practitioner-scheduled-availability?practitioner_ids=5dcb47800000000000000001%2C5dcb47800000000000000002",
    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/practitioner-scheduled-availability?practitioner_ids=5dcb47800000000000000001%2C5dcb47800000000000000002', [
    '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/practitioner-scheduled-availability?practitioner_ids=5dcb47800000000000000001%2C5dcb47800000000000000002", 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 resolved practitioner availability windows.

{
  "data": [
    {
      "practitioner_id": "64a9f3b2c3d8e1f4a5b6c7d8",
      "room_id": "64a9f3b2c3d8e1f4a5b6c7d8",
      "date_time_from": "2026-05-23T09:00:00+00:00",
      "date_time_to": "2026-05-23T17:00:00+00:00",
      "is_available": true,
      "availability_type": "regular",
      "custom_availability_id": "64a9f3b2c3d8e1f4a5b6c7d8"
    }
  ]
}

{
  "message": "Unauthenticated"
}

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

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