Calendar & Scheduling

Practitioner Rotas

Endpoints to manage Practitioner Rotas in Trybe.

get/shop/practitioner-rotas

List all practitioner rotas

listAllPractitionerRotas

Returns a paginated list of every PractitionerRota the caller is authorised to see, across all practitioners. Useful for schedule management UIs that need to show a unified rota view. Use the nested /shop/practitioners/{practitionerId}/rotas endpoint when you already know the practitioner and want to avoid the extra filtering.

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 PractitionerRota objects across all practitioners the caller can see.
401
The user is unauthenticated
403
The authenticated user does not have permission.

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

const response = await fetch('https://api.playground.try.be/shop/practitioner-rotas', {
  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-rotas",
    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-rotas', [
    '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-rotas", 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 `PractitionerRota` objects across all practitioners the caller can see.

{
  "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"
        }
      ]
    }
  ],
  "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."
}

post/shop/practitioner-rotas

Create a practitioner rota

createPractitionerRotaStandalone

Creates a new PractitionerRota for the practitioner identified by practitioner_id in the request body. Equivalent to calling the nested POST /shop/practitioners/{practitionerId}/rotas endpoint but doesn't require the practitioner ID in the URL.

Request body

practitioner_idobject-idrequired
Practitioner the new rota applies to. The caller must have SCHEDULE_MANAGE (or equivalent) on every site the practitioner works at — otherwise the request is rejected with 403.
start_datedateoptionalnullable
The date from which this rota is active (YYYY-MM-DD).
end_datedateoptionalnullable
The date on which this rota ends. Omit or pass null for an open-ended rota.
scheduling_week_intervalintegerrequired
The number of weeks in the rolling schedule cycle.
availability_rulesobject[]required
The availability rules for this rota.

Responses

201
A single PractitionerRota object.
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/practitioner-rotas" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json" \
  -H "Content-Type: application/json" \
  -d '{
  "practitioner_id": "5dcb47800000000000000010",
  "start_date": "2026-01-15",
  "end_date": "2026-01-15",
  "scheduling_week_interval": 2,
  "availability_rules": [
    {
      "week_num": 1,
      "weekday": "monday",
      "time_from": "09:00",
      "time_to": "17:00"
    }
  ]
}'

const response = await fetch('https://api.playground.try.be/shop/practitioner-rotas', {
  method: 'POST',
  headers: {
    Authorization: 'Bearer YOUR_API_KEY',
    'Content-Type': 'application/json',
    Accept: 'application/json',
  },
  body: JSON.stringify({
    "practitioner_id": "5dcb47800000000000000010",
    "start_date": "2026-01-15",
    "end_date": "2026-01-15",
    "scheduling_week_interval": 2,
    "availability_rules": [
      {
        "week_num": 1,
        "weekday": "monday",
        "time_from": "09:00",
        "time_to": "17:00"
      }
    ]
  }),
})

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/practitioner-rotas",
    headers={
        "Authorization": "Bearer YOUR_API_KEY",
        "Accept": "application/json",
        "Content-Type": "application/json",
    },
    json={
        "practitioner_id": "5dcb47800000000000000010",
        "start_date": "2026-01-15",
        "end_date": "2026-01-15",
        "scheduling_week_interval": 2,
        "availability_rules": [
            {
                "week_num": 1,
                "weekday": "monday",
                "time_from": "09:00",
                "time_to": "17:00"
            }
        ]
    },
)
response.raise_for_status()
data = response.json()

<?php

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api.playground.try.be/shop/practitioner-rotas', [
    'headers' => [
        'Authorization' => 'Bearer YOUR_API_KEY',
        'Accept' => 'application/json',
        'Content-Type' => 'application/json',
    ],
    'json' => [
            'practitioner_id' => '5dcb47800000000000000010',
            'start_date' => '2026-01-15',
            'end_date' => '2026-01-15',
            'scheduling_week_interval' => 2,
            'availability_rules' => [
                [
                    'week_num' => 1,
                    'weekday' => 'monday',
                    'time_from' => '09:00',
                    'time_to' => '17:00'
                ]
            ]
        ],
]);

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

package main

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

func main() {
	payload, _ := json.Marshal(map[string]interface{}{
		"practitioner_id": "5dcb47800000000000000010",
		"start_date": "2026-01-15",
		"end_date": "2026-01-15",
		"scheduling_week_interval": 2,
		"availability_rules": []interface{}{
			map[string]interface{}{
				"week_num": 1,
				"weekday": "monday",
				"time_from": "09:00",
				"time_to": "17:00",
			},
		},
	})
	req, _ := http.NewRequest("POST", "https://api.playground.try.be/shop/practitioner-rotas", 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 `PractitionerRota` object.

{
  "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"
      }
    ]
  }
}

