Sites & Organisation

Bookable Areas

A BookableArea is a physical area at a site (e.g. cabana, hot tub, treatment pod) that customers reserve via an AreaBookingType. Each area has a capacity and an availability schedule made up of AvailabilityRules.

The BookableArea object

Attributes

idobject-idrequired
Unique identifier of the bookable area.
organisation_iduuidrequired
ID of the organisation the bookable area belongs to.
site_iduuidrequired
ID of the site the bookable area belongs to. A bookable area is scoped to exactly one site.
namestringrequired
Display name for the bookable area. Shown to staff and customers.
descriptionstringrequirednullable
Long-form description of the bookable area.
capacityintegerrequired
Maximum number of simultaneous bookings. 1 means exclusive-use; values > 1 allow shared occupancy.
availability_rulesobject[]required
The AvailabilityRules currently configured on this area. These determine when the area is bookable. Manage them via the /shop/bookable-areas/{bookableAreaId}/availability-rules endpoints.
zonesobject[]optional
Hydrated Zone records this bookable area belongs to. Zones group areas in the floor plan for spatial constraints.

{
  "id": "5dcb47800000000000000000",
  "organisation_id": "0193b6e0-3b56-7000-9f50-9d3d5e2c1111",
  "site_id": "0193b6e0-3b56-7000-9f50-9d3d5e2c2222",
  "name": "Hot Tub 1",
  "description": "Private rooftop hot tub for up to four guests. 38°C, sunset\nviews over the gardens.\n",
  "capacity": 4,
  "availability_rules": [
    {
      "id": "64a9f3b2c3d8e1f4a5b6c7d8",
      "date_from": "2021-02-15T12:00:00+00:00",
      "date_to": "2021-02-15T12:00:00+00:00",
      "is_available": true,
      "max_duration": 1,
      "min_duration": 1,
      "time_from": "11:00",
      "time_to": "17:00",
      "weekdays": [
        "string"
      ]
    }
  ],
  "zones": [
    {
      "id": "5f1234567890abcdef123456",
      "name": "Pool Deck",
      "organisation_id": "22222222-2222-2222-2222-222222222222",
      "site_id": "11111111-1111-1111-1111-111111111111"
    }
  ]
}

get/shop/bookable-areas

List bookable areas

listBookableAreas

Returns a paginated list of BookableAreas at the given site, ordered by their order field then by name. Use this to populate a settings dashboard or a calendar resource picker.

Requires the RESERVATIONS_VIEW permission on the site.

Query parameters

site_idstringrequired
Filter results by the site they belong to
pageintegeroptional
The page to retrieve results from
per_pageintegeroptional
The number of results to return per page

Responses

200
A paginated list of BookableAreas.
401
The user is unauthenticated
403
The authenticated user does not have permission.

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

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

A paginated list of `BookableArea`s.

{
  "data": [
    {
      "id": "5dcb47800000000000000000",
      "organisation_id": "0193b6e0-3b56-7000-9f50-9d3d5e2c1111",
      "site_id": "0193b6e0-3b56-7000-9f50-9d3d5e2c2222",
      "name": "Hot Tub 1",
      "description": "Private rooftop hot tub for up to four guests. 38°C, sunset\nviews over the gardens.\n",
      "capacity": 4,
      "availability_rules": [
        {
          "id": "64a9f3b2c3d8e1f4a5b6c7d8",
          "date_from": "2021-02-15T12:00:00+00:00",
          "date_to": "2021-02-15T12:00:00+00:00",
          "is_available": true,
          "max_duration": 1,
          "min_duration": 1,
          "time_from": "11:00",
          "time_to": "17:00",
          "weekdays": [
            "string"
          ]
        }
      ],
      "zones": [
        {
          "id": "5f1234567890abcdef123456",
          "name": "Pool Deck",
          "organisation_id": "22222222-2222-2222-2222-222222222222",
          "site_id": "11111111-1111-1111-1111-111111111111"
        }
      ]
    }
  ]
}

{
  "message": "Unauthenticated"
}

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

post/shop/bookable-areas

Create a bookable area

createBookableArea

Creates a new BookableArea at the site identified by the site_id query parameter. The minimum body is name and capacity.

Requires the SETTINGS_MANAGE permission on the site.

Query parameters