{
  "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/practitioner-rotas/{practitionerRotaId}

Retrieve a practitioner rota by ID

getPractitionerRotaById

Returns the PractitionerRota identified by practitionerRotaId. The rota record includes the practitioner_id it belongs to. Equivalent to calling the nested GET /shop/practitioners/{practitionerId}/rotas/{rotaId} endpoint but doesn't require the practitioner ID in the URL.

Path parameters

practitionerRotaIdobject-idrequired
The ID of the PractitionerRota.

Responses

200
A single PractitionerRota object.
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/practitioner-rotas/abc123" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json"

const response = await fetch('https://api.playground.try.be/shop/practitioner-rotas/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/practitioner-rotas/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/practitioner-rotas/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/practitioner-rotas/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 `PractitionerRota` object.

{
  "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"
      }
    ]
  }
}

{
  "message": "Unauthenticated"
}

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

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

put/shop/practitioner-rotas/{practitionerRotaId}

Update a practitioner rota by ID

updatePractitionerRotaById

Updates the PractitionerRota identified by practitionerRotaId. The practitioner the rota belongs to cannot be changed; create a new rota and delete the old one if you need to move the schedule between practitioners.

Path parameters

practitionerRotaIdobject-idrequired
The ID of the PractitionerRota.

Request body

start_datedateoptionalnullable
The date from which this rota is active (YYYY-MM-DD).
end_datedateoptionalnullable
The date on which this rota ends. Pass null for an open-ended rota.
scheduling_week_intervalintegerrequired
The number of weeks in the rolling schedule cycle.
availability_rulesobject[]required
The availability rules for this rota.

Responses

200
A single PractitionerRota object.
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/practitioner-rotas/abc123" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json" \
  -H "Content-Type: application/json" \
  -d '{
  "start_date": "2026-01-15",
  "end_date": "2026-01-15",
  "scheduling_week_interval": 2,
  "availability_rules": [
    {
      "week_num": 1,
      "weekday": "monday",
      "time_from": "09:00",
      "time_to": "17:00"
    }
  ]
}'

const response = await fetch('https://api.playground.try.be/shop/practitioner-rotas/abc123', {
  method: 'PUT',
  headers: {
    Authorization: 'Bearer YOUR_API_KEY',
    'Content-Type': 'application/json',
    Accept: 'application/json',
  },
  body: JSON.stringify({
    "start_date": "2026-01-15",
    "end_date": "2026-01-15",
    "scheduling_week_interval": 2,
    "availability_rules": [
      {
        "week_num": 1,
        "weekday": "monday",
        "time_from": "09:00",
        "time_to": "17:00"
      }
    ]
  }),
})

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/practitioner-rotas/abc123",
    headers={
        "Authorization": "Bearer YOUR_API_KEY",
        "Accept": "application/json",
        "Content-Type": "application/json",
    },
    json={
        "start_date": "2026-01-15",
        "end_date": "2026-01-15",
        "scheduling_week_interval": 2,
        "availability_rules": [
            {
                "week_num": 1,
                "weekday": "monday",
                "time_from": "09:00",
                "time_to": "17:00"
            }
        ]
    },
)
response.raise_for_status()
data = response.json()

<?php

$client = new \GuzzleHttp\Client();

$response = $client->request('PUT', 'https://api.playground.try.be/shop/practitioner-rotas/abc123', [
    'headers' => [
        'Authorization' => 'Bearer YOUR_API_KEY',
        'Accept' => 'application/json',
        'Content-Type' => 'application/json',
    ],
    'json' => [
            'start_date' => '2026-01-15',
            'end_date' => '2026-01-15',
            'scheduling_week_interval' => 2,
            'availability_rules' => [
                [
                    'week_num' => 1,
                    'weekday' => 'monday',
                    'time_from' => '09:00',
                    'time_to' => '17:00'
                ]
            ]
        ],
]);

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

package main

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

func main() {
	payload, _ := json.Marshal(map[string]interface{}{
		"start_date": "2026-01-15",
		"end_date": "2026-01-15",
		"scheduling_week_interval": 2,
		"availability_rules": []interface{}{
			map[string]interface{}{
				"week_num": 1,
				"weekday": "monday",
				"time_from": "09:00",
				"time_to": "17:00",
			},
		},
	})
	req, _ := http.NewRequest("PUT", "https://api.playground.try.be/shop/practitioner-rotas/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 `PractitionerRota` object.

{
  "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"
      }
    ]
  }
}