site_idstringrequired
Filter results by the site they belong to
pageintegeroptional
The page to retrieve results from
per_pageintegeroptional
The number of results to return per page

Request body

namestringoptional
New display name for the bookable area.
descriptionstringoptionalnullable
Replacement long-form description shown to customers on the shopfront. Markdown is rendered. Pass null to clear.
capacityintegeroptional
New capacity. Lowering capacity doesn't cancel existing bookings — they keep their slot.
zone_idsstring[]optional
Zones the area belongs to. Filtered to the area's site.

Responses

201
A single BookableArea.
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/bookable-areas?site_id=site_abc123" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json" \
  -H "Content-Type: application/json" \
  -d '{
  "name": "Hot Tub 1",
  "description": "Heated 4-person hot tub with hydrotherapy jets, available year-round.",
  "capacity": 4,
  "zone_ids": [
    "64a9f3b2c3d8e1f4a5b6c7d8"
  ]
}'

const response = await fetch('https://api.playground.try.be/shop/bookable-areas?site_id=site_abc123', {
  method: 'POST',
  headers: {
    Authorization: 'Bearer YOUR_API_KEY',
    'Content-Type': 'application/json',
    Accept: 'application/json',
  },
  body: JSON.stringify({
    "name": "Hot Tub 1",
    "description": "Heated 4-person hot tub with hydrotherapy jets, available year-round.",
    "capacity": 4,
    "zone_ids": [
      "64a9f3b2c3d8e1f4a5b6c7d8"
    ]
  }),
})

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/bookable-areas?site_id=site_abc123",
    headers={
        "Authorization": "Bearer YOUR_API_KEY",
        "Accept": "application/json",
        "Content-Type": "application/json",
    },
    json={
        "name": "Hot Tub 1",
        "description": "Heated 4-person hot tub with hydrotherapy jets, available year-round.",
        "capacity": 4,
        "zone_ids": [
            "64a9f3b2c3d8e1f4a5b6c7d8"
        ]
    },
)
response.raise_for_status()
data = response.json()

<?php

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api.playground.try.be/shop/bookable-areas?site_id=site_abc123', [
    'headers' => [
        'Authorization' => 'Bearer YOUR_API_KEY',
        'Accept' => 'application/json',
        'Content-Type' => 'application/json',
    ],
    'json' => [
            'name' => 'Hot Tub 1',
            'description' => 'Heated 4-person hot tub with hydrotherapy jets, available year-round.',
            'capacity' => 4,
            'zone_ids' => [
                '64a9f3b2c3d8e1f4a5b6c7d8'
            ]
        ],
]);

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

package main

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