{
  "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/practitioner-rotas/{practitionerRotaId}

Delete a practitioner rota by ID

deletePractitionerRotaById

Deletes the PractitionerRota identified by practitionerRotaId. Any future availability windows generated from this rota are invalidated, but existing bookings are retained.

Path parameters

practitionerRotaIdobject-idrequired
The ID of the PractitionerRota.

Responses

204
PractitionerRota 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/practitioner-rotas/abc123" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json"

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

PractitionerRota deleted successfully.

// empty response

{
  "message": "Unauthenticated"
}

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

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

get/shop/practitioners/{practitionerId}/rotas

List rotas for a practitioner

listPractitionerRotas

Returns a paginated list of PractitionerRota objects for the given 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.
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 PractitionerRota objects.
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/rotas" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json"

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

{
  "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"
        }
      ]
    }
  ],
  "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}/rotas

Create a rota for a practitioner

createPractitionerRota

Creates a new PractitionerRota for the given 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.

Request body

practitioner_idobject-idrequired
Identifier of the practitioner this rota applies to. Must match the practitionerId in the URL; included in the body so the rota is self-describing on writeback to integrations and audit logs.
start_datedateoptionalnullable
The date from which this rota is active (YYYY-MM-DD).
end_datedateoptionalnullable
The date on which this rota ends. Omit or pass null for an open-ended rota.
scheduling_week_intervalintegerrequired
The number of weeks in the rolling schedule cycle.
availability_rulesobject[]required
The availability rules for this rota.

Responses

201
A single PractitionerRota object.
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/rotas" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json" \
  -H "Content-Type: application/json" \
  -d '{
  "practitioner_id": "64a9f3b2c3d8e1f4a5b6c7d8",
  "start_date": "2026-01-15",
  "end_date": "2026-01-15",
  "scheduling_week_interval": 2,
  "availability_rules": [
    {
      "week_num": 1,
      "weekday": "monday",
      "time_from": "09:00",
      "time_to": "17:00"
    }
  ]
}'

const response = await fetch('https://api.playground.try.be/shop/practitioners/abc123/rotas', {
  method: 'POST',
  headers: {
    Authorization: 'Bearer YOUR_API_KEY',
    'Content-Type': 'application/json',
    Accept: 'application/json',
  },
  body: JSON.stringify({
    "practitioner_id": "64a9f3b2c3d8e1f4a5b6c7d8",
    "start_date": "2026-01-15",
    "end_date": "2026-01-15",
    "scheduling_week_interval": 2,
    "availability_rules": [
      {
        "week_num": 1,
        "weekday": "monday",
        "time_from": "09:00",
        "time_to": "17:00"
      }
    ]
  }),
})

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/rotas",
    headers={
        "Authorization": "Bearer YOUR_API_KEY",
        "Accept": "application/json",
        "Content-Type": "application/json",
    },
    json={
        "practitioner_id": "64a9f3b2c3d8e1f4a5b6c7d8",
        "start_date": "2026-01-15",
        "end_date": "2026-01-15",
        "scheduling_week_interval": 2,
        "availability_rules": [
            {
                "week_num": 1,
                "weekday": "monday",
                "time_from": "09:00",
                "time_to": "17:00"
            }
        ]
    },
)
response.raise_for_status()
data = response.json()

<?php

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api.playground.try.be/shop/practitioners/abc123/rotas', [
    'headers' => [
        'Authorization' => 'Bearer YOUR_API_KEY',
        'Accept' => 'application/json',
        'Content-Type' => 'application/json',
    ],
    'json' => [
            'practitioner_id' => '64a9f3b2c3d8e1f4a5b6c7d8',
            'start_date' => '2026-01-15',
            'end_date' => '2026-01-15',
            'scheduling_week_interval' => 2,
            'availability_rules' => [
                [
                    'week_num' => 1,
                    'weekday' => 'monday',
                    'time_from' => '09:00',
                    'time_to' => '17:00'
                ]
            ]
        ],
]);

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

package main

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

func main() {
	payload, _ := json.Marshal(map[string]interface{}{
		"practitioner_id": "64a9f3b2c3d8e1f4a5b6c7d8",
		"start_date": "2026-01-15",
		"end_date": "2026-01-15",
		"scheduling_week_interval": 2,
		"availability_rules": []interface{}{
			map[string]interface{}{
				"week_num": 1,
				"weekday": "monday",
				"time_from": "09:00",
				"time_to": "17:00",
			},
		},
	})
	req, _ := http.NewRequest("POST", "https://api.playground.try.be/shop/practitioners/abc123/rotas", 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 `PractitionerRota` object.

{
  "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"
      }
    ]
  }
}

{
  "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}/rotas/{rotaId}

Retrieve a practitioner rota

getPractitionerRota

Use this endpoint to retrieve a single PractitionerRota.

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.
rotaIduuidrequired
The ID of the PractitionerRota.

Responses

200
A single PractitionerRota object.
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/rotas/00000000-0000-0000-0000-000000000000" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json"

const response = await fetch('https://api.playground.try.be/shop/practitioners/abc123/rotas/00000000-0000-0000-0000-000000000000', {
  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/rotas/00000000-0000-0000-0000-000000000000",
    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/rotas/00000000-0000-0000-0000-000000000000', [
    '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/rotas/00000000-0000-0000-0000-000000000000", 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 `PractitionerRota` object.

{
  "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"
      }
    ]
  }
}

{
  "message": "Unauthenticated"
}

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

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

put/shop/practitioners/{practitionerId}/rotas/{rotaId}

Update a practitioner rota

updatePractitionerRota

Use this endpoint to update an existing PractitionerRota.

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.
rotaIduuidrequired
The ID of the PractitionerRota.

Request body

start_datedateoptionalnullable
The date from which this rota is active (YYYY-MM-DD).
end_datedateoptionalnullable
The date on which this rota ends. Pass null for an open-ended rota.
scheduling_week_intervalintegerrequired
The number of weeks in the rolling schedule cycle.
availability_rulesobject[]required
The availability rules for this rota.

Responses

200
A single PractitionerRota object.
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/rotas/00000000-0000-0000-0000-000000000000" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json" \
  -H "Content-Type: application/json" \
  -d '{
  "start_date": "2026-01-15",
  "end_date": "2026-01-15",
  "scheduling_week_interval": 2,
  "availability_rules": [
    {
      "week_num": 1,
      "weekday": "monday",
      "time_from": "09:00",
      "time_to": "17:00"
    }
  ]
}'

const response = await fetch('https://api.playground.try.be/shop/practitioners/abc123/rotas/00000000-0000-0000-0000-000000000000', {
  method: 'PUT',
  headers: {
    Authorization: 'Bearer YOUR_API_KEY',
    'Content-Type': 'application/json',
    Accept: 'application/json',
  },
  body: JSON.stringify({
    "start_date": "2026-01-15",
    "end_date": "2026-01-15",
    "scheduling_week_interval": 2,
    "availability_rules": [
      {
        "week_num": 1,
        "weekday": "monday",
        "time_from": "09:00",
        "time_to": "17:00"
      }
    ]
  }),
})

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/rotas/00000000-0000-0000-0000-000000000000",
    headers={
        "Authorization": "Bearer YOUR_API_KEY",
        "Accept": "application/json",
        "Content-Type": "application/json",
    },
    json={
        "start_date": "2026-01-15",
        "end_date": "2026-01-15",
        "scheduling_week_interval": 2,
        "availability_rules": [
            {
                "week_num": 1,
                "weekday": "monday",
                "time_from": "09:00",
                "time_to": "17:00"
            }
        ]
    },
)
response.raise_for_status()
data = response.json()

<?php

$client = new \GuzzleHttp\Client();

$response = $client->request('PUT', 'https://api.playground.try.be/shop/practitioners/abc123/rotas/00000000-0000-0000-0000-000000000000', [
    'headers' => [
        'Authorization' => 'Bearer YOUR_API_KEY',
        'Accept' => 'application/json',
        'Content-Type' => 'application/json',
    ],
    'json' => [
            'start_date' => '2026-01-15',
            'end_date' => '2026-01-15',
            'scheduling_week_interval' => 2,
            'availability_rules' => [
                [
                    'week_num' => 1,
                    'weekday' => 'monday',
                    'time_from' => '09:00',
                    'time_to' => '17:00'
                ]
            ]
        ],
]);

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

package main

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

func main() {
	payload, _ := json.Marshal(map[string]interface{}{
		"start_date": "2026-01-15",
		"end_date": "2026-01-15",
		"scheduling_week_interval": 2,
		"availability_rules": []interface{}{
			map[string]interface{}{
				"week_num": 1,
				"weekday": "monday",
				"time_from": "09:00",
				"time_to": "17:00",
			},
		},
	})
	req, _ := http.NewRequest("PUT", "https://api.playground.try.be/shop/practitioners/abc123/rotas/00000000-0000-0000-0000-000000000000", 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 `PractitionerRota` object.

{
  "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"
      }
    ]
  }
}

{
  "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}/rotas/{rotaId}

Delete a practitioner rota

deletePractitionerRota

Use this endpoint to delete a PractitionerRota.

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.
rotaIduuidrequired
The ID of the PractitionerRota.

Responses

204
PractitionerRota 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/rotas/00000000-0000-0000-0000-000000000000" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json"

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

PractitionerRota deleted successfully.

// empty response

{
  "message": "Unauthenticated"
}

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

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