func main() {
	payload, _ := json.Marshal(map[string]interface{}{
		"name": "Hot Tub 1",
		"description": "Heated 4-person hot tub with hydrotherapy jets, available year-round.",
		"capacity": 4,
		"zone_ids": []interface{}{
			"64a9f3b2c3d8e1f4a5b6c7d8",
		},
	})
	req, _ := http.NewRequest("POST", "https://api.playground.try.be/shop/bookable-areas?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)
}

A single `BookableArea`.

{
  "data": {
    "id": "5dcb47800000000000000000",
    "organisation_id": "0193b6e0-3b56-7000-9f50-9d3d5e2c1111",
    "site_id": "0193b6e0-3b56-7000-9f50-9d3d5e2c2222",
    "name": "Hot Tub 1",
    "description": "Private rooftop hot tub for up to four guests. 38°C, sunset\nviews over the gardens.\n",
    "capacity": 4,
    "availability_rules": [
      {
        "id": "64a9f3b2c3d8e1f4a5b6c7d8",
        "date_from": "2021-02-15T12:00:00+00:00",
        "date_to": "2021-02-15T12:00:00+00:00",
        "is_available": true,
        "max_duration": 1,
        "min_duration": 1,
        "time_from": "11:00",
        "time_to": "17:00",
        "weekdays": [
          "string"
        ]
      }
    ],
    "zones": [
      {
        "id": "5f1234567890abcdef123456",
        "name": "Pool Deck",
        "organisation_id": "22222222-2222-2222-2222-222222222222",
        "site_id": "11111111-1111-1111-1111-111111111111"
      }
    ]
  }
}

{
  "message": "Unauthenticated"
}

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

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

get/shop/bookable-areas/order

List ordered bookable areas

listOrderedBookableAreas

Returns the site's BookableAreas in their current display order. Pair with PUT /shop/bookable-areas/order to power a drag-and-drop ordering UI.

Requires the RESERVATIONS_VIEW permission on the site.

Query parameters

site_idstringrequired
Filter results by the site they belong to

Responses

200
The site's bookable areas in display order. Pair with PUT /shop/bookable-areas/order to power a drag-and-drop UI.
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/bookable-areas/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/bookable-areas/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/bookable-areas/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/bookable-areas/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/bookable-areas/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 site's bookable areas in display order. Pair with `PUT /shop/bookable-areas/order` to power a drag-and-drop UI.

{
  "data": [
    {
      "id": "64a9f3b2c3d8e1f4a5b6c7d8",
      "name": "Hot Tub 1"
    }
  ]
}

{
  "message": "Unauthenticated"
}

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

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

put/shop/bookable-areas/order

Update bookable area order

updateBookableAreaOrder

Replaces the display order of the site's BookableAreas. The order of area_ids in the body is the new order — element 0 becomes order=0, element 1 becomes order=1, and so on.

Requires the SETTINGS_MANAGE permission on the site.

Request body

area_idsstring[]required
Ordered list of bookable area IDs. Element 0 becomes the first-displayed area.
site_iduuidrequired
ID of the site whose area order is being updated. The caller's API key must have access to this site.

Responses

200
The site's bookable areas in display order. Pair with PUT /shop/bookable-areas/order to power a drag-and-drop UI.
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/bookable-areas/order" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json" \
  -H "Content-Type: application/json" \
  -d '{
  "area_ids": [
    "64a9f3b2c3d8e1f4a5b6c7d8"
  ],
  "site_id": "00000000-0000-0000-0000-000000000000"
}'

const response = await fetch('https://api.playground.try.be/shop/bookable-areas/order', {
  method: 'PUT',
  headers: {
    Authorization: 'Bearer YOUR_API_KEY',
    'Content-Type': 'application/json',
    Accept: 'application/json',
  },
  body: JSON.stringify({
    "area_ids": [
      "64a9f3b2c3d8e1f4a5b6c7d8"
    ],
    "site_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/bookable-areas/order",
    headers={
        "Authorization": "Bearer YOUR_API_KEY",
        "Accept": "application/json",
        "Content-Type": "application/json",
    },
    json={
        "area_ids": [
            "64a9f3b2c3d8e1f4a5b6c7d8"
        ],
        "site_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/bookable-areas/order', [
    'headers' => [
        'Authorization' => 'Bearer YOUR_API_KEY',
        'Accept' => 'application/json',
        'Content-Type' => 'application/json',
    ],
    'json' => [
            'area_ids' => [
                '64a9f3b2c3d8e1f4a5b6c7d8'
            ],
            'site_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{}{
		"area_ids": []interface{}{
			"64a9f3b2c3d8e1f4a5b6c7d8",
		},
		"site_id": "00000000-0000-0000-0000-000000000000",
	})
	req, _ := http.NewRequest("PUT", "https://api.playground.try.be/shop/bookable-areas/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 site's bookable areas in display order. Pair with `PUT /shop/bookable-areas/order` to power a drag-and-drop UI.

{
  "data": [
    {
      "id": "64a9f3b2c3d8e1f4a5b6c7d8",
      "name": "Hot Tub 1"
    }
  ]
}

{
  "message": "Unauthenticated"
}

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

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

get/shop/bookable-areas/{bookableAreaId}

Retrieve a bookable area

getBookableArea

Returns the full BookableArea for the given ID.

Requires the RESERVATIONS_VIEW permission on the area's site.

Path parameters

bookableAreaIdobject-idrequired
The ID of the bookable area.

Responses

200
A single BookableArea.
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/bookable-areas/abc123" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json"

const response = await fetch('https://api.playground.try.be/shop/bookable-areas/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/bookable-areas/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/bookable-areas/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/bookable-areas/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 `BookableArea`.

{
  "data": {
    "id": "5dcb47800000000000000000",
    "organisation_id": "0193b6e0-3b56-7000-9f50-9d3d5e2c1111",
    "site_id": "0193b6e0-3b56-7000-9f50-9d3d5e2c2222",
    "name": "Hot Tub 1",
    "description": "Private rooftop hot tub for up to four guests. 38°C, sunset\nviews over the gardens.\n",
    "capacity": 4,
    "availability_rules": [
      {
        "id": "64a9f3b2c3d8e1f4a5b6c7d8",
        "date_from": "2021-02-15T12:00:00+00:00",
        "date_to": "2021-02-15T12:00:00+00:00",
        "is_available": true,
        "max_duration": 1,
        "min_duration": 1,
        "time_from": "11:00",
        "time_to": "17:00",
        "weekdays": [
          "string"
        ]
      }
    ],
    "zones": [
      {
        "id": "5f1234567890abcdef123456",
        "name": "Pool Deck",
        "organisation_id": "22222222-2222-2222-2222-222222222222",
        "site_id": "11111111-1111-1111-1111-111111111111"
      }
    ]
  }
}

{
  "message": "Unauthenticated"
}

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

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

put/shop/bookable-areas/{bookableAreaId}

Update a bookable area

updateBookableArea

Updates a BookableArea. The validator enforces the same shape as on create — name and capacity are required. Sending fewer fields than that returns 422.

Requires the SETTINGS_MANAGE permission on the area's site.

Path parameters

bookableAreaIdobject-idrequired
The ID of the bookable area.

Request body

namestringrequired
New display name for the bookable area.
descriptionstringoptionalnullable
Replacement long-form description shown to customers on the shopfront. Markdown is rendered. Pass null to clear.
capacityintegerrequired
New capacity. Lowering capacity doesn't cancel existing bookings — they keep their slot.
zone_idsstring[]optional
Zones the area belongs to. Filtered to the area's site.

Responses

200
A single BookableArea.
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/bookable-areas/abc123" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json" \
  -H "Content-Type: application/json" \
  -d '{
  "name": "Hot Tub 1",
  "description": "Heated 4-person hot tub with hydrotherapy jets, available year-round.",
  "capacity": 4,
  "zone_ids": [
    "64a9f3b2c3d8e1f4a5b6c7d8"
  ]
}'

const response = await fetch('https://api.playground.try.be/shop/bookable-areas/abc123', {
  method: 'PUT',
  headers: {
    Authorization: 'Bearer YOUR_API_KEY',
    'Content-Type': 'application/json',
    Accept: 'application/json',
  },
  body: JSON.stringify({
    "name": "Hot Tub 1",
    "description": "Heated 4-person hot tub with hydrotherapy jets, available year-round.",
    "capacity": 4,
    "zone_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/bookable-areas/abc123",
    headers={
        "Authorization": "Bearer YOUR_API_KEY",
        "Accept": "application/json",
        "Content-Type": "application/json",
    },
    json={
        "name": "Hot Tub 1",
        "description": "Heated 4-person hot tub with hydrotherapy jets, available year-round.",
        "capacity": 4,
        "zone_ids": [
            "64a9f3b2c3d8e1f4a5b6c7d8"
        ]
    },
)
response.raise_for_status()
data = response.json()

<?php

$client = new \GuzzleHttp\Client();

$response = $client->request('PUT', 'https://api.playground.try.be/shop/bookable-areas/abc123', [
    'headers' => [
        'Authorization' => 'Bearer YOUR_API_KEY',
        'Accept' => 'application/json',
        'Content-Type' => 'application/json',
    ],
    'json' => [
            'name' => 'Hot Tub 1',
            'description' => 'Heated 4-person hot tub with hydrotherapy jets, available year-round.',
            'capacity' => 4,
            'zone_ids' => [
                '64a9f3b2c3d8e1f4a5b6c7d8'
            ]
        ],
]);

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

package main

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

func main() {
	payload, _ := json.Marshal(map[string]interface{}{
		"name": "Hot Tub 1",
		"description": "Heated 4-person hot tub with hydrotherapy jets, available year-round.",
		"capacity": 4,
		"zone_ids": []interface{}{
			"64a9f3b2c3d8e1f4a5b6c7d8",
		},
	})
	req, _ := http.NewRequest("PUT", "https://api.playground.try.be/shop/bookable-areas/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 `BookableArea`.

{
  "data": {
    "id": "5dcb47800000000000000000",
    "organisation_id": "0193b6e0-3b56-7000-9f50-9d3d5e2c1111",
    "site_id": "0193b6e0-3b56-7000-9f50-9d3d5e2c2222",
    "name": "Hot Tub 1",
    "description": "Private rooftop hot tub for up to four guests. 38°C, sunset\nviews over the gardens.\n",
    "capacity": 4,
    "availability_rules": [
      {
        "id": "64a9f3b2c3d8e1f4a5b6c7d8",
        "date_from": "2021-02-15T12:00:00+00:00",
        "date_to": "2021-02-15T12:00:00+00:00",
        "is_available": true,
        "max_duration": 1,
        "min_duration": 1,
        "time_from": "11:00",
        "time_to": "17:00",
        "weekdays": [
          "string"
        ]
      }
    ],
    "zones": [
      {
        "id": "5f1234567890abcdef123456",
        "name": "Pool Deck",
        "organisation_id": "22222222-2222-2222-2222-222222222222",
        "site_id": "11111111-1111-1111-1111-111111111111"
      }
    ]
  }
}

{
  "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/bookable-areas/{bookableAreaId}

Delete a bookable area

deleteBookableArea

Soft-deletes the bookable area. Existing area bookings are unaffected, but the area is removed from new-booking allocations and disassociated from any AreaBookingType it was attached to.

Requires the SETTINGS_MANAGE permission on the area's site.

Path parameters

bookableAreaIdobject-idrequired
The ID of the bookable area.

Responses

204
Bookable area 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/bookable-areas/abc123" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json"

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

Bookable area deleted successfully.

// empty response

{
  "message": "Unauthenticated"
}

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

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

post/shop/bookable-areas/{bookableAreaId}/copy

Duplicate a bookable area

copyBookableArea

Creates a copy of an existing BookableArea under the same site and organisation. Useful for seeding additional areas off an existing one — e.g. "Hot Tub 2" copied from "Hot Tub 1".

Requires the SETTINGS_MANAGE permission on the area's site.

Path parameters

bookableAreaIdobject-idrequired
The ID of the bookable area.

Request body

namestringrequired
Display name for the new copy.
descriptionstringoptional
Long-form description for the new copy, shown to customers on the shopfront. Markdown is rendered. Omit to inherit the source area's description.
capacityintegerrequired
Maximum guests this area can hold concurrently. Defaults to the source area's capacity when omitted. Lowering capacity later does not affect existing bookings already above the limit.
zone_idsstring[]optional
Zones the copy belongs to. Filtered to the source area's site.

Responses

201
A single BookableArea.
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/bookable-areas/abc123/copy" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json" \
  -H "Content-Type: application/json" \
  -d '{
  "name": "Hot Tub 2",
  "description": "A second hot-tub bay alongside the first, set up for couples bookings.",
  "capacity": 4,
  "zone_ids": [
    "64a9f3b2c3d8e1f4a5b6c7d8"
  ]
}'

const response = await fetch('https://api.playground.try.be/shop/bookable-areas/abc123/copy', {
  method: 'POST',
  headers: {
    Authorization: 'Bearer YOUR_API_KEY',
    'Content-Type': 'application/json',
    Accept: 'application/json',
  },
  body: JSON.stringify({
    "name": "Hot Tub 2",
    "description": "A second hot-tub bay alongside the first, set up for couples bookings.",
    "capacity": 4,
    "zone_ids": [
      "64a9f3b2c3d8e1f4a5b6c7d8"
    ]
  }),
})

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/bookable-areas/abc123/copy",
    headers={
        "Authorization": "Bearer YOUR_API_KEY",
        "Accept": "application/json",
        "Content-Type": "application/json",
    },
    json={
        "name": "Hot Tub 2",
        "description": "A second hot-tub bay alongside the first, set up for couples bookings.",
        "capacity": 4,
        "zone_ids": [
            "64a9f3b2c3d8e1f4a5b6c7d8"
        ]
    },
)
response.raise_for_status()
data = response.json()

<?php

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api.playground.try.be/shop/bookable-areas/abc123/copy', [
    'headers' => [
        'Authorization' => 'Bearer YOUR_API_KEY',
        'Accept' => 'application/json',
        'Content-Type' => 'application/json',
    ],
    'json' => [
            'name' => 'Hot Tub 2',
            'description' => 'A second hot-tub bay alongside the first, set up for couples bookings.',
            'capacity' => 4,
            'zone_ids' => [
                '64a9f3b2c3d8e1f4a5b6c7d8'
            ]
        ],
]);

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

package main

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

func main() {
	payload, _ := json.Marshal(map[string]interface{}{
		"name": "Hot Tub 2",
		"description": "A second hot-tub bay alongside the first, set up for couples bookings.",
		"capacity": 4,
		"zone_ids": []interface{}{
			"64a9f3b2c3d8e1f4a5b6c7d8",
		},
	})
	req, _ := http.NewRequest("POST", "https://api.playground.try.be/shop/bookable-areas/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)
}

A single `BookableArea`.

{
  "data": {
    "id": "5dcb47800000000000000000",
    "organisation_id": "0193b6e0-3b56-7000-9f50-9d3d5e2c1111",
    "site_id": "0193b6e0-3b56-7000-9f50-9d3d5e2c2222",
    "name": "Hot Tub 1",
    "description": "Private rooftop hot tub for up to four guests. 38°C, sunset\nviews over the gardens.\n",
    "capacity": 4,
    "availability_rules": [
      {
        "id": "64a9f3b2c3d8e1f4a5b6c7d8",
        "date_from": "2021-02-15T12:00:00+00:00",
        "date_to": "2021-02-15T12:00:00+00:00",
        "is_available": true,
        "max_duration": 1,
        "min_duration": 1,
        "time_from": "11:00",
        "time_to": "17:00",
        "weekdays": [
          "string"
        ]
      }
    ],
    "zones": [
      {
        "id": "5f1234567890abcdef123456",
        "name": "Pool Deck",
        "organisation_id": "22222222-2222-2222-2222-222222222222",
        "site_id": "11111111-1111-1111-1111-111111111111"
      }
    ]
  }
}

{
  "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/bookable-areas/{bookableAreaId}/availability-rules

List availability rules for a bookable area

listBookableAreaAvailabilityRules

Returns all AvailabilityRules configured on a BookableArea. Availability rules carve up the calendar into windows when the area can or cannot be booked — useful for blocking maintenance slots or restricting cabana hours.

Any is_available: false rule overrides any is_available: true rule for the same time period.

Requires the SETTINGS_MANAGE permission on the area's site.

Path parameters

bookableAreaIdobject-idrequired
The ID of the bookable area.

Responses

200
A list of AvailabilityRules on a BookableArea.
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/bookable-areas/abc123/availability-rules" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json"

const response = await fetch('https://api.playground.try.be/shop/bookable-areas/abc123/availability-rules', {
  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/bookable-areas/abc123/availability-rules",
    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/bookable-areas/abc123/availability-rules', [
    '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/bookable-areas/abc123/availability-rules", 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 `AvailabilityRule`s on a `BookableArea`.

{
  "data": [
    {
      "id": "64a9f3b2c3d8e1f4a5b6c7d8",
      "date_from": "2021-02-15T12:00:00+00:00",
      "date_to": "2021-02-15T12:00:00+00:00",
      "is_available": true,
      "max_duration": 1,
      "min_duration": 1,
      "time_from": "11:00",
      "time_to": "17:00",
      "weekdays": [
        "string"
      ]
    }
  ]
}

{
  "message": "Unauthenticated"
}

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

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

post/shop/bookable-areas/{bookableAreaId}/availability-rules

Create an availability rule for a bookable area

createBookableAreaAvailabilityRule

Adds a new AvailabilityRule to a BookableArea. With is_available: true the rule opens new bookable windows; with is_available: false it blocks them. Omitting date/time/weekday filters means the rule applies always.

date_from defaults to today in the area's timezone when omitted.

Requires the SETTINGS_MANAGE permission on the area's site.

Path parameters

bookableAreaIdobject-idrequired
The ID of the bookable area.

Request body

is_availablebooleanoptional
Whether the window is bookable. false rules override true rules.
date_fromdateoptionalnullable
First date this rule applies (inclusive).
date_todateoptionalnullable
Last date this rule applies (inclusive).
time_fromstringoptionalnullable
Daily start time in HH:MM.
time_tostringoptionalnullable
Daily end time in HH:MM.
weekdaysstring[]optional

Responses

201
A single AvailabilityRule.
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/bookable-areas/abc123/availability-rules" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json" \
  -H "Content-Type: application/json" \
  -d '{
  "is_available": true,
  "date_from": "2026-06-01",
  "date_to": "2026-08-31",
  "time_from": "10:00",
  "time_to": "18:00",
  "weekdays": [
    "monday"
  ]
}'

const response = await fetch('https://api.playground.try.be/shop/bookable-areas/abc123/availability-rules', {
  method: 'POST',
  headers: {
    Authorization: 'Bearer YOUR_API_KEY',
    'Content-Type': 'application/json',
    Accept: 'application/json',
  },
  body: JSON.stringify({
    "is_available": true,
    "date_from": "2026-06-01",
    "date_to": "2026-08-31",
    "time_from": "10:00",
    "time_to": "18:00",
    "weekdays": [
      "monday"
    ]
  }),
})

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/bookable-areas/abc123/availability-rules",
    headers={
        "Authorization": "Bearer YOUR_API_KEY",
        "Accept": "application/json",
        "Content-Type": "application/json",
    },
    json={
        "is_available": True,
        "date_from": "2026-06-01",
        "date_to": "2026-08-31",
        "time_from": "10:00",
        "time_to": "18:00",
        "weekdays": [
            "monday"
        ]
    },
)
response.raise_for_status()
data = response.json()

<?php

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api.playground.try.be/shop/bookable-areas/abc123/availability-rules', [
    'headers' => [
        'Authorization' => 'Bearer YOUR_API_KEY',
        'Accept' => 'application/json',
        'Content-Type' => 'application/json',
    ],
    'json' => [
            'is_available' => true,
            'date_from' => '2026-06-01',
            'date_to' => '2026-08-31',
            'time_from' => '10:00',
            'time_to' => '18:00',
            'weekdays' => [
                'monday'
            ]
        ],
]);

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

package main

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

func main() {
	payload, _ := json.Marshal(map[string]interface{}{
		"is_available": true,
		"date_from": "2026-06-01",
		"date_to": "2026-08-31",
		"time_from": "10:00",
		"time_to": "18:00",
		"weekdays": []interface{}{
			"monday",
		},
	})
	req, _ := http.NewRequest("POST", "https://api.playground.try.be/shop/bookable-areas/abc123/availability-rules", 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 `AvailabilityRule`.

{
  "data": {
    "id": "64a9f3b2c3d8e1f4a5b6c7d8",
    "date_from": "2021-02-15T12:00:00+00:00",
    "date_to": "2021-02-15T12:00:00+00:00",
    "is_available": true,
    "max_duration": 1,
    "min_duration": 1,
    "time_from": "11:00",
    "time_to": "17:00",
    "weekdays": [
      "string"
    ]
  }
}

{
  "message": "Unauthenticated"
}

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

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

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

get/shop/bookable-areas/{bookableAreaId}/availability-rules/{availabilityRuleId}

Retrieve a bookable area availability rule

getBookableAreaAvailabilityRule

Returns a single AvailabilityRule belonging to the given BookableArea.

Requires the SETTINGS_MANAGE permission on the area's site.

Path parameters

bookableAreaIdobject-idrequired
The ID of the bookable area.
availabilityRuleIdobject-idrequired
The unique identifier of the availability rule.

Responses

200
A single AvailabilityRule.
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/bookable-areas/abc123/availability-rules/abc123" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json"

const response = await fetch('https://api.playground.try.be/shop/bookable-areas/abc123/availability-rules/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/bookable-areas/abc123/availability-rules/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/bookable-areas/abc123/availability-rules/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/bookable-areas/abc123/availability-rules/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 `AvailabilityRule`.

{
  "data": {
    "id": "64a9f3b2c3d8e1f4a5b6c7d8",
    "date_from": "2021-02-15T12:00:00+00:00",
    "date_to": "2021-02-15T12:00:00+00:00",
    "is_available": true,
    "max_duration": 1,
    "min_duration": 1,
    "time_from": "11:00",
    "time_to": "17:00",
    "weekdays": [
      "string"
    ]
  }
}

{
  "message": "Unauthenticated"
}

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

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

put/shop/bookable-areas/{bookableAreaId}/availability-rules/{availabilityRuleId}

Update a bookable area availability rule

updateBookableAreaAvailabilityRule

Updates an AvailabilityRule on a BookableArea. The server validates the same shape as on create, so is_available is required. Calendar availability is recomputed from the updated rule set.

Requires the SETTINGS_MANAGE permission on the area's site.

Path parameters

bookableAreaIdobject-idrequired
The ID of the bookable area.
availabilityRuleIdobject-idrequired
The unique identifier of the availability rule.

Request body

is_availablebooleanrequired
Whether the window is bookable. false rules override true rules.
date_fromdateoptionalnullable
First date this rule applies (inclusive).
date_todateoptionalnullable
Last date this rule applies (inclusive).
time_fromstringoptionalnullable
Daily start time in HH:MM.
time_tostringoptionalnullable
Daily end time in HH:MM.
weekdaysstring[]optional

Responses

200
A single AvailabilityRule.
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/bookable-areas/abc123/availability-rules/abc123" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json" \
  -H "Content-Type: application/json" \
  -d '{
  "is_available": true,
  "date_from": "2026-06-01",
  "date_to": "2026-08-31",
  "time_from": "10:00",
  "time_to": "18:00",
  "weekdays": [
    "monday"
  ]
}'

const response = await fetch('https://api.playground.try.be/shop/bookable-areas/abc123/availability-rules/abc123', {
  method: 'PUT',
  headers: {
    Authorization: 'Bearer YOUR_API_KEY',
    'Content-Type': 'application/json',
    Accept: 'application/json',
  },
  body: JSON.stringify({
    "is_available": true,
    "date_from": "2026-06-01",
    "date_to": "2026-08-31",
    "time_from": "10:00",
    "time_to": "18:00",
    "weekdays": [
      "monday"
    ]
  }),
})

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/bookable-areas/abc123/availability-rules/abc123",
    headers={
        "Authorization": "Bearer YOUR_API_KEY",
        "Accept": "application/json",
        "Content-Type": "application/json",
    },
    json={
        "is_available": True,
        "date_from": "2026-06-01",
        "date_to": "2026-08-31",
        "time_from": "10:00",
        "time_to": "18:00",
        "weekdays": [
            "monday"
        ]
    },
)
response.raise_for_status()
data = response.json()

<?php

$client = new \GuzzleHttp\Client();

$response = $client->request('PUT', 'https://api.playground.try.be/shop/bookable-areas/abc123/availability-rules/abc123', [
    'headers' => [
        'Authorization' => 'Bearer YOUR_API_KEY',
        'Accept' => 'application/json',
        'Content-Type' => 'application/json',
    ],
    'json' => [
            'is_available' => true,
            'date_from' => '2026-06-01',
            'date_to' => '2026-08-31',
            'time_from' => '10:00',
            'time_to' => '18:00',
            'weekdays' => [
                'monday'
            ]
        ],
]);

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

package main

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

func main() {
	payload, _ := json.Marshal(map[string]interface{}{
		"is_available": true,
		"date_from": "2026-06-01",
		"date_to": "2026-08-31",
		"time_from": "10:00",
		"time_to": "18:00",
		"weekdays": []interface{}{
			"monday",
		},
	})
	req, _ := http.NewRequest("PUT", "https://api.playground.try.be/shop/bookable-areas/abc123/availability-rules/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 `AvailabilityRule`.

{
  "data": {
    "id": "64a9f3b2c3d8e1f4a5b6c7d8",
    "date_from": "2021-02-15T12:00:00+00:00",
    "date_to": "2021-02-15T12:00:00+00:00",
    "is_available": true,
    "max_duration": 1,
    "min_duration": 1,
    "time_from": "11:00",
    "time_to": "17:00",
    "weekdays": [
      "string"
    ]
  }
}

{
  "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/bookable-areas/{bookableAreaId}/availability-rules/{availabilityRuleId}

Delete a bookable area availability rule

deleteBookableAreaAvailabilityRule

Removes an AvailabilityRule from a BookableArea. Calendar availability is recomputed from the remaining rules. Existing bookings are unaffected.

Requires the SETTINGS_MANAGE permission on the area's site.

Path parameters

bookableAreaIdobject-idrequired
The ID of the bookable area.
availabilityRuleIdobject-idrequired
The unique identifier of the availability rule.

Responses

204
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/bookable-areas/abc123/availability-rules/abc123" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json"

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

Availability rule deleted successfully.

// empty response

{
  "message": "Unauthenticated"
}

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

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