Reports · Trybe API

Reports

The Reports group of endpoints provide access to various reports on the Trybe platform.

get/shop/reports/order-items

Queue an export of the order items report

queueOrderItemsReport

This endpoint queues an export of the order items report to be generated asynchronously.

Query parameters

site_iduuidoptional
Restrict the report to order items belonging to the given site. Omit to include items from every site the caller's API key can access; the response groups them under their own site_id field.
order_labelstring[]optionalDeprecated
A comma-separated list of order labels IDs to filter on.
order_label_idsstring[]optional
A comma-separated list of order labels IDs to filter on.
sales_channel_idstring[]optionalDeprecated
A comma-separated list of sales channel IDs to filter on.
sales_channel_idsstring[]optional
A comma-separated list of sales channel IDs to filter on.
offering_idstring[]optionalDeprecated
A comma-separated list of offering IDs to filter on.
offering_idsstring[]optional
A comma-separated list of offering IDs to filter on.
offering_typestring[]optionalDeprecated
A comma-separated list of item types to filter on.
offering_typesstring[]optional
A comma-separated list of item types to filter on.
offering_categorystringoptionalDeprecated
Filter by the offering's category.
offering_category_idsstring[]optional
A comma-separated list of offering category ids to filter on.
statusstringoptionalDeprecated
Filter by the status of the item.
statusesstring[]optional
A comma-separated list of statuses to filter on.
order_statusstring[]optionalDeprecated
A comma-separated list of order statuses to filter on.
order_statusesstring[]optional
A comma-separated list of order statuses to filter on.
revenue_date_fromdateoptional
Filter on items with an order revenue date on or after this date.
revenue_date_todateoptional
Filter on items with an order revenue date on or before this date.
date_fromdate-timeoptional
Filter on items with a start time on or after this date.
date_todate-timeoptional
Filter on items with a start time on or before this date.
order_submitted_at_fromdate-timeoptional
Filter on orders with a submitted date on or after this time.
order_submitted_at_todate-timeoptional
Filter on orders with a submitted date before this time.
item_date_fromdate-timeoptional
Filter on items which are booked in for on or after this date.
item_date_todate-timeoptional
Filter on items which are booked in for before this date.
category_idstring[]optionalDeprecated
A comma-separated list of category IDs to filter on.
category_idsstring[]optional
A comma-separated list of stock category IDs to filter on.
brand_idsstring[]optional
A comma-separated list of stock brand IDs to filter on.
revenue_centresstring[]optional
A comma-separated list of revenue centre names to filter on.
sold_by_idstring[]optionalDeprecated
A comma-separated list of user IDs to filter for items sold by that user.
sold_by_idsstring[]optional
A comma-separated list of user IDs to filter for items sold by that user.
practitioner_idstring[]optionalDeprecated
A comma-separated list of practitioner IDs to filter on.
practitioner_idsstring[]optional
A comma-separated list of practitioner IDs to filter on.
shop_category_idsstring[]optional
A comma-separated list of shop category ids to filter on (includes offering and voucher categories).
room_idstring[]optionalDeprecated
A comma-separated list of room IDs to filter on.
room_idsstring[]optional
A comma-separated list of room IDs to filter on.
zone_idstring[]optionalDeprecated
A comma-separated list of zone IDs to filter on.
zone_idsstring[]optional
A comma-separated list of zone IDs to filter on.

Responses

200
The job was successfully queued
400
The request failed.

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

const response = await fetch('https://api.playground.try.be/shop/reports/order-items/queue', {
  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/reports/order-items/queue",
    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/reports/order-items/queue', [
    '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/reports/order-items/queue", 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 job was successfully queued

{
  "data": {
    "id": "00000000-0000-0000-0000-000000000000",
    "status": "pending",
    "output": {},
    "created_at": "2023-11-07T00:00:00+00:00",
    "updated_at": "2023-11-07T01:00:00+00:00"
  }
}

{
  "message": "string"
}

get/shop/visit-intake-forms-for-orders/queue-pdf

Queue an export of inventory IDs

actionQueueInventoryIdsExport

This endpoint queues an export of the inventory IDs report.

Query parameters

site_iduuidrequired
Filter stock on hand by site.

Responses

200
The job was successfully queued
400
The request failed.

curl "https://api.playground.try.be/inventory/inventory-ids/queue?site_id=00000000-0000-0000-0000-000000000000" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json"

const response = await fetch('https://api.playground.try.be/inventory/inventory-ids/queue?site_id=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/inventory/inventory-ids/queue?site_id=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/inventory/inventory-ids/queue?site_id=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/inventory/inventory-ids/queue?site_id=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)
}

The job was successfully queued

{
  "data": {
    "id": "00000000-0000-0000-0000-000000000000",
    "status": "pending",
    "output": {},
    "created_at": "2023-11-07T00:00:00+00:00",
    "updated_at": "2023-11-07T01:00:00+00:00"
  }
}

{
  "message": "string"
}

get/shop/reports/client-associated-barcodes

Use this endpoint to retrieve a list of ClientAssociatedBarcode resources for reporting purposes. This endpoint supports filtering by various criteria including created date, expiry date, order, customer, source, and payment method.

Query parameters

site_iduuidrequired
Filter the list of ClientAssociatedBarcodes by site
pageintegeroptional
The page to retrieve results from
created_at_fromdate-timeoptional
Filter the list of ClientAssociatedBarcodes by created date (ISO 8601 format)
created_at_todate-timeoptional
Filter the list of ClientAssociatedBarcodes by created date (ISO 8601 format)
expires_at_fromdate-timeoptional
Filter the list of ClientAssociatedBarcodes by expiry date (ISO 8601 format)
expires_at_todate-timeoptional
Filter the list of ClientAssociatedBarcodes by expiry date (ISO 8601 format)
has_orderbooleanoptional
Filter the list of ClientAssociatedBarcodes by whether they have an associated order
has_payment_methodbooleanoptional
Filter the list of ClientAssociatedBarcodes by whether they have an associated payment
sourcestringoptional
Filter the list of ClientAssociatedBarcodes by source

Responses

200
The list of ClientAssociatedBarcode resources was successfully retrieved
401
The user is unauthenticated

curl "https://api.playground.try.be/shop/reports/client-associated-barcodes?site_id=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/reports/client-associated-barcodes?site_id=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/reports/client-associated-barcodes?site_id=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/reports/client-associated-barcodes?site_id=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/reports/client-associated-barcodes?site_id=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)
}

The list of `ClientAssociatedBarcode` resources was successfully retrieved

{
  "data": [
    {
      "id": "00000000-0000-0000-0000-000000000000",
      "customer_id": "00000000-0000-0000-0000-000000000000",
      "customer": {
        "id": "00000000-0000-0000-0000-000000000000",
        "first_name": "Jane",
        "last_name": "Doe",
        "full_name": "Jane Doe",
        "phone": "+447900000000",
        "has_password": true,
        "dob": "2026-01-15",
        "brand_id": "00000000-0000-0000-0000-000000000000",
        "site_id": "00000000-0000-0000-0000-000000000000",
        "stripe_id": "cus_1234567890",
        "express_stripe_id": "cus_1234567890",
        "email": "janedoe@example.com",
        "labels": [
          {
            "id": "00000000-0000-0000-0000-000000000000",
            "value": "VIP",
            "colour": "ff6634"
          }
        ],
        "preferred_locale": "en",
        "locked_at": "2026-01-15T09:30:00+00:00",
        "created_at": "2026-01-15T09:30:00+00:00",
        "updated_at": "2026-01-15T09:30:00+00:00",
        "deleted_at": "2026-01-15T09:30:00+00:00",
        "last_active_at": "2026-01-15T09:30:00+00:00",
        "email_verified_at": "2026-01-15T09:30:00+00:00",
        "last_check_in": {
          "checked_in_at": "2026-01-15T09:30:00+00:00",
          "method": "Scanned"
        },
        "avatar_id": "000000-000000-000000-000000",
        "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"
        },
        "external_ref": "ext-cust-789012"
      },
      "barcode": "string",
      "expires_at": "2026-01-15T09:30:00+00:00",
      "brand_id": "00000000-0000-0000-0000-000000000000",
      "site_id": "00000000-0000-0000-0000-000000000000",
      "organisation_id": "00000000-0000-0000-0000-000000000000",
      "source": "kiosk",
      "order": {
        "id": "64a9f3b2c3d8e1f4a5b6c7d8",
        "applied_promo_code": {
          "id": "64a9f3b2c3d8e1f4a5b6c7d8",
          "applied_at": "2023-11-15T12:00:00+00:00",
          "applied_by": {
            "id": "64a9f3b2c3d8e1f4a5b6c7d8",
            "avatar": {
              "id": "00000000-0000-0000-0000-000000000000"
            },
            "email": "guest@example.com",
            "first_name": "Jane",
            "full_name": "Jane Smith",
            "last_name": "Smith"
          },
          "code": "FIVEOFF",
          "discount_total": 2000,
          "is_discount_applied": true,
          "percentage": 10
        },
        "applied_promo_code_discount_total": 1,
        "applied_promo_code_id": "64a9f3b2c3d8e1f4a5b6c7d8",
        "booking_items": [
          {
            "id": "64a9f3b2c3d8e1f4a5b6c7d8",
            "added_by_customer": false,
            "base_price": 1,
            "booking_reserved_until": "2026-01-15T09:30:00+00:00",
            "booking_summary": {
              "id": "00000000-0000-0000-0000-000000000000"
            },
            "date": "2026-01-15",
            "discount_amount": 1,
            "discounts": [
              null
            ],
            "exclusive_tax_amount": 1,
            "guest": {
              "id": "00000000-0000-0000-0000-000000000000"
            },
            "guests": [
              null
            ],
            "inclusive_tax_amount": 1,
            "is_modifiable": true,
            "item_type": "appointment",
            "net_total": 1,
            "order_discount_amount": 1,
            "price": 1,
            "sold_by": {
              "id": "00000000-0000-0000-0000-000000000000"
            },
            "status": "cancelled",
            "total_cost": 1,
            "type_id": "64a9f3b2c3d8e1f4a5b6c7d8",
            "type_name": "string",
            "type_product_code": "string",
            "created_at": "2025-02-04T12:00:00+01:00",
            "updated_at": "2025-02-04T12:00:00+01:00"
          }
        ],
        "booking_items_end_date": "2026-01-15",
        "booking_items_start_date": "2026-01-15",
        "booking_items_span_multiple_days": false,
        "coupon_codes": [
          {
            "id": "64a9f3b2c3d8e1f4a5b6c7d8",
            "code": "FIVEOFF",
            "customer_credit_id": "00000000-0000-0000-0000-000000000000",
            "description": "Get 10% off all treatments booked in April.",
            "issued_by_id": "64a9f3b2c3d8e1f4a5b6c7d8",
            "issued_by_type": "credit",
            "name": "April special"
          }
        ],
        "currency": "gbp",
        "customer_id": "00000000-0000-0000-0000-000000000000",
        "customer_tax_details": {
          "legal_name": "Jane Jones",
          "tax_id": "GB1234567",
          "address_line_1": "1 Davey Street",
          "address_line_2": "Clapham",
          "city": "London",
          "postcode": "SW4 1AA",
          "country": "United Kingdom"
        },
        "discount_total": 100,
        "discounts": [
          {
            "id": "64a9f3b2c3d8e1f4a5b6c7d8",
            "amount_type": "monetary",
            "applicable_for": "app_and_booking_engine",
            "applied_at": "2026-01-15T09:30:00+00:00",
            "applied_by": {
              "id": "00000000-0000-0000-0000-000000000000"
            },
            "calculated_amount": 150,
            "coupon": {
              "id": "00000000-0000-0000-0000-000000000000"
            },
            "coupon_code_id": "64a9f3b2c3d8e1f4a5b6c7d8",
            "currency": "gbp",
            "discount_amount": 15,
            "discount_type_code": "SUMMER23",
            "reason_code": "general",
            "site_id": "00000000-0000-0000-0000-000000000000"
          }
        ],
        "email": "janedoe@example.com",
        "external_ids": [
          {
            "key": "pms_id",
            "name": "PMS ID",
            "value": "pms_1234"
          }
        ],
        "external_ref": "ABC-123",
        "external_visit_ref": "RES1234",
        "first_name": "Jane",
        "guests": [
          {
            "id": "5dcb47800000000000000000",
            "checked_in_at": "2025-10-01T12:00:00+00:00",
            "checked_out_at": "2025-10-01T16:30:00+00:00",
            "customer_id": "5f8a1b2c-9d3e-4a5b-8c6d-7e8f9a0b1c2d",
            "email": "jane.doe@example.com",
            "first_name": "Jane",
            "intake_form_submission_id": "5dcb47800000000000000010",
            "intake_form_complete": false,
            "is_lead_booker": true,
            "last_name": "Doe",
            "name": "Jane Doe"
          }
        ],
        "intake_form_required": true,
        "intake_form_url": "https://demo.try.be/intake-form",
        "intake_forms_complete": true,
        "integration_config_id": "5f344d756e7f2e7d3f2e4b82",
        "is_customer_required": true,
        "is_locked": false,
        "is_promo_code_discount_applied": true,
        "items": [
          {
            "id": "64a9f3b2c3d8e1f4a5b6c7d8",
            "added_by_customer": false,
            "base_price": 595,
            "basket_id": "64a9f3b2c3d8e1f4a5b6c7d8",
            "booking_summary": {
              "id": "00000000-0000-0000-0000-000000000000"
            },
            "discount_amount": 595,
            "discounts": [
              null
            ],
            "exclusive_tax_amount": 0,
            "guests": [
              null
            ],
            "has_posted": true,
            "inclusive_tax_amount": 49,
            "item_configuration": {
              "id": "00000000-0000-0000-0000-000000000000"
            },
            "last_post_attempt": "2026-01-15T09:30:00+00:00",
            "offering": {
              "id": "00000000-0000-0000-0000-000000000000"
            },
            "option_budgets": [
              null
            ],
            "order_discount_amount": 1,
            "package_items": [
              null
            ],
            "posted_at": "2026-01-15T09:30:00+00:00",
            "price": 595,
            "purchasable_details": {
              "id": "00000000-0000-0000-0000-000000000000"
            },
            "quantity": 1,
            "reserved_until": "2026-01-15T09:30:00+00:00",
            "sold_by": {
              "id": "00000000-0000-0000-0000-000000000000"
            },
            "status": "cancelled",
            "total_cost": 595,
            "created_at": "2025-02-04T12:00:00+01:00",
            "updated_at": "2025-02-04T12:00:00+01:00"
          }
        ],
        "items_status": "confirmed",
        "labels": [
          {
            "id": "64a9f3b2c3d8e1f4a5b6c7d8",
            "color": "#FF0000",
            "name": "VIP",
            "order_id": "64a9f3b2c3d8e1f4a5b6c7d8"
          }
        ],
        "last_name": "Doe",
        "locked_at": "2019-01-15T12:00:00+01:00",
        "net_total": 8000,
        "order_ref": "TRY00",
        "organisation_id": "00000000-0000-0000-0000-000000000000",
        "outstanding_payment_amount": 1,
        "package_items": [
          {
            "id": "64a9f3b2c3d8e1f4a5b6c7d8",
            "added_by_customer": false,
            "base_price": 1,
            "date": "2026-01-15",
            "discount_amount": 1,
            "discounts": [
              null
            ],
            "exclusive_tax_amount": 1,
            "guest": {
              "id": "00000000-0000-0000-0000-000000000000"
            },
            "guests": [
              null
            ],
            "inclusive_tax_amount": 1,
            "integration_booking_engine": "Guestline",
            "is_modifiable": true,
            "item_type": "package",
            "net_total": 1,
            "option_budgets": [
              null
            ],
            "order_discount_amount": 1,
            "package_items": [
              null
            ],
            "price": 1,
            "sold_by": {
              "id": "00000000-0000-0000-0000-000000000000"
            },
            "status": "cancelled",
            "total_cost": 1,
            "type_id": "64a9f3b2c3d8e1f4a5b6c7d8",
            "type_name": "string",
            "type_product_code": "string",
            "created_at": "2025-02-04T12:00:00+01:00",
            "updated_at": "2025-02-04T12:00:00+01:00"
          }
        ],
        "payment_totals": {
          "chargeable": 500,
          "missing": 1000,
          "paid": 750,
          "pending": 250,
          "provided": 1500,
          "unpaid": 1000
        },
        "payments": [
          {
            "id": "64a9f3b2c3d8e1f4a5b6c7d8",
            "amount": 10000,
            "capture_method": "automatic",
            "chargebacks": [
              null
            ],
            "currency": "gbp",
            "details_source": "pay_by_link",
            "failure_reason": "Suspected fraud",
            "order_ref": "EXT-12345",
            "paid_at": "2020-02-24T12:00:00+01:00",
            "payable_id": "64a9f3b2c3d8e1f4a5b6c7d8",
            "payable_type": "string",
            "processor": "stripe",
            "processor_data": {
              "id": "00000000-0000-0000-0000-000000000000"
            },
            "processor_id": "64a9f3b2c3d8e1f4a5b6c7d8",
            "processor_type": "string",
            "refundable_amount": 3500,
            "refunds": [
              null
            ],
            "status": "cancelled",
            "created_at": "2025-02-04T12:00:00+01:00"
          }
        ],
        "phone": "+447727123456",
        "post_to_room_config": {
          "associated_at": "2026-01-15T09:30:00+00:00",
          "processor_data": {
            "G#": 2081111,
            "RN": "9500"
          }
        },
        "promo_code_applied_at": "2026-01-15T09:30:00+00:00",
        "promo_code_applied_by": {
          "id": "64a9f3b2c3d8e1f4a5b6c7d8",
          "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"
          },
          "email": "guest@example.com",
          "first_name": "Jane",
          "full_name": "Jane Smith",
          "last_name": "Smith"
        },
        "purchase_items": [
          {
            "id": "64a9f3b2c3d8e1f4a5b6c7d8",
            "added_by_customer": false,
            "base_price": 1,
            "discount_amount": 1,
            "discounts": [
              null
            ],
            "exclusive_tax_amount": 1,
            "guests": [
              null
            ],
            "inclusive_tax_amount": 1,
            "is_modifiable": true,
            "item_configuration": {
              "id": "00000000-0000-0000-0000-000000000000"
            },
            "item_type": "product",
            "net_total": 1,
            "order_discount_amount": 1,
            "purchasable_details": {
              "id": "00000000-0000-0000-0000-000000000000"
            },
            "quantity": 1,
            "reserved_until": "2026-01-15T09:30:00+00:00",
            "sold_by": {
              "id": "00000000-0000-0000-0000-000000000000"
            },
            "status": "cancelled",
            "total_cost": 1,
            "type_id": "64a9f3b2c3d8e1f4a5b6c7d8",
            "type_name": "string",
            "type_product_code": "string",
            "unit_price": 1,
            "created_at": "2025-02-04T12:00:00+01:00",
            "updated_at": "2025-02-04T12:00:00+01:00"
          }
        ],
        "sales_channel": {
          "id": "64a9f3b2c3d8e1f4a5b6c7d8",
          "name": "Web",
          "organisation_id": "00000000-0000-0000-0000-000000000000"
        },
        "service_charge": {
          "amount": 1000,
          "item_amounts": [
            {
              "id": "00000000-0000-0000-0000-000000000000"
            }
          ],
          "percentage": 10
        },
        "site_id": "00000000-0000-0000-0000-000000000000",
        "special_requests": "I would like the Blue Room please",
        "stage": "not_arrived",
        "status": "submitted",
        "submit_auth_amount": 1,
        "submit_payment_amount": 1,
        "submitted_at": "2020-02-24T12:00:00+01:00",
        "submitted_by": {
          "id": "64a9f3b2c3d8e1f4a5b6c7d8",
          "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"
          },
          "email": "guest@example.com",
          "first_name": "Jane",
          "full_name": "Jane Smith",
          "last_name": "Smith"
        },
        "taxes": [
          {
            "amount": 1290,
            "inclusive": false,
            "name": "VAT",
            "percentage": 20
          }
        ],
        "tip_amount": 1050,
        "tips": [
          {
            "id": "64a9f3b2c3d8e1f4a5b6c7d8",
            "amount": 1050,
            "declined": false,
            "updated_at": "2026-01-15T09:30:00+00:00",
            "can_remove": false
          }
        ],
        "total_cost": 1,
        "total_paid_or_authed": 1,
        "total_tax": 2000,
        "totals": {
          "exclusive_tax": 0,
          "inclusive_tax": 250,
          "order_discount": 11000,
          "subtotal": 12000,
          "subtotal_without_exclusive_tax": 12000,
          "total": 10000
        },
        "visit": {
          "id": "64a9f3b2c3d8e1f4a5b6c7d8",
          "visit_ref": "EXT-12345",
          "visit_type": {
            "id": "64a9f3b2c3d8e1f4a5b6c7d8",
            "name": "Stay"
          },
          "status": "string",
          "arrival_date": "2026-01-15T09:30:00+00:00",
          "departure_date": "2026-01-15T09:30:00+00:00",
          "first_name": "Alex",
          "last_name": "Morgan"
        },
        "voucher_codes": [
          {
            "id": "00000000-0000-0000-0000-000000000000",
            "amount_type": "discount_to_zero",
            "calculated_amount": 1000,
            "code": "ABCDEFGHIJ123",
            "coupon_code_id": "64a9f3b2c3d8e1f4a5b6c7d8",
            "description": "A 30 minute treatment of your choice.",
            "is_redeemed": true,
            "name": "30 min treatment",
            "voucher_type_id": "64a9f3b2c3d8e1f4a5b6c7d8"
          }
        ],
        "created_at": "2020-02-24T12:00:00+01:00",
        "updated_at": "2020-02-24T12:00:00+01:00"
      },
      "payment_method": {
        "id": "00000000-0000-0000-0000-000000000000",
        "payment_method_id": "pm_3K6a0RGysTOePye00nkob5Pi",
        "name": "My debit card",
        "type": "card",
        "status": "revoked",
        "cardholder_name": "Jane Doe",
        "card_brand": "amex",
        "card_country": "gb",
        "card_funding": "credit",
        "card_expiry": "08/22",
        "last_4": "1234",
        "processor": "stripe",
        "created_at": "2025-01-01T00:00:00+00:00",
        "updated_at": "2025-01-01T00:00:00+00:00",
        "revoked_at": "2025-01-01T00:00:00+00:00"
      },
      "created_at": "2026-01-15T09:30:00+00: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"
}

get/shop/reports/client-associated-barcodes/queue

Queue an export of the client associated barcodes report

actionQueueClientAssociatedBarcodesReport

This endpoint queues an export of the client associated barcodes report. The report will be generated asynchronously and delivered via the configured delivery method.

Query parameters

site_iduuidrequired
Filter the list of ClientAssociatedBarcodes by site
pageintegeroptional
The page to retrieve results from
created_at_fromdate-timeoptional
Filter the list of ClientAssociatedBarcodes by created date (ISO 8601 format)
created_at_todate-timeoptional
Filter the list of ClientAssociatedBarcodes by created date (ISO 8601 format)
expires_at_fromdate-timeoptional
Filter the list of ClientAssociatedBarcodes by expiry date (ISO 8601 format)
expires_at_todate-timeoptional
Filter the list of ClientAssociatedBarcodes by expiry date (ISO 8601 format)
has_orderbooleanoptional
Filter the list of ClientAssociatedBarcodes by whether they have an associated order
has_payment_methodbooleanoptional
Filter the list of ClientAssociatedBarcodes by whether they have an associated payment
sourcestringoptional
Filter the list of ClientAssociatedBarcodes by source

Responses

200
The job was successfully queued
400
The request failed.

curl "https://api.playground.try.be/shop/reports/client-associated-barcodes/queue?site_id=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/reports/client-associated-barcodes/queue?site_id=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/reports/client-associated-barcodes/queue?site_id=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/reports/client-associated-barcodes/queue?site_id=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/reports/client-associated-barcodes/queue?site_id=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)
}

The job was successfully queued

{
  "data": {
    "id": "00000000-0000-0000-0000-000000000000",
    "status": "pending",
    "output": {},
    "created_at": "2023-11-07T00:00:00+00:00",
    "updated_at": "2023-11-07T01:00:00+00:00"
  }
}

{
  "message": "string"
}

get/shop/reports/itinerary

Date Itinerary Report Queue

getDateItineraryQueue

This endpoint queues an export of a full day's itinerary for a given date.

Query parameters

datedateoptional
The date to generate the itinerary for
site_iduuidoptional
The ID of the site to generate the itinerary for

Responses

200
The job was successfully queued
401
The user is unauthenticated

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

const response = await fetch('https://api.playground.try.be/shop/reports/itinerary', {
  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/reports/itinerary",
    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/reports/itinerary', [
    '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/reports/itinerary", 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 job was successfully queued

{
  "data": {
    "id": "00000000-0000-0000-0000-000000000000",
    "status": "pending",
    "output": {},
    "created_at": "2023-11-07T00:00:00+00:00",
    "updated_at": "2023-11-07T01:00:00+00:00"
  }
}

{
  "message": "Unauthenticated"
}

get/shop/reports/payouts

List payouts for a site

listPayouts

Use this endpoint to retrieve a list of payouts for a site.

Query parameters

site_iduuidoptional
Filter the list of payouts by site.
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.
statusstringoptional
Filter for payouts with a specific status.
Possible values:not_startedprocessingprocessedfailed
pageintegeroptional
The page to retrieve results from
per_pageintegeroptional
The number of results to return per page

Responses

200
The list of Payout resources was successfully retrieved.
401
The user is unauthenticated

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

const response = await fetch('https://api.playground.try.be/shop/reports/payouts', {
  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/reports/payouts",
    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/reports/payouts', [
    '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/reports/payouts", 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 list of `Payout` resources was successfully retrieved.

{
  "data": [
    {
      "id": "64a9f3b2c3d8e1f4a5b6c7d8",
      "status": "string",
      "payout_date": "2026-01-15",
      "processed_date": "2026-01-15T09:30:00+00:00",
      "num_charges": 1,
      "amount": "string",
      "currency": "GBP"
    }
  ],
  "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"
}

get/shop/reports/practitioner-occupancy

Get practitioner occupancy report

getPractitionerOccupancyReport

Returns a practitioner occupancy report for the given date/time range, showing bookable, blocked, appointment and session minutes per practitioner. The date range must not exceed 60 days. Requires the REPORTS_VIEW permission. When requesting a CSV export via the Accept: text/csv header, requires the REPORTS_DOWNLOAD permission instead.

Query parameters

date_time_fromdate-timerequired
The start of the reporting period as an ISO 8601 date-time string (e.g. 2024-01-01T00:00:00+00:00). The range between date_time_from and date_time_to must not exceed 60 days.
date_time_todate-timerequired
The end of the reporting period as an ISO 8601 date-time string (e.g. 2024-01-31T23:59:59+00:00). Must be after date_time_from. The range between date_time_from and date_time_to must not exceed 60 days.
practitioner_idsstringoptional
A comma-separated string of practitioner IDs to filter the report to specific practitioners.
site_iduuidoptional
The site ID to scope the report to.

Responses

200
Practitioner occupancy report data.
400
The request failed.
403
The authenticated user does not have permission.

curl "https://api.playground.try.be/shop/reports/practitioner-occupancy?date_time_from=2024-01-01T00%3A00%3A00%2B00%3A00&date_time_to=2024-01-31T23%3A59%3A59%2B00%3A00" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json"

const response = await fetch('https://api.playground.try.be/shop/reports/practitioner-occupancy?date_time_from=2024-01-01T00%3A00%3A00%2B00%3A00&date_time_to=2024-01-31T23%3A59%3A59%2B00%3A00', {
  method: 'GET',
  headers: {
    Authorization: 'Bearer YOUR_API_KEY',
    Accept: 'application/json',
  },
})

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

const data = await response.json()

import httpx

response = httpx.get(
    "https://api.playground.try.be/shop/reports/practitioner-occupancy?date_time_from=2024-01-01T00%3A00%3A00%2B00%3A00&date_time_to=2024-01-31T23%3A59%3A59%2B00%3A00",
    headers={
        "Authorization": "Bearer YOUR_API_KEY",
        "Accept": "application/json",
    },
)
response.raise_for_status()
data = response.json()

<?php

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://api.playground.try.be/shop/reports/practitioner-occupancy?date_time_from=2024-01-01T00%3A00%3A00%2B00%3A00&date_time_to=2024-01-31T23%3A59%3A59%2B00%3A00', [
    'headers' => [
        'Authorization' => 'Bearer YOUR_API_KEY',
        'Accept' => 'application/json',
    ],
]);

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

package main

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

func main() {
	req, _ := http.NewRequest("GET", "https://api.playground.try.be/shop/reports/practitioner-occupancy?date_time_from=2024-01-01T00%3A00%3A00%2B00%3A00&date_time_to=2024-01-31T23%3A59%3A59%2B00%3A00", nil)
	req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
	req.Header.Set("Accept", "application/json")
	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()
	var data map[string]interface{}
	json.NewDecoder(resp.Body).Decode(&data)
}

Practitioner occupancy report data.

{
  "data": [
    {
      "practitioner": {
        "id": "5dcb47800000000000000000",
        "name": "Jane Doe"
      },
      "bookable_mins": 2400,
      "blocked_mins": 120,
      "appointment_mins": 1800,
      "session_mins": 300
    }
  ],
  "totals": {
    "bookable_mins": 9600,
    "blocked_mins": 480,
    "appointment_mins": 7200,
    "session_mins": 1200
  }
}

{
  "message": "string"
}

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

get/shop/reports/practitioner-occupancy/queue

Queue practitioner occupancy report export

queuePractitionerOccupancyReport

Queues a practitioner occupancy report for asynchronous CSV export. Returns a queued job resource that can be polled for completion. Requires the REPORTS_DOWNLOAD permission.

Query parameters

date_time_fromdate-timerequired
The start of the reporting period as an ISO 8601 date-time string (e.g. 2024-01-01T00:00:00+00:00). The range between date_time_from and date_time_to must not exceed 60 days.
date_time_todate-timerequired
The end of the reporting period as an ISO 8601 date-time string (e.g. 2024-01-31T23:59:59+00:00). Must be after date_time_from. The range between date_time_from and date_time_to must not exceed 60 days.
practitioner_idsstringoptional
A comma-separated string of practitioner IDs to filter the report to specific practitioners.
site_iduuidoptional
The site ID to scope the report to.

Responses

200
The report has been queued for export.
400
The request failed.
403
The authenticated user does not have permission.

curl "https://api.playground.try.be/shop/reports/practitioner-occupancy/queue?date_time_from=2024-01-01T00%3A00%3A00%2B00%3A00&date_time_to=2024-01-31T23%3A59%3A59%2B00%3A00" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json"

const response = await fetch('https://api.playground.try.be/shop/reports/practitioner-occupancy/queue?date_time_from=2024-01-01T00%3A00%3A00%2B00%3A00&date_time_to=2024-01-31T23%3A59%3A59%2B00%3A00', {
  method: 'GET',
  headers: {
    Authorization: 'Bearer YOUR_API_KEY',
    Accept: 'application/json',
  },
})

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

const data = await response.json()

import httpx

response = httpx.get(
    "https://api.playground.try.be/shop/reports/practitioner-occupancy/queue?date_time_from=2024-01-01T00%3A00%3A00%2B00%3A00&date_time_to=2024-01-31T23%3A59%3A59%2B00%3A00",
    headers={
        "Authorization": "Bearer YOUR_API_KEY",
        "Accept": "application/json",
    },
)
response.raise_for_status()
data = response.json()

<?php

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://api.playground.try.be/shop/reports/practitioner-occupancy/queue?date_time_from=2024-01-01T00%3A00%3A00%2B00%3A00&date_time_to=2024-01-31T23%3A59%3A59%2B00%3A00', [
    'headers' => [
        'Authorization' => 'Bearer YOUR_API_KEY',
        'Accept' => 'application/json',
    ],
]);

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

package main

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

func main() {
	req, _ := http.NewRequest("GET", "https://api.playground.try.be/shop/reports/practitioner-occupancy/queue?date_time_from=2024-01-01T00%3A00%3A00%2B00%3A00&date_time_to=2024-01-31T23%3A59%3A59%2B00%3A00", nil)
	req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
	req.Header.Set("Accept", "application/json")
	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()
	var data map[string]interface{}
	json.NewDecoder(resp.Body).Decode(&data)
}

The report has been queued for export.

{
  "data": {
    "id": "00000000-0000-0000-0000-000000000000",
    "status": "pending",
    "output": {},
    "created_at": "2023-11-07T00:00:00+00:00",
    "updated_at": "2023-11-07T01:00:00+00:00"
  }
}

{
  "message": "string"
}

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

get/shop/reports/practitioner-occupancy-by-date

Get practitioner occupancy report by date

getPractitionerOccupancyByDateReport

Returns a practitioner occupancy report for the given date/time range, showing bookable, blocked, appointment and session minutes per practitioner per day. The date range must not exceed 60 days. Requires the REPORTS_VIEW permission. When requesting a CSV export via the Accept: text/csv header, requires the REPORTS_DOWNLOAD permission instead.

Query parameters

date_time_fromdate-timeoptional
The start of the reporting period as an ISO 8601 date-time string (e.g. 2024-01-01T00:00:00+00:00). Required if date_from is not provided. The range between date_time_from and date_time_to must not exceed 60 days.
date_time_todate-timeoptional
The end of the reporting period as an ISO 8601 date-time string (e.g. 2024-01-31T23:59:59+00:00). Must be after date_time_from. Required if date_to is not provided. The range between date_time_from and date_time_to must not exceed 60 days.
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.
practitioner_idsstringoptional
A comma-separated string of practitioner IDs to filter the report to specific practitioners.
site_iduuidoptional
The site ID to scope the report to.
zone_idstringoptional
A comma-separated string of zone IDs to filter by.

Responses

200
Practitioner occupancy by date report data.
400
The request failed.
403
The authenticated user does not have permission.

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

const response = await fetch('https://api.playground.try.be/shop/reports/practitioner-occupancy-by-date', {
  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/reports/practitioner-occupancy-by-date",
    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/reports/practitioner-occupancy-by-date', [
    '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/reports/practitioner-occupancy-by-date", 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 occupancy by date report data.

{
  "data": [
    {
      "date": "2024-01-15",
      "practitioner": {
        "id": "5dcb47800000000000000000",
        "name": "Jane Doe"
      },
      "bookable_mins": 480,
      "blocked_mins": 60,
      "appointment_mins": 360,
      "session_mins": 60
    }
  ],
  "totals": {
    "bookable_mins": 9600,
    "blocked_mins": 480,
    "appointment_mins": 7200,
    "session_mins": 1200
  }
}

{
  "message": "string"
}

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

get/shop/reports/practitioner-occupancy-by-date/queue

Queue practitioner occupancy by date report export

queuePractitionerOccupancyByDateReport

Queues a practitioner occupancy by date report for asynchronous CSV export. Returns a queued job resource that can be polled for completion. Requires the REPORTS_DOWNLOAD permission.

Query parameters

date_time_fromdate-timeoptional
The start of the reporting period as an ISO 8601 date-time string (e.g. 2024-01-01T00:00:00+00:00). Required if date_from is not provided. The range between date_time_from and date_time_to must not exceed 60 days.
date_time_todate-timeoptional
The end of the reporting period as an ISO 8601 date-time string (e.g. 2024-01-31T23:59:59+00:00). Must be after date_time_from. Required if date_to is not provided. The range between date_time_from and date_time_to must not exceed 60 days.
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.
practitioner_idsstringoptional
A comma-separated string of practitioner IDs to filter the report to specific practitioners.
site_iduuidoptional
The site ID to scope the report to.
zone_idstringoptional
A comma-separated string of zone IDs to filter by.

Responses

200
The report has been queued for export.
400
The request failed.
403
The authenticated user does not have permission.

curl "https://api.playground.try.be/shop/reports/practitioner-occupancy-by-date/queue" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json"

const response = await fetch('https://api.playground.try.be/shop/reports/practitioner-occupancy-by-date/queue', {
  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/reports/practitioner-occupancy-by-date/queue",
    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/reports/practitioner-occupancy-by-date/queue', [
    '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/reports/practitioner-occupancy-by-date/queue", 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 report has been queued for export.

{
  "data": {
    "id": "00000000-0000-0000-0000-000000000000",
    "status": "pending",
    "output": {},
    "created_at": "2023-11-07T00:00:00+00:00",
    "updated_at": "2023-11-07T01:00:00+00:00"
  }
}

{
  "message": "string"
}

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

get/shop/reports/service-charge-items

List service charge items

listServiceChargeItems

Use this endpoint to retrieve a paginated list of basket items with their service charge amounts.

Query parameters

site_iduuidoptional
Filter the list of items by site.
pageintegeroptional
The page to retrieve results from
offering_typestring[]optional
Filter by the offering type.
offering_idstring[]optional
Filter by the offering ID.
offering_categorystringoptional
Filter by the offering's category.
sold_by_idstring[]optional
Filter by the ID of the user who sold the item.
order_statusstringoptional
Filter by the status of the order.
statusstringoptional
Filter by the status of the item.
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.
revenue_date_fromdateoptional
Filter to items with an order revenue date on or after this date.
revenue_date_todateoptional
Filter to items with an order revenue date on or before this date.
order_submitted_at_fromdateoptional
Filter to items in orders submitted on or before this date.
order_submitted_at_todateoptional
Filter to items in orders submitted on or after this date.
order_labelstring[]optional
Filter to items in orders with these labels.
item_date_fromdateoptional
Filter to items with an 'item date' (based on the start time if available) on or after this date.
item_date_todateoptional
Filter to items with an 'item date' (based on the start time if available) on or before this date.
practitioner_idstring[]optional
Filter to items assigned to these practitioners.
room_idstring[]optional
Filter to items assigned to these rooms.
zone_idstring[]optional
Filter to items assigned to resources in these zones.

Responses

200
The list of items was successfully retrieved
401
The user is unauthenticated

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

const response = await fetch('https://api.playground.try.be/shop/reports/service-charge-items', {
  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/reports/service-charge-items",
    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/reports/service-charge-items', [
    '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/reports/service-charge-items", 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 list of items was successfully retrieved

{
  "data": [
    {
      "id": "64a9f3b2c3d8e1f4a5b6c7d8",
      "basket_id": "64a9f3b2c3d8e1f4a5b6c7d8",
      "order_ref": "TRY03",
      "order_status": "settled",
      "revenue_date": "2026-01-15",
      "item_date": "2026-01-15",
      "quantity": 1,
      "offering_id": "64a9f3b2c3d8e1f4a5b6c7d8",
      "offering_type": "appointment",
      "offering_name": "60 Minute Massage",
      "total_cost": 15000,
      "net_total": 12000,
      "service_charge": 1000,
      "sold_by": {
        "id": "00000000-0000-0000-0000-000000000000",
        "name": "Alex Morgan",
        "type": "practitioner"
      },
      "practitioner": {
        "id": "5dcb47800000000000000000",
        "name": "Jane Doe"
      },
      "start_time": "2026-01-15T09:30:00+00:00",
      "sales_channel": "Website",
      "payment_methods": "Card, Cash",
      "created_at": "2026-01-15T09:30:00+00: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"
  },
  "totals": {
    "service_charge_total": 760,
    "total_unique_orders": 2,
    "total_items": 5
  }
}

{
  "message": "Unauthenticated"
}

get/shop/reports/service-charge-items/queue

Queue an export of the service charge items report

actionQueueServiceChargeItemsReport

This endpoint queues an export of the service charge items report.

Query parameters

site_iduuidoptional
Filter the list of items by site.
offering_typestring[]optional
Filter by the offering type.
offering_idstring[]optional
Filter by the offering ID.
offering_categorystringoptional
Filter by the offering's category.
sold_by_idstring[]optional
Filter by the ID of the user who sold the item.
order_statusstringoptional
Filter by the status of the order.
statusstringoptional
Filter by the status of the item.
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.
revenue_date_fromdateoptional
Filter to items with an order revenue date on or after this date.
revenue_date_todateoptional
Filter to items with an order revenue date on or before this date.
order_submitted_at_fromdateoptional
Filter to items in orders submitted on or before this date.
order_submitted_at_todateoptional
Filter to items in orders submitted on or after this date.
order_labelstring[]optional
Filter to items in orders with these labels.
item_date_fromdateoptional
Filter to items with an 'item date' (based on the start time if available) on or after this date.
item_date_todateoptional
Filter to items with an 'item date' (based on the start time if available) on or before this date.
practitioner_idstring[]optional
Filter to items assigned to these practitioners.
room_idstring[]optional
Filter to items assigned to these rooms.
zone_idstring[]optional
Filter to items assigned to resources in these zones.

Responses

200
The job was successfully queued
400
The request failed.

curl "https://api.playground.try.be/shop/reports/service-charge-items/queue" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json"

const response = await fetch('https://api.playground.try.be/shop/reports/service-charge-items/queue', {
  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/reports/service-charge-items/queue",
    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/reports/service-charge-items/queue', [
    '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/reports/service-charge-items/queue", 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 job was successfully queued

{
  "data": {
    "id": "00000000-0000-0000-0000-000000000000",
    "status": "pending",
    "output": {},
    "created_at": "2023-11-07T00:00:00+00:00",
    "updated_at": "2023-11-07T01:00:00+00:00"
  }
}

{
  "message": "string"
}

get/shop/reports/tips

List tip items

listTipItems

Use this endpoint to retrieve a paginated list of items that have tip amounts associated with them.

Query parameters

site_iduuidoptional
Filter the list of baskets by site.
pageintegeroptional
The page to retrieve results from
revenue_date_fromdateoptional
Filter to baskets with a revenue date on or after this date.
revenue_date_todateoptional
Filter to baskets with a revenue date on or before this date.
submitted_at_fromdateoptional
Filter to baskets submitted on or after this date.
submitted_at_todateoptional
Filter to baskets submitted on or before this date.

Responses

200
The list of items was successfully retrieved
401
The user is unauthenticated

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

const response = await fetch('https://api.playground.try.be/shop/reports/tips', {
  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/reports/tips",
    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/reports/tips', [
    '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/reports/tips", 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 list of items was successfully retrieved

{
  "data": [
    {
      "id": "64a9f3b2c3d8e1f4a5b6c7d8",
      "basket_id": "64a9f3b2c3d8e1f4a5b6c7d8",
      "order_ref": "TRY03",
      "order_status": "settled",
      "order_date": "2026-01-15T09:30:00+00:00",
      "revenue_date": "2026-01-15",
      "total_cost": 15000,
      "net_total": 12000,
      "tip_amount": 2500,
      "gross_tip_amount": 3000,
      "tip_breakdown": [
        {
          "tip_item_id": "a0f41964-78e1-474c-9fff-44ebaad9a6d1",
          "basket_item_id": "697b8493694753489003695e",
          "amount": 1389,
          "gross_amount": 1667,
          "allocation_method": "direct allocation (package ratio 16.67%)",
          "offering_name": "Consultation with Dr. Smith"
        }
      ],
      "practitioners": [
        {
          "id": "64a9f3b2c3d8e1f4a5b6c7d8",
          "name": "Jasmine"
        }
      ],
      "payment_methods": "Manual (Cash)"
    }
  ],
  "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"
  },
  "totals": {
    "total_tip_items": 2500,
    "total_unique_orders": 10,
    "tip_total": 5,
    "gross_tip_amount": 6000
  }
}

{
  "message": "Unauthenticated"
}

get/shop/reports/tips/queue

Queue an export of the tip report

actionQueueTipReport

This endpoint queues an export of the tip report.

Query parameters

site_iduuidoptional
Filter the list of baskets by site.
revenue_date_fromdateoptional
Filter to baskets with a revenue date on or after this date.
revenue_date_todateoptional
Filter to baskets with a revenue date on or before this date.
submitted_at_fromdateoptional
Filter to baskets submitted on or after this date.
submitted_at_todateoptional
Filter to baskets submitted on or before this date.

Responses

200
The job was successfully queued
400
The request failed.

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

const response = await fetch('https://api.playground.try.be/shop/reports/tips/queue', {
  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/reports/tips/queue",
    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/reports/tips/queue', [
    '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/reports/tips/queue", 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 job was successfully queued

{
  "data": {
    "id": "00000000-0000-0000-0000-000000000000",
    "status": "pending",
    "output": {},
    "created_at": "2023-11-07T00:00:00+00:00",
    "updated_at": "2023-11-07T01:00:00+00:00"
  }
}

{
  "message": "string"
}

get/shop/reports/sessions

List appointment enquiries

listReportSessions

Use this endpoint to retrieve a list of Sessions.

Query parameters

site_iduuidrequired
Filter the list of sessions by site.
pageintegeroptional
The page to retrieve results from
idstring[]optional
Include only sessions with this ID.
datedateoptional
Include sessions on this date.
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.
start_time_fromdate-timeoptional
Include sessions starting on or after this date.
start_time_todate-timeoptional
Include sessions starting before this date.
session_type_idmongo-idoptional
Include sessions of this type.
recurrence_group_idmongo-idoptional
Include sessions with this recurrence group ("session time").
room_idmongo-idoptional
Include sessions taking place in this room.
practitioner_idmongo-idoptional
Include sessions carried out by this practitioner.
zone_idmongo-idoptional
Include sessions taking place in this zone.
include_cancelledbooleanoptional
Include cancelled sessions.
cancelledbooleanoptional
Only return cancelled sessions.
include_bookingsbooleanoptional
Include bookings in the response.

Responses

200
The list of Session resources was successfully retrieved.
401
The user is unauthenticated

curl "https://api.playground.try.be/shop/reports/sessions?site_id=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/reports/sessions?site_id=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/reports/sessions?site_id=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/reports/sessions?site_id=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/reports/sessions?site_id=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)
}

The list of `Session` resources was successfully retrieved.

{
  "data": [
    {
      "id": "64a9f3b2c3d8e1f4a5b6c7d8",
      "session_type_id": "64a9f3b2c3d8e1f4a5b6c7d8",
      "session_type_name": "string",
      "practitioner_id": "64a9f3b2c3d8e1f4a5b6c7d8",
      "practitioner": {
        "id": "5dcb47800000000000000000",
        "name": "Jane Doe"
      },
      "room_id": "64a9f3b2c3d8e1f4a5b6c7d8",
      "room": {
        "id": "5dcb47800000000000000000",
        "capacity": 1,
        "name": "Alex Morgan"
      },
      "start_time": "2026-01-15T09:30:00+00:00",
      "end_time": "2026-01-15T09:30:00+00:00",
      "duration": 1,
      "capacity": 1,
      "remaining_capacity": 1,
      "max_baskets": 1,
      "waitlist_enabled": false,
      "num_waitlisted": 1,
      "price": 1,
      "currency": "GBP",
      "created_at": "2026-01-15T09:30:00+00:00",
      "updated_at": "2026-01-15T09:30:00+00:00",
      "deleted_at": "2026-01-15T09:30:00+00:00",
      "site_id": "00000000-0000-0000-0000-000000000000"
    }
  ],
  "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"
  },
  "totals": {
    "capacity": 1,
    "remaining_capacity": 1
  }
}

{
  "message": "Unauthenticated"
}

get/shop/reports/sessions/queue

Queue an export of the sessions list

actionQueueSessionListReport

This endpoint queues an export of the sessions list.

Query parameters

site_iduuidrequired
Filter the list of sessions by site.
datedateoptional
Include sessions on this date.
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.
start_time_fromdate-timeoptional
Include sessions starting on or after this date.
start_time_todate-timeoptional
Include sessions starting before this date.
session_type_idmongo-idoptional
Include sessions of this type.
recurrence_group_idmongo-idoptional
Include sessions with this recurrence group ("session time").
room_idmongo-idoptional
Include sessions taking place in this room.
practitioner_idmongo-idoptional
Include sessions carried out by this practitioner.
zone_idmongo-idoptional
Include sessions taking place in this zone.
include_cancelledbooleanoptional
Include cancelled sessions.
cancelledbooleanoptional
Only return cancelled sessions.

Responses

200
The job was successfully queued
400
The request failed.

curl "https://api.playground.try.be/shop/reports/sessions/queue?site_id=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/reports/sessions/queue?site_id=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/reports/sessions/queue?site_id=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/reports/sessions/queue?site_id=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/reports/sessions/queue?site_id=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)
}

The job was successfully queued

{
  "data": {
    "id": "00000000-0000-0000-0000-000000000000",
    "status": "pending",
    "output": {},
    "created_at": "2023-11-07T00:00:00+00:00",
    "updated_at": "2023-11-07T01:00:00+00:00"
  }
}

{
  "message": "string"
}

get/shop/reports/projected-membership-revenue

List projected revenues for memberships

listProjectedMembershipRevenue

Use this endpoint to retrieve the projected revenue from Memberships at a given date

Query parameters

site_iduuidrequired
Filter the projected membership revenue report by site
pageintegeroptional
The page to retrieve results from
datedaterequired
The date to get the projected membership revenue report for
membership_type_idsstring[]optional
Filter the projected membership revenue report by membership type
billing_frequencystring[]optional
Filter the projected membership revenue report by billing frequency
manual_paymentsbooleanoptional
Filter the projected membership revenue report by manual payments

Responses

200
The list of ProjectedMembershipRevenue resources was successfully retrieved.
401
The user is unauthenticated

curl "https://api.playground.try.be/shop/reports/projected-membership-revenue?site_id=00000000-0000-0000-0000-000000000000&date=2023-05-05" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json"

const response = await fetch('https://api.playground.try.be/shop/reports/projected-membership-revenue?site_id=00000000-0000-0000-0000-000000000000&date=2023-05-05', {
  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/reports/projected-membership-revenue?site_id=00000000-0000-0000-0000-000000000000&date=2023-05-05",
    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/reports/projected-membership-revenue?site_id=00000000-0000-0000-0000-000000000000&date=2023-05-05', [
    '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/reports/projected-membership-revenue?site_id=00000000-0000-0000-0000-000000000000&date=2023-05-05", 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 list of `ProjectedMembershipRevenue` resources was successfully retrieved.

{
  "data": [
    {
      "id": "00000000-0000-0000-0000-000000000000",
      "membership_number": "00000014",
      "lead_member": {
        "id": "64a9f3b2c3d8e1f4a5b6c7d8",
        "full_name": "Alex Morgan",
        "email": "guest@example.com",
        "phone": "+447700900000",
        "labels": [
          {
            "id": "00000000-0000-0000-0000-000000000000",
            "value": "VIP",
            "colour": "ff6634"
          }
        ]
      },
      "start_date": "string",
      "end_date": "string",
      "membership_type": {
        "id": "64a9f3b2c3d8e1f4a5b6c7d8",
        "name": "Alex Morgan"
      },
      "membership_rate": {
        "id": "64a9f3b2c3d8e1f4a5b6c7d8",
        "name": "Alex Morgan"
      },
      "status": "active",
      "gross_amount": 1,
      "net_amount": 1,
      "duration_days": 1,
      "elapsed_days": 1,
      "remaining_days": 1,
      "gross_remaining_balance": 1,
      "net_remaining_balance": 1
    }
  ],
  "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"
}

get/shop/reports/projected-membership-revenue/queue

Queue an export of the projected membership revenue report

actionQueueProjectedMembershipRevenueReport

This endpoint queues an export of the projected membership revenue report.

Query parameters

site_iduuidrequired
Filter the projected membership revenue report by site
datedaterequired
The date to get the projected membership revenue report for
membership_type_idsstring[]optional
Filter the projected membership revenue report by membership type
billing_frequencystring[]optional
Filter the projected membership revenue report by billing frequency
manual_paymentsbooleanoptional
Filter the projected membership revenue report by manual payments

Responses

200
The job was successfully queued
400
The request failed.

curl "https://api.playground.try.be/shop/reports/projected-membership-revenue/queue?site_id=00000000-0000-0000-0000-000000000000&date=2023-05-05" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json"

const response = await fetch('https://api.playground.try.be/shop/reports/projected-membership-revenue/queue?site_id=00000000-0000-0000-0000-000000000000&date=2023-05-05', {
  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/reports/projected-membership-revenue/queue?site_id=00000000-0000-0000-0000-000000000000&date=2023-05-05",
    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/reports/projected-membership-revenue/queue?site_id=00000000-0000-0000-0000-000000000000&date=2023-05-05', [
    '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/reports/projected-membership-revenue/queue?site_id=00000000-0000-0000-0000-000000000000&date=2023-05-05", 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 job was successfully queued

{
  "data": {
    "id": "00000000-0000-0000-0000-000000000000",
    "status": "pending",
    "output": {},
    "created_at": "2023-11-07T00:00:00+00:00",
    "updated_at": "2023-11-07T01:00:00+00:00"
  }
}

{
  "message": "string"
}

get/shop/reports/projected-membership-revenue-by-month

List projected revenues by month for memberships

listProjectedMembershipRevenueByMonth

Use this endpoint to retrieve the projected revenue from Memberships at a given date for the following 12 calendar months

Query parameters

site_iduuidrequired
Filter the projected membership revenue by month report by site
pageintegeroptional
The page to retrieve results from
datedaterequired
The date to get the projected membership revenue by month report for
membership_type_idsstring[]optional
Filter the projected membership revenue by month report by membership type
billing_frequencystring[]optional
Filter the projected membership revenue by month report by billing frequency
manual_paymentsbooleanoptional
Filter the projected membership revenue by month report by manual payments

Responses

200
The list of ProjectedMembershipRevenueByMonth resources was successfully retrieved.
401
The user is unauthenticated

curl "https://api.playground.try.be/shop/reports/projected-membership-revenue-by-month?site_id=00000000-0000-0000-0000-000000000000&date=2023-05-05" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json"

const response = await fetch('https://api.playground.try.be/shop/reports/projected-membership-revenue-by-month?site_id=00000000-0000-0000-0000-000000000000&date=2023-05-05', {
  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/reports/projected-membership-revenue-by-month?site_id=00000000-0000-0000-0000-000000000000&date=2023-05-05",
    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/reports/projected-membership-revenue-by-month?site_id=00000000-0000-0000-0000-000000000000&date=2023-05-05', [
    '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/reports/projected-membership-revenue-by-month?site_id=00000000-0000-0000-0000-000000000000&date=2023-05-05", 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 list of `ProjectedMembershipRevenueByMonth` resources was successfully retrieved.

{
  "data": [
    {
      "id": "00000000-0000-0000-0000-000000000000",
      "membership_number": "00000014",
      "lead_member": {
        "id": "64a9f3b2c3d8e1f4a5b6c7d8",
        "full_name": "Alex Morgan",
        "email": "guest@example.com",
        "phone": "+447700900000",
        "labels": [
          {
            "id": "00000000-0000-0000-0000-000000000000",
            "value": "VIP",
            "colour": "ff6634"
          }
        ]
      },
      "membership_type": {
        "id": "64a9f3b2c3d8e1f4a5b6c7d8",
        "name": "Alex Morgan"
      },
      "membership_rate": {
        "id": "64a9f3b2c3d8e1f4a5b6c7d8",
        "name": "Alex Morgan"
      },
      "status": "active",
      "remaining_days": 1,
      "gross_remaining_balance": 1,
      "net_remaining_balance": 1,
      "monthly_revenues": [
        {
          "month": "2026-01-15",
          "gross_amount": 1,
          "net_amount": 1,
          "days": 1
        }
      ]
    }
  ],
  "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"
}

get/shop/reports/projected-membership-revenue-by-month/queue

Queue an export of the projected membership revenue by month report

actionQueueProjectedMembershipRevenueByMonthReport

This endpoint queues an export of the projected membership revenue by month report.

Query parameters

site_iduuidrequired
Filter the projected membership revenue by month report by site
datedaterequired
The date to get the projected membership revenue by month report for
membership_type_idsstring[]optional
Filter the projected membership revenue by month report by membership type
billing_frequencystring[]optional
Filter the projected membership revenue by month report by billing frequency
manual_paymentsbooleanoptional
Filter the projected membership revenue by month report by manual payments

Responses

200
The job was successfully queued
400
The request failed.

curl "https://api.playground.try.be/shop/reports/projected-membership-revenue-by-month/queue?site_id=00000000-0000-0000-0000-000000000000&date=2023-05-05" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json"

const response = await fetch('https://api.playground.try.be/shop/reports/projected-membership-revenue-by-month/queue?site_id=00000000-0000-0000-0000-000000000000&date=2023-05-05', {
  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/reports/projected-membership-revenue-by-month/queue?site_id=00000000-0000-0000-0000-000000000000&date=2023-05-05",
    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/reports/projected-membership-revenue-by-month/queue?site_id=00000000-0000-0000-0000-000000000000&date=2023-05-05', [
    '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/reports/projected-membership-revenue-by-month/queue?site_id=00000000-0000-0000-0000-000000000000&date=2023-05-05", 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 job was successfully queued

{
  "data": {
    "id": "00000000-0000-0000-0000-000000000000",
    "status": "pending",
    "output": {},
    "created_at": "2023-11-07T00:00:00+00:00",
    "updated_at": "2023-11-07T01:00:00+00:00"
  }
}

{
  "message": "string"
}

get/shop/reports/orders-sheet/queue

Queue an export of the orders sheet

actionQueueOrdersSheet

Queue a request to export the orders sheet

Query parameters

site_idstringoptional
Filter orders by the site they belong to
querystringoptional
The query to filter orders on.
item_datedateoptional
Filter on orders with items on this date.

Responses

200
The job was successfully queued
401
The user is unauthenticated

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

const response = await fetch('https://api.playground.try.be/shop/reports/orders-sheet/queue', {
  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/reports/orders-sheet/queue",
    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/reports/orders-sheet/queue', [
    '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/reports/orders-sheet/queue", 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 job was successfully queued

{
  "data": {
    "id": "00000000-0000-0000-0000-000000000000",
    "status": "pending",
    "output": {},
    "created_at": "2023-11-07T00:00:00+00:00",
    "updated_at": "2023-11-07T01:00:00+00:00"
  }
}

{
  "message": "Unauthenticated"
}

get/shop/reports/membership-credits

List membership credits

listMembershipCredits

Use this endpoint to retrieve a paginated list of membership credits.

Query parameters

site_iduuidoptional
Filter the list of baskets by site.
pageintegeroptional
The page to retrieve results from

Responses

200
The list of items was successfully retrieved
401
The user is unauthenticated

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

const response = await fetch('https://api.playground.try.be/shop/reports/membership-credits', {
  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/reports/membership-credits",
    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/reports/membership-credits', [
    '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/reports/membership-credits", 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 list of items was successfully retrieved

{
  "data": [
    {
      "id": "00000000-0000-0000-0000-000000000000",
      "membership_number": "000047569",
      "customer_id": "00000000-0000-0000-0000-000000000000",
      "first_name": "John",
      "last_name": "Doe",
      "email": "guest@example.com",
      "total_credits": 15,
      "multi_use_credits": 12
    }
  ],
  "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"
  },
  "totals": {
    "total_memberships": 2500,
    "total_credits": 10,
    "total_multi_use_credits": 5
  }
}

{
  "message": "Unauthenticated"
}

get/shop/reports/membership-credits/queue

Queue an export of the membership credit report

actionQueueMembershipCreditsReport

This endpoint queues an export of the membership credit report.

Query parameters

site_iduuidoptional
Filter the list of baskets by site.

Responses

200
The job was successfully queued
400
The request failed.

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

const response = await fetch('https://api.playground.try.be/shop/reports/membership-credits/queue', {
  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/reports/membership-credits/queue",
    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/reports/membership-credits/queue', [
    '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/reports/membership-credits/queue", 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 job was successfully queued

{
  "data": {
    "id": "00000000-0000-0000-0000-000000000000",
    "status": "pending",
    "output": {},
    "created_at": "2023-11-07T00:00:00+00:00",
    "updated_at": "2023-11-07T01:00:00+00:00"
  }
}

{
  "message": "string"
}

get/shop/reports/membership-credit-usage

List membership credit usage

listMembershipCreditUsage

Use this endpoint to retrieve a paginated list of individual membership credit records, including their current status (redeemable, redeemed, revoked, or expired), the associated customer and membership details, and issuance/expiry dates. Unlike the membership credits summary report, this report returns one row per credit rather than aggregating by membership.

Query parameters

site_iduuidoptional
Restrict the report to membership credits associated with the given site. Omit to include credits across every site the caller's API key can access; the response groups them under their own site_id field.
statusoptional
Filter credits by their computed status. Supports a single value or an array of values.
membership_type_iduuidoptional
Filter credits by the membership type.
membership_statusstringoptional
Filter credits by the current status of the associated membership.
Possible values:activeinactiveexpiredupcomingneeds_attentionreserved
multi_usebooleanoptional
Filter credits by whether they are multi-use.
issued_at_fromdateoptional
Filter credits issued on or after this date. The date is interpreted in the site's local timezone.
issued_at_todateoptional
Filter credits issued on or before this date. The date is interpreted in the site's local timezone.
sortstringoptional
The field to sort the results by.
sort_directionstringoptional
The direction to sort the results in.
Possible values:ascdesc
pageintegeroptional
The page to retrieve results from
per_pageintegeroptional
The number of results to return per page

Responses

200
The list of items was successfully retrieved
401
The user is unauthenticated

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

const response = await fetch('https://api.playground.try.be/shop/reports/membership-credit-usage', {
  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/reports/membership-credit-usage",
    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/reports/membership-credit-usage', [
    '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/reports/membership-credit-usage", 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 list of items was successfully retrieved

{
  "data": [
    {
      "id": "00000000-0000-0000-0000-000000000000",
      "coupon": {
        "name": "Spa Day Pass",
        "description": "Free-form text from the resource.",
        "code": "string"
      },
      "customer_id": "00000000-0000-0000-0000-000000000000",
      "first_name": "John",
      "last_name": "Doe",
      "email": "guest@example.com",
      "membership": {
        "id": "00000000-0000-0000-0000-000000000000",
        "number": "47569",
        "type_name": "Gold Membership",
        "status": "active"
      },
      "multi_use": false,
      "status": "redeemable",
      "issued_at": "2026-01-15T09:30:00+00:00",
      "expires_at": "2026-01-15T09:30:00+00:00",
      "redeemed_at": "2026-01-15T09:30:00+00:00",
      "revoked_at": "2026-01-15T09:30:00+00: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"
  },
  "totals": {
    "total_credits": 150,
    "total_redeemed": 45,
    "total_revoked": 10,
    "total_expired": 20,
    "total_redeemable": 75,
    "total_multi_use": 30
  }
}

{
  "message": "Unauthenticated"
}

get/shop/reports/membership-credit-usage/queue

Queue an export of the membership credit usage report

actionQueueMembershipCreditUsageReport

This endpoint queues an export of the membership credit usage report.

Query parameters

site_iduuidoptional
Restrict the report to membership credits associated with the given site. Omit to include credits across every site the caller's API key can access; the response groups them under their own site_id field.
statusoptional
Filter credits by their computed status. Supports a single value or an array of values.
membership_type_iduuidoptional
Filter credits by the membership type.
membership_statusstringoptional
Filter credits by the current status of the associated membership.
Possible values:activeinactiveexpiredupcomingneeds_attentionreserved
multi_usebooleanoptional
Filter credits by whether they are multi-use.
issued_at_fromdateoptional
Filter credits issued on or after this date. The date is interpreted in the site's local timezone.
issued_at_todateoptional
Filter credits issued on or before this date. The date is interpreted in the site's local timezone.

Responses

200
The job was successfully queued
400
The request failed.

curl "https://api.playground.try.be/shop/reports/membership-credit-usage/queue" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json"

const response = await fetch('https://api.playground.try.be/shop/reports/membership-credit-usage/queue', {
  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/reports/membership-credit-usage/queue",
    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/reports/membership-credit-usage/queue', [
    '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/reports/membership-credit-usage/queue", 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 job was successfully queued

{
  "data": {
    "id": "00000000-0000-0000-0000-000000000000",
    "status": "pending",
    "output": {},
    "created_at": "2023-11-07T00:00:00+00:00",
    "updated_at": "2023-11-07T01:00:00+00:00"
  }
}

{
  "message": "string"
}

get/shop/reports/kpi-stats

Get KPI stats report

getKpiStatsReport

Returns per-day basket statistics and range totals over a configurable date range (defaulting to the last 30 days). Shows total basket counts and average values, with website baskets (source=shop_v2) broken out separately. Per-day data includes an entry for every date in the requested range, even when no baskets exist for that day (zero-count entries are included). The summary provides aggregated totals across the entire date range. Requires the DASHBOARDS_VIEW permission.

Query parameters

site_idstringrequired
Filter results by the site they belong to
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.

Responses

200
KPI stats report data.
400
The request failed.
403
The authenticated user does not have permission.

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

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

KPI stats report data.

{
  "data": {
    "by_date": [
      {
        "date": "2024-01-15",
        "all_baskets_count": 42,
        "all_baskets_average_value": 7500,
        "website_baskets_count": 28,
        "website_baskets_average_value": 6800
      }
    ],
    "summary": {
      "all_baskets_count": 420,
      "all_baskets_average_value": 7200,
      "website_baskets_count": 280,
      "website_baskets_average_value": 6500
    }
  },
  "meta": {
    "currency": "gbp"
  }
}

{
  "message": "string"
}

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

get/shop/reports/adyen-fees

Get the Adyen fees report

getAdyenFeesReport

Use this endpoint to retrieve a breakdown of the Adyen processing fees that have been deducted from captured payments over a given date range. Each row represents one Adyen payment and includes the component fees (commission, markup, scheme, interchange and processing) along with the payment metadata.

The endpoint supports content negotiation: send Accept: text/csv (or append .csv to the URL where supported) to receive the report as a CSV download instead of JSON. The CSV variant requires the reports.download permission, whereas the JSON variant requires reports.view.

When date_from and date_to are omitted, the report defaults to the current calendar month in the site's timezone.

Query parameters

site_iduuidoptional
Filter the report to a single Site. When omitted, fees across every site the authenticated user has access to are included.
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.

Responses

200
The Adyen fees report was successfully retrieved.
403
The authenticated user does not have permission.

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

const response = await fetch('https://api.playground.try.be/shop/reports/adyen-fees', {
  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/reports/adyen-fees",
    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/reports/adyen-fees', [
    '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/reports/adyen-fees", 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 Adyen fees report was successfully retrieved.

{
  "data": [
    {
      "id": "5f8a1b2c3d4e5f6a7b8c9d0e",
      "psp_ref": "853599611111111A",
      "details_source": "ecom",
      "card_brand": "visa",
      "card_country": "GB",
      "amount": 12500,
      "commission": 12,
      "markup_fee": 8,
      "scheme_fee": 4,
      "interchange_fee": 30,
      "processing_fee": 10,
      "total_fees": 64,
      "application_fee": 50,
      "currency": "gbp",
      "paid_at": "2025-04-12T14:35:22+01:00",
      "site_id": "00000000-0000-0000-0000-000000000000",
      "site_name": "Trybe Spa London"
    }
  ]
}

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

get/shop/reports/hotel-package-items/refresh

Refresh the hotel package items report

actionRefreshHotelPackageItemsReport

Use this endpoint to trigger a refresh of the hotel package items report. The report is regenerated asynchronously in the background and emailed to the configured recipients when ready; this endpoint returns immediately once the job has been queued.

Because the underlying job is queued, calling this endpoint multiple times in quick succession may produce more than one delivery of the report. Wait for the previous email to arrive before retrying.

Responses

204
The refresh job was successfully dispatched. The report will be delivered asynchronously once it has finished generating.
401
The user is unauthenticated

curl "https://api.playground.try.be/shop/reports/hotel-package-items/refresh" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json"

const response = await fetch('https://api.playground.try.be/shop/reports/hotel-package-items/refresh', {
  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/reports/hotel-package-items/refresh",
    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/reports/hotel-package-items/refresh', [
    '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/reports/hotel-package-items/refresh", 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 refresh job was successfully dispatched. The report will be delivered asynchronously once it has finished generating.

// empty response

{
  "message": "Unauthenticated"
}

get/shop/reports/partner-orders

Export the partner orders report

listPartnerOrders

Use this endpoint to download a CSV export of every order placed through a specific partner. Each row corresponds to one order in the partner's pipeline, sorted by submission date (most recent first); when a query is supplied the rows are ordered by search relevance instead.

Generating the file is synchronous, so for partners with very large order volumes prefer the queue variant of this endpoint, which renders the report on a background worker and notifies you when it is ready.

Requires the admin.sites.manage permission.

Query parameters

partner_idstringrequired
Scope the export to the named partner. Accepts a partner key from the platform partner catalogue (or ota for the generic OTA bucket). Only baskets attributed to this partner are included — direct bookings are excluded. Required because the report is partner-attribution-driven and would otherwise return an empty file.
site_idstringoptional
Filter the export to one or more Site IDs. Accepts a single ID or a comma-separated list. When omitted, orders across every site the authenticated user has access to are included.
customer_iduuidoptional
Filter the export to a single customer.
statusstringoptional
Filter the export by basket status. Accepts a single value or a comma-separated list. Defaults to new, submitted and settled.
querystringoptional
A free-text search across the order reference, external reference, customer name and email, and the names of items in the order. When set, results are ordered by relevance.
submitted_at_fromdate-timeoptional
The earliest submitted_at date and time to include in the export (inclusive).
submitted_at_todate-timeoptional
The latest submitted_at date and time to include in the export (inclusive).
item_date_fromdateoptional
Include orders that contain at least one item dated on or after this date.
item_date_todateoptional
Include orders that contain at least one item dated on or before this date.
revenue_date_fromdateoptional
The earliest revenue_date to include in the export (inclusive).
revenue_date_todateoptional
The latest revenue_date to include in the export (inclusive).
labelsstringoptional
Filter by basket labels. Accepts a comma-separated list of label IDs; prefix an ID with - to exclude orders with that label, or pass none to match only orders with no labels at all.
external_idstringoptional
Filter by an external ID in the form key:value (for example, pms:RES-12345).

Responses

200
The partner orders report was successfully generated.
403
The authenticated user does not have permission.
422
The request didn't pass validation

curl "https://api.playground.try.be/shop/reports/partner-orders?partner_id=ota" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json"

const response = await fetch('https://api.playground.try.be/shop/reports/partner-orders?partner_id=ota', {
  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/reports/partner-orders?partner_id=ota",
    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/reports/partner-orders?partner_id=ota', [
    '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/reports/partner-orders?partner_id=ota", 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 partner orders report was successfully generated.

// empty response

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

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

get/shop/reports/partner-orders/queue

Queue an export of the partner orders report

queuePartnerOrdersExport

Use this endpoint to queue a background job that renders the partner orders report as a CSV. The job runs asynchronously and the resulting file is attached to the returned QueuedJob once it has finished. Pass email=true to additionally have the file emailed to the user who queued the job.

This is the recommended variant for partners with large order volumes, where the synchronous export endpoint may time out.

Requires the admin.sites.manage permission.

Query parameters

partner_idstringrequired
Scope the export to the named partner. Accepts a partner key from the platform partner catalogue (or ota for the generic OTA bucket). Only baskets attributed to this partner are included — direct bookings are excluded. Required because the report is partner-attribution-driven and would otherwise return an empty file.
site_idstringoptional
Filter the export to one or more Site IDs. Accepts a single ID or a comma-separated list. When omitted, orders across every site the authenticated user has access to are included.
customer_iduuidoptional
Filter the export to a single customer.
statusstringoptional
Filter the export by basket status. Accepts a single value or a comma-separated list. Defaults to new, submitted and settled.
querystringoptional
A free-text search across the order reference, external reference, customer name and email, and the names of items in the order. When set, results are ordered by relevance.
submitted_at_fromdate-timeoptional
The earliest submitted_at date and time to include in the export (inclusive).
submitted_at_todate-timeoptional
The latest submitted_at date and time to include in the export (inclusive).
item_date_fromdateoptional
Include orders that contain at least one item dated on or after this date.
item_date_todateoptional
Include orders that contain at least one item dated on or before this date.
revenue_date_fromdateoptional
The earliest revenue_date to include in the export (inclusive).
revenue_date_todateoptional
The latest revenue_date to include in the export (inclusive).
labelsstringoptional
Filter by basket labels. Accepts a comma-separated list of label IDs; prefix an ID with - to exclude orders with that label, or pass none to match only orders with no labels at all.
external_idstringoptional
Filter by an external ID in the form key:value (for example, pms:RES-12345).
emailbooleanoptional
When true, the rendered CSV will be emailed to the user who queued the job once it has finished generating. When false (the default) the file is only made available for download from the queued job.

Responses

200
The job was successfully queued
403
The authenticated user does not have permission.
422
The request didn't pass validation

curl "https://api.playground.try.be/shop/reports/partner-orders/queue?partner_id=ota" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json"

const response = await fetch('https://api.playground.try.be/shop/reports/partner-orders/queue?partner_id=ota', {
  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/reports/partner-orders/queue?partner_id=ota",
    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/reports/partner-orders/queue?partner_id=ota', [
    '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/reports/partner-orders/queue?partner_id=ota", 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 job was successfully queued

{
  "data": {
    "id": "00000000-0000-0000-0000-000000000000",
    "status": "pending",
    "output": {},
    "created_at": "2023-11-07T00:00:00+00:00",
    "updated_at": "2023-11-07T01:00:00+00:00"
  }
}

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

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

get/shop/reports/bookable-area-occupancy

Bookable area occupancy report

listBookableAreaOccupancy

For each bookable area at the requested site, returns bookable / blocked / booked minutes across the requested date range. Capped to 60 days per request — for larger ranges, queue an export with /shop/reports/bookable-area-occupancy/queue.

Query parameters

site_iduuidoptional
Restrict the report to the given site.
date_fromdaterequired
Restrict to occupancy on or after this date. Required. The range between date_from and date_to cannot exceed 60 days.
date_todaterequired
Restrict to occupancy on or before this date. Required.
bookable_area_idsstring[]optional
A comma-separated list of bookable area IDs to restrict to.
zone_idstring[]optional
A comma-separated list of zone IDs to restrict bookable areas to.

Responses

200
The report was successfully generated.
400
The request failed.

curl "https://api.playground.try.be/shop/reports/bookable-area-occupancy?date_from=2026-06-01&date_to=2026-06-30" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json"

const response = await fetch('https://api.playground.try.be/shop/reports/bookable-area-occupancy?date_from=2026-06-01&date_to=2026-06-30', {
  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/reports/bookable-area-occupancy?date_from=2026-06-01&date_to=2026-06-30",
    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/reports/bookable-area-occupancy?date_from=2026-06-01&date_to=2026-06-30', [
    '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/reports/bookable-area-occupancy?date_from=2026-06-01&date_to=2026-06-30", 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 report was successfully generated.

{
  "data": [
    {
      "bookable_area": {
        "id": "64a9f3b2c3d8e1f4a5b6c7d8",
        "name": "Pool"
      },
      "bookable_mins": 1,
      "blocked_mins": 1,
      "booked_mins": 1
    }
  ],
  "totals": {
    "bookable_mins": 1,
    "blocked_mins": 1,
    "booked_mins": 1
  }
}

{
  "message": "string"
}

get/shop/reports/bookable-area-occupancy/queue

Queue an export of the bookable area occupancy report

queueBookableAreaOccupancyExport

Queues a CSV export of the bookable area occupancy report to be generated asynchronously.

Query parameters

site_iduuidoptional
Restrict the report to the given site.
date_fromdaterequired
Restrict to occupancy on or after this date. Required. The range between date_from and date_to cannot exceed 60 days.
date_todaterequired
Restrict to occupancy on or before this date. Required.
bookable_area_idsstring[]optional
A comma-separated list of bookable area IDs to restrict to.
zone_idstring[]optional
A comma-separated list of zone IDs to restrict bookable areas to.
emailbooleanoptional
If true, email the completed CSV to the authenticated user when the background job finishes. Defaults to false, in which case the queued job's output URL must be polled via the queued-jobs endpoint.

Responses

200
The job was successfully queued
400
The request failed.

curl "https://api.playground.try.be/shop/reports/bookable-area-occupancy/queue?date_from=2026-06-01&date_to=2026-06-30" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json"

const response = await fetch('https://api.playground.try.be/shop/reports/bookable-area-occupancy/queue?date_from=2026-06-01&date_to=2026-06-30', {
  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/reports/bookable-area-occupancy/queue?date_from=2026-06-01&date_to=2026-06-30",
    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/reports/bookable-area-occupancy/queue?date_from=2026-06-01&date_to=2026-06-30', [
    '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/reports/bookable-area-occupancy/queue?date_from=2026-06-01&date_to=2026-06-30", 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 job was successfully queued

{
  "data": {
    "id": "00000000-0000-0000-0000-000000000000",
    "status": "pending",
    "output": {},
    "created_at": "2023-11-07T00:00:00+00:00",
    "updated_at": "2023-11-07T01:00:00+00:00"
  }
}

{
  "message": "string"
}

get/shop/reports/cancellations-and-no-shows

Cancellations and no-shows report

listCancellationsAndNoShows

Summarises baskets that were cancelled or marked as a no-show in the given revenue date range. The response is a display-ready table (rows of header + body cells) split into data (one row per status) and totals (a single combined row). The response can also be requested as a CSV by sending Accept: text/csv.

For programmatic access to the same numbers in JSON-native shape, use /shop/reports/cancellations-and-no-shows-v2. For large date ranges or background email-delivered exports, queue the report with /shop/reports/cancellations-and-no-shows/queue.

Query parameters

site_iduuidrequired
Restrict the report to baskets at the given site. Required.
revenue_date_fromdaterequired
Restrict to baskets with a revenue date on or after this date.
revenue_date_todaterequired
Restrict to baskets with a revenue date on or before this date.

Responses

200
The report was successfully generated.
400
The request failed.

curl "https://api.playground.try.be/shop/reports/cancellations-and-no-shows?site_id=00000000-0000-0000-0000-000000000000&revenue_date_from=2026-06-01&revenue_date_to=2026-06-30" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json"

const response = await fetch('https://api.playground.try.be/shop/reports/cancellations-and-no-shows?site_id=00000000-0000-0000-0000-000000000000&revenue_date_from=2026-06-01&revenue_date_to=2026-06-30', {
  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/reports/cancellations-and-no-shows?site_id=00000000-0000-0000-0000-000000000000&revenue_date_from=2026-06-01&revenue_date_to=2026-06-30",
    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/reports/cancellations-and-no-shows?site_id=00000000-0000-0000-0000-000000000000&revenue_date_from=2026-06-01&revenue_date_to=2026-06-30', [
    '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/reports/cancellations-and-no-shows?site_id=00000000-0000-0000-0000-000000000000&revenue_date_from=2026-06-01&revenue_date_to=2026-06-30", 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 report was successfully generated.

{
  "data": {
    "rows": [
      {
        "cells": [
          {
            "format": "th",
            "value": "string"
          }
        ]
      }
    ]
  },
  "totals": {
    "rows": [
      {
        "cells": [
          {
            "format": "th",
            "value": "string"
          }
        ]
      }
    ]
  }
}

{
  "message": "string"
}

get/shop/reports/cancellations-and-no-shows-v2

Cancellations and no-shows report (v2)

listCancellationsAndNoShowsV2

Returns the cancellations and no-shows totals as a JSON-native object — one bucket each for cancelled baskets, no-show baskets, and a combined total. Money fields are integers in the site's minor units (e.g. pence for GBP).

Prefer this endpoint over /shop/reports/cancellations-and-no-shows when integrating with a system rather than rendering a table.

Query parameters

site_iduuidrequired
Restrict the report to baskets at the given site. Required.
revenue_date_fromdaterequired
Restrict to baskets with a revenue date on or after this date.
revenue_date_todaterequired
Restrict to baskets with a revenue date on or before this date.

Responses

200
The report was successfully generated.
400
The request failed.

curl "https://api.playground.try.be/shop/reports/cancellations-and-no-shows-v2?site_id=00000000-0000-0000-0000-000000000000&revenue_date_from=2026-06-01&revenue_date_to=2026-06-30" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json"

const response = await fetch('https://api.playground.try.be/shop/reports/cancellations-and-no-shows-v2?site_id=00000000-0000-0000-0000-000000000000&revenue_date_from=2026-06-01&revenue_date_to=2026-06-30', {
  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/reports/cancellations-and-no-shows-v2?site_id=00000000-0000-0000-0000-000000000000&revenue_date_from=2026-06-01&revenue_date_to=2026-06-30",
    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/reports/cancellations-and-no-shows-v2?site_id=00000000-0000-0000-0000-000000000000&revenue_date_from=2026-06-01&revenue_date_to=2026-06-30', [
    '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/reports/cancellations-and-no-shows-v2?site_id=00000000-0000-0000-0000-000000000000&revenue_date_from=2026-06-01&revenue_date_to=2026-06-30", 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 report was successfully generated.

{
  "cancelled": {
    "name": "Cancelled",
    "count": 12,
    "total_net": 90000,
    "total_gross": 108000
  },
  "no_shows": {
    "name": "Cancelled",
    "count": 12,
    "total_net": 90000,
    "total_gross": 108000
  },
  "total": {
    "name": "Cancelled",
    "count": 12,
    "total_net": 90000,
    "total_gross": 108000
  }
}

{
  "message": "string"
}

get/shop/reports/cancellations-and-no-shows/queue

Queue an export of the cancellations and no-shows report

queueCancellationsAndNoShowsExport

Queues a CSV export of the cancellations and no-shows report so it can be generated asynchronously. The report is run on a background worker and, when email=true, is delivered to the calling user once ready. Use this instead of the synchronous endpoint when the date range spans more than a few months.

See /shop/reports/cancellations-and-no-shows for the synchronous variant.

Query parameters

site_iduuidrequired
Restrict the report to baskets at the given site. Required.
revenue_date_fromdaterequired
Restrict to baskets with a revenue date on or after this date.
revenue_date_todaterequired
Restrict to baskets with a revenue date on or before this date.
emailbooleanoptional
If true, email the completed CSV to the authenticated user when the background job finishes. Defaults to false, in which case the queued job's output URL must be polled via the queued-jobs endpoint.

Responses

200
The job was successfully queued
400
The request failed.

curl "https://api.playground.try.be/shop/reports/cancellations-and-no-shows/queue?site_id=00000000-0000-0000-0000-000000000000&revenue_date_from=2026-06-01&revenue_date_to=2026-06-30" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json"

const response = await fetch('https://api.playground.try.be/shop/reports/cancellations-and-no-shows/queue?site_id=00000000-0000-0000-0000-000000000000&revenue_date_from=2026-06-01&revenue_date_to=2026-06-30', {
  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/reports/cancellations-and-no-shows/queue?site_id=00000000-0000-0000-0000-000000000000&revenue_date_from=2026-06-01&revenue_date_to=2026-06-30",
    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/reports/cancellations-and-no-shows/queue?site_id=00000000-0000-0000-0000-000000000000&revenue_date_from=2026-06-01&revenue_date_to=2026-06-30', [
    '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/reports/cancellations-and-no-shows/queue?site_id=00000000-0000-0000-0000-000000000000&revenue_date_from=2026-06-01&revenue_date_to=2026-06-30", 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 job was successfully queued

{
  "data": {
    "id": "00000000-0000-0000-0000-000000000000",
    "status": "pending",
    "output": {},
    "created_at": "2023-11-07T00:00:00+00:00",
    "updated_at": "2023-11-07T01:00:00+00:00"
  }
}

{
  "message": "string"
}

get/shop/reports/charge-list

Charges list

listCharges

A paginated list of individual charges (payments and refunds) at the requested site, filterable by status, processor, completion date, revenue date, payout date, and more. A per-processor net total is returned alongside the page of data so dashboards can show a running total without needing to fetch every page.

For large date ranges or background CSV delivery, use /shop/reports/charge-list/queue.

Query parameters

site_iduuidoptional
Restrict the report to charges at the given site.
pageintegeroptional
The page to retrieve results from
per_pageintegeroptional
The number of results to return per page
completed_fromdate-timeoptional
Restrict to charges completed on or after this time.
completed_todate-timeoptional
Restrict to charges completed on or before this time.
created_fromdate-timeoptional
Restrict to charges created on or after this time.
created_todate-timeoptional
Restrict to charges created on or before this time.
revenue_date_fromdateoptional
Restrict to charges with a revenue date on or after this date.
revenue_date_todateoptional
Restrict to charges with a revenue date on or before this date.
payout_date_fromdateoptional
Restrict to charges with a payout date on or after this date.
payout_date_todateoptional
Restrict to charges with a payout date on or before this date.
statusstringoptional
The charge status to include. Defaults to complete for the main charge list and to all for the pay-by-link variant.
chargeable_typestringoptional
Filter to charges against a specific chargeable type (e.g. order, membership).
charge_typestringoptional
Filter to a particular charge type (e.g. payment, refund).
processorstringoptional
Filter to charges that went through a specific payment processor (e.g. adyen, stripe, cash).
details_sourcestringoptional
Filter to charges where the payment details came from a specific source (e.g. pay_by_link).
order_statusstringoptional
Filter to charges whose parent order has a specific status.
created_byobject-idoptional
Filter to charges created by a specific user ID.

Responses

200
The charges were successfully retrieved.
400
The request failed.

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

const response = await fetch('https://api.playground.try.be/shop/reports/charge-list', {
  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/reports/charge-list",
    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/reports/charge-list', [
    '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/reports/charge-list", 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 charges were successfully retrieved.

{
  "data": [
    {
      "id": "60a8c0901d210625e3a87667",
      "charge_type": "payment",
      "chargeable_type": "order",
      "order_ref": "TRY03",
      "order_status": "settled",
      "revenue_date": "2026-06-15",
      "payout_date": "2026-06-18",
      "chargeable_id": "64a9f3b2c3d8e1f4a5b6c7d8",
      "customer_id": "00000000-0000-0000-0000-000000000000",
      "customer_name": "Jane Doe",
      "processor": "adyen",
      "processor_type": "card",
      "processor_type_id": "00000000-0000-0000-0000-000000000000",
      "processor_id": "PSP_REF_123",
      "notes": "Free-form text from the resource.",
      "amount": 15000,
      "currency": "gbp",
      "status": "complete",
      "failure_reason": "string",
      "cardholder_name": "string",
      "card_brand": "string",
      "card_last4": "string",
      "application_fee": 1,
      "net_amount": 1,
      "created_at": "2026-01-15T09:30:00+00:00",
      "completed_at": "2026-01-15T09:30:00+00: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"
  },
  "processor_totals": [
    {
      "processor": "adyen",
      "amount": 250000
    }
  ]
}

{
  "message": "string"
}

get/shop/reports/charge-list/queue

Queue an export of the charges list

queueChargeListExport

Queues a CSV export of the charges list to be generated asynchronously.

Query parameters

site_iduuidoptional
Restrict the report to charges at the given site.
completed_fromdate-timeoptional
Restrict to charges completed on or after this time.
completed_todate-timeoptional
Restrict to charges completed on or before this time.
created_fromdate-timeoptional
Restrict to charges created on or after this time.
created_todate-timeoptional
Restrict to charges created on or before this time.
revenue_date_fromdateoptional
Restrict to charges with a revenue date on or after this date.
revenue_date_todateoptional
Restrict to charges with a revenue date on or before this date.
payout_date_fromdateoptional
Restrict to charges with a payout date on or after this date.
payout_date_todateoptional
Restrict to charges with a payout date on or before this date.
statusstringoptional
The charge status to include. Defaults to complete for the main charge list and to all for the pay-by-link variant.
chargeable_typestringoptional
Filter to charges against a specific chargeable type (e.g. order, membership).
charge_typestringoptional
Filter to a particular charge type (e.g. payment, refund).
processorstringoptional
Filter to charges that went through a specific payment processor (e.g. adyen, stripe, cash).
details_sourcestringoptional
Filter to charges where the payment details came from a specific source (e.g. pay_by_link).
order_statusstringoptional
Filter to charges whose parent order has a specific status.
created_byobject-idoptional
Filter to charges created by a specific user ID.
emailbooleanoptional
If true, email the completed CSV to the authenticated user when the background job finishes. Defaults to false, in which case the queued job's output URL must be polled via the queued-jobs endpoint.

Responses

200
The job was successfully queued
400
The request failed.

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

const response = await fetch('https://api.playground.try.be/shop/reports/charge-list/queue', {
  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/reports/charge-list/queue",
    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/reports/charge-list/queue', [
    '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/reports/charge-list/queue", 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 job was successfully queued

{
  "data": {
    "id": "00000000-0000-0000-0000-000000000000",
    "status": "pending",
    "output": {},
    "created_at": "2023-11-07T00:00:00+00:00",
    "updated_at": "2023-11-07T01:00:00+00:00"
  }
}

{
  "message": "string"
}

get/shop/reports/commission

Commission report

listCommission

Returns the commission earned by each practitioner at the requested site for the given period, broken down by commission package. Money fields are decimal strings in the site's currency (rather than minor-unit integers) to preserve the precision of the underlying commission calculation.

For background CSV delivery use /shop/reports/commission/queue.

Query parameters

site_iduuidrequired
Restrict the report to commission earned at the given site.
date_fromdaterequired
Restrict to commission earned on or after this date.
date_todaterequired
Restrict to commission earned on or before this date.

Responses

200
The report was successfully generated.
400
The request failed.

curl "https://api.playground.try.be/shop/reports/commission?site_id=00000000-0000-0000-0000-000000000000&date_from=2026-06-01&date_to=2026-06-30" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json"

const response = await fetch('https://api.playground.try.be/shop/reports/commission?site_id=00000000-0000-0000-0000-000000000000&date_from=2026-06-01&date_to=2026-06-30', {
  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/reports/commission?site_id=00000000-0000-0000-0000-000000000000&date_from=2026-06-01&date_to=2026-06-30",
    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/reports/commission?site_id=00000000-0000-0000-0000-000000000000&date_from=2026-06-01&date_to=2026-06-30', [
    '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/reports/commission?site_id=00000000-0000-0000-0000-000000000000&date_from=2026-06-01&date_to=2026-06-30", 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 report was successfully generated.

{
  "data": [
    {
      "practitioner_name": "Sarah Smith",
      "commission_package_name": "Standard Therapist Commission",
      "date_from": "2026-01-15",
      "date_to": "2026-01-15",
      "total_sales": "450.00",
      "total_commission": "45.00",
      "total_surcharge": "0.00",
      "total_gross_commission": "45.00",
      "item_count": 9,
      "currency": "gbp"
    }
  ]
}

{
  "message": "string"
}

get/shop/reports/commission/queue

Queue an export of the commission report

queueCommissionExport

Queues a CSV export of the commission report to be generated asynchronously.

Query parameters

site_iduuidrequired
Restrict the report to commission earned at the given site.
date_fromdaterequired
Restrict to commission earned on or after this date.
date_todaterequired
Restrict to commission earned on or before this date.
emailbooleanoptional
If true, email the completed CSV to the authenticated user when the background job finishes. Defaults to false, in which case the queued job's output URL must be polled via the queued-jobs endpoint.

Responses

200
The job was successfully queued
400
The request failed.

curl "https://api.playground.try.be/shop/reports/commission/queue?site_id=00000000-0000-0000-0000-000000000000&date_from=2026-06-01&date_to=2026-06-30" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json"

const response = await fetch('https://api.playground.try.be/shop/reports/commission/queue?site_id=00000000-0000-0000-0000-000000000000&date_from=2026-06-01&date_to=2026-06-30', {
  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/reports/commission/queue?site_id=00000000-0000-0000-0000-000000000000&date_from=2026-06-01&date_to=2026-06-30",
    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/reports/commission/queue?site_id=00000000-0000-0000-0000-000000000000&date_from=2026-06-01&date_to=2026-06-30', [
    '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/reports/commission/queue?site_id=00000000-0000-0000-0000-000000000000&date_from=2026-06-01&date_to=2026-06-30", 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 job was successfully queued

{
  "data": {
    "id": "00000000-0000-0000-0000-000000000000",
    "status": "pending",
    "output": {},
    "created_at": "2023-11-07T00:00:00+00:00",
    "updated_at": "2023-11-07T01:00:00+00:00"
  }
}

{
  "message": "string"
}

get/shop/reports/daily-revenue-stats

Daily revenue stats

getDailyRevenueStats

The dashboard payload that powers the "today at a glance" revenue view for a single site. Returns revenue by centre, payments by processor, top items, and other operational counts. Defaults to today in the site's timezone if date is omitted.

Query parameters

site_iduuidrequired
The site to compute the daily stats for.
datedateoptional
The date to compute the stats for. Defaults to today in the site's timezone if omitted.

Responses

200
The stats were successfully generated.
400
The request failed.

curl "https://api.playground.try.be/shop/reports/daily-revenue-stats?site_id=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/reports/daily-revenue-stats?site_id=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/reports/daily-revenue-stats?site_id=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/reports/daily-revenue-stats?site_id=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/reports/daily-revenue-stats?site_id=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)
}

The stats were successfully generated.

{
  "revenue_by_centre": "string",
  "payments_by_processor": "string",
  "operational_stats": "string",
  "orders": "string",
  "item_type_breakdown": "string",
  "top_items": "string"
}

{
  "message": "string"
}

get/shop/reports/daily-sales-stats

Daily sales stats

getDailySalesStats

The dashboard payload that powers the "today's sales" view for a single site. Returns payments grouped by processor, refunds, the day's orders, aggregate order stats, and membership sales. Defaults to today in the site's timezone if date is omitted.

Companion endpoint to /shop/reports/daily-revenue-stats.

Query parameters

site_iduuidrequired
The site to compute the daily stats for.
datedateoptional
The date to compute the stats for. Defaults to today in the site's timezone if omitted.

Responses

200
The stats were successfully generated.
400
The request failed.

curl "https://api.playground.try.be/shop/reports/daily-sales-stats?site_id=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/reports/daily-sales-stats?site_id=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/reports/daily-sales-stats?site_id=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/reports/daily-sales-stats?site_id=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/reports/daily-sales-stats?site_id=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)
}

The stats were successfully generated.

{
  "payments_by_processor": "string",
  "refunds": "EXT-12345",
  "orders": "string",
  "order_stats": "string",
  "memberships": "string"
}

{
  "message": "string"
}

get/shop/reports/day-charges

Charges completed on a single day

listDayCharges

A convenience wrapper around /shop/reports/charge-list pre-filtered to a single day. Returns charges (payments and refunds) completed on the given date, paginated 100 to a page, alongside the per-processor totals for the day. Intended for end-of-day reconciliation views.

Query parameters

site_iduuidoptional
Restrict to charges at the given site. Defaults to the authenticated user's default site if omitted.
datedateoptional
The date the charges were completed on. Must be on or before today. Defaults to today in the site's timezone if omitted.
pageintegeroptional
The page to retrieve results from

Responses

200
The day's charges were successfully retrieved.
400
The request failed.

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

const response = await fetch('https://api.playground.try.be/shop/reports/day-charges', {
  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/reports/day-charges",
    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/reports/day-charges', [
    '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/reports/day-charges", 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 day's charges were successfully retrieved.

{
  "data": [
    {
      "id": "60a8c0901d210625e3a87667",
      "charge_type": "payment",
      "chargeable_type": "order",
      "order_ref": "TRY03",
      "order_status": "settled",
      "revenue_date": "2026-06-15",
      "payout_date": "2026-06-18",
      "chargeable_id": "64a9f3b2c3d8e1f4a5b6c7d8",
      "customer_id": "00000000-0000-0000-0000-000000000000",
      "customer_name": "Jane Doe",
      "processor": "adyen",
      "processor_type": "card",
      "processor_type_id": "00000000-0000-0000-0000-000000000000",
      "processor_id": "PSP_REF_123",
      "notes": "Free-form text from the resource.",
      "amount": 15000,
      "currency": "gbp",
      "status": "complete",
      "failure_reason": "string",
      "cardholder_name": "string",
      "card_brand": "string",
      "card_last4": "string",
      "application_fee": 1,
      "net_amount": 1,
      "created_at": "2026-01-15T09:30:00+00:00",
      "completed_at": "2026-01-15T09:30:00+00: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"
  },
  "processor_totals": [
    {
      "processor": "adyen",
      "amount": 250000
    }
  ]
}

{
  "message": "string"
}

get/shop/reports/general-ledger

General ledger

listGeneralLedger

A chronologically-sorted ledger of every revenue, payment, refund and revenue-reversal event at a site over the requested period. Use this for end-to-end financial reconciliation; for voucher-specific reconciliation see /shop/reports/voucher-ledger-detailed.

Query parameters

site_iduuidrequired
The site to compute the voucher ledger for.
date_fromdaterequired
Start of the date range covered by the ledger.
date_todaterequired
End of the date range covered by the ledger.

Responses

200
The ledger was successfully generated.
400
The request failed.

curl "https://api.playground.try.be/shop/reports/general-ledger?site_id=00000000-0000-0000-0000-000000000000&date_from=2026-06-01&date_to=2026-06-30" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json"

const response = await fetch('https://api.playground.try.be/shop/reports/general-ledger?site_id=00000000-0000-0000-0000-000000000000&date_from=2026-06-01&date_to=2026-06-30', {
  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/reports/general-ledger?site_id=00000000-0000-0000-0000-000000000000&date_from=2026-06-01&date_to=2026-06-30",
    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/reports/general-ledger?site_id=00000000-0000-0000-0000-000000000000&date_from=2026-06-01&date_to=2026-06-30', [
    '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/reports/general-ledger?site_id=00000000-0000-0000-0000-000000000000&date_from=2026-06-01&date_to=2026-06-30", 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 ledger was successfully generated.

[
  {
    "date": "2026-01-15T09:30:00+00:00",
    "type": "revenue",
    "revenue_centre": "string",
    "description": "Card payment",
    "amount": 1,
    "gross_amount": 1,
    "net_amount": 1,
    "tax_amount": 1,
    "meta": {}
  }
]

{
  "message": "string"
}

get/shop/reports/item-revenues

Item revenues report

listItemRevenues

Paginated list of submitted/settled basket items annotated with their per-revenue-centre allocations. Useful for reconciling revenue by offering, by revenue centre, or by item date. Money fields are integers in minor units.

For large date ranges or background CSV delivery use /shop/reports/item-revenues/queue.

Query parameters

site_iduuidrequired
Restrict to items at the given site.
pageintegeroptional
The page to retrieve results from
revenue_date_fromdateoptional
Restrict to items belonging to baskets with a revenue date on or after this date.
revenue_date_todateoptional
Restrict to items belonging to baskets with a revenue date on or before this date.
item_date_fromdateoptional
Restrict to items dated on or after this date.
item_date_todateoptional
Restrict to items dated on or before this date.
order_submitted_at_fromdate-timeoptional
Restrict to items belonging to baskets submitted on or after this time.
order_submitted_at_todate-timeoptional
Restrict to items belonging to baskets submitted on or before this time.
offering_typestringoptional
Filter to items of a particular offering type. Pass all to include every type (the default when filters omit this).
offering_idsstring[]optional
A comma-separated list of offering IDs to filter on.
revenue_centresstring[]optional
A comma-separated list of revenue centre keys or IDs to filter on.

Responses

200
The report was successfully generated.
400
The request failed.

curl "https://api.playground.try.be/shop/reports/item-revenues?site_id=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/reports/item-revenues?site_id=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/reports/item-revenues?site_id=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/reports/item-revenues?site_id=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/reports/item-revenues?site_id=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)
}

The report was successfully generated.

{
  "data": [
    {
      "id": "60a8c0901d210625e3a87667",
      "basket_id": "60a8c0901d210625e3a87668",
      "order_ref": "TRY03",
      "offering_type": "appointment",
      "offering_id": "64a9f3b2c3d8e1f4a5b6c7d8",
      "offering_name": "60 Minute Massage",
      "total_cost": 15000,
      "net_total": 12500,
      "gross_revenue": 1,
      "net_revenue": 1,
      "date": "2026-06-15",
      "revenues": [
        {
          "revenue_centre": "spa",
          "gross_revenue": 15000,
          "net_revenue": 12500
        }
      ]
    }
  ],
  "meta": {
    "revenue_centres": [
      {
        "key": "string",
        "name": "Alex Morgan"
      }
    ]
  },
  "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": "string"
}

get/shop/reports/item-revenues/queue

Queue an export of the item revenues report

queueItemRevenuesExport

Queues a CSV export of the item revenues report to be generated asynchronously.

Query parameters

site_iduuidrequired
Restrict to items at the given site.
revenue_date_fromdateoptional
Restrict to items belonging to baskets with a revenue date on or after this date.
revenue_date_todateoptional
Restrict to items belonging to baskets with a revenue date on or before this date.
item_date_fromdateoptional
Restrict to items dated on or after this date.
item_date_todateoptional
Restrict to items dated on or before this date.
order_submitted_at_fromdate-timeoptional
Restrict to items belonging to baskets submitted on or after this time.
order_submitted_at_todate-timeoptional
Restrict to items belonging to baskets submitted on or before this time.
offering_typestringoptional
Filter to items of a particular offering type. Pass all to include every type (the default when filters omit this).
offering_idsstring[]optional
A comma-separated list of offering IDs to filter on.
revenue_centresstring[]optional
A comma-separated list of revenue centre keys or IDs to filter on.
emailbooleanoptional
If true, email the completed CSV to the authenticated user when the background job finishes. Defaults to false, in which case the queued job's output URL must be polled via the queued-jobs endpoint.

Responses

200
The job was successfully queued
400
The request failed.

curl "https://api.playground.try.be/shop/reports/item-revenues/queue?site_id=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/reports/item-revenues/queue?site_id=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/reports/item-revenues/queue?site_id=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/reports/item-revenues/queue?site_id=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/reports/item-revenues/queue?site_id=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)
}

The job was successfully queued

{
  "data": {
    "id": "00000000-0000-0000-0000-000000000000",
    "status": "pending",
    "output": {},
    "created_at": "2023-11-07T00:00:00+00:00",
    "updated_at": "2023-11-07T01:00:00+00:00"
  }
}

{
  "message": "string"
}

get/shop/reports/occupancy-overview

Occupancy overview

listOccupancyOverview

A daily occupancy roll-up for a site, combining booked-basket counts, session counts and capacity, blocked-time minutes, and the same per-day numbers reported by the practitioner and room occupancy reports. Intended to power a single-screen overview of "how busy is this site this week". Capped to 7 days per request.

Query parameters

site_iduuidrequired
The site to compute the overview for.
date_fromdaterequired
The first date in the overview. Required. The range between date_from and date_to cannot exceed 7 days.
date_todaterequired
The last date in the overview. Required.
zone_idstring[]optional
A comma-separated list of zone IDs to restrict practitioners and rooms to.

Responses

200
The overview was successfully generated.
400
The request failed.

curl "https://api.playground.try.be/shop/reports/occupancy-overview?site_id=00000000-0000-0000-0000-000000000000&date_from=2026-06-15&date_to=2026-06-21" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json"

const response = await fetch('https://api.playground.try.be/shop/reports/occupancy-overview?site_id=00000000-0000-0000-0000-000000000000&date_from=2026-06-15&date_to=2026-06-21', {
  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/reports/occupancy-overview?site_id=00000000-0000-0000-0000-000000000000&date_from=2026-06-15&date_to=2026-06-21",
    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/reports/occupancy-overview?site_id=00000000-0000-0000-0000-000000000000&date_from=2026-06-15&date_to=2026-06-21', [
    '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/reports/occupancy-overview?site_id=00000000-0000-0000-0000-000000000000&date_from=2026-06-15&date_to=2026-06-21", 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 overview was successfully generated.

{
  "data": [
    {
      "date": "2026-01-15",
      "baskets": {
        "num_baskets": 35,
        "num_booked_appointments": 22,
        "num_booked_sessions": 5,
        "num_booked_packages": 8
      },
      "sessions": {
        "num_sessions": 6,
        "total_session_capacity": 60,
        "total_session_booked_customers": 32
      },
      "blocked_times": {
        "num_blocked_times": 1,
        "total_mins": 1
      },
      "practitioners": {},
      "rooms": {}
    }
  ]
}

{
  "message": "string"
}

get/shop/reports/pay-by-link-payments

Pay-by-link payments list

listPayByLinkPayments

A paginated list of pay-by-link charges issued at the given site. Useful for tracking outstanding payment links sent to customers (status=pending) and reviewing recently collected pay-by-link payments.

For the smart-filter options used to power list-page chips and saved searches, see /shop/reports/pay-by-link-payments/smart-filters.

Query parameters

site_iduuidrequired
Restrict to pay-by-link payments at the given site.
pageintegeroptional
The page to retrieve results from
per_pageintegeroptional
The number of payments to return per page. Defaults to 30.
created_fromdateoptional
Restrict to pay-by-link charges created on or after this date.
created_todateoptional
Restrict to pay-by-link charges created on or before this date.
completed_fromdateoptional
Restrict to pay-by-link charges completed on or after this date.
completed_todateoptional
Restrict to pay-by-link charges completed on or before this date.
revenue_date_fromdateoptional
Restrict to pay-by-link charges whose underlying basket has a revenue date on or after this date.
revenue_date_todateoptional
Restrict to pay-by-link charges whose underlying basket has a revenue date on or before this date.
statusstringoptional
Filter to pay-by-link charges with a specific status. Defaults to all.
sortstringoptional
Field to sort the list by.
sort_orderstringoptional
Sort direction. asc returns oldest-first, desc returns newest-first. Combine with sort to control which column is sorted. Defaults to asc.
Possible values:ascdesc

Responses

200
The pay-by-link payments were successfully retrieved.
400
The request failed.

curl "https://api.playground.try.be/shop/reports/pay-by-link-payments?site_id=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/reports/pay-by-link-payments?site_id=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/reports/pay-by-link-payments?site_id=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/reports/pay-by-link-payments?site_id=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/reports/pay-by-link-payments?site_id=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)
}

The pay-by-link payments were successfully retrieved.

{
  "data": [
    {
      "id": "64a9f3b2c3d8e1f4a5b6c7d8",
      "status": "pending",
      "order_ref": "TRY03",
      "basket_id": "64a9f3b2c3d8e1f4a5b6c7d8",
      "customer_name": "Jane Doe",
      "revenue_date": "string",
      "created_at": "2026-01-15T09:30:00+00:00",
      "paid_at": "2026-01-15T09:30:00+00: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": "string"
}

get/shop/reports/pay-by-link-payments/smart-filters

Smart filters for the pay-by-link payments list

listPayByLinkPaymentsSmartFilters

Returns the smart-filter options that can be used to filter the pay-by-link payments list — e.g. "outstanding for over 7 days", "completed today". Companion endpoint to /shop/reports/pay-by-link-payments.

Query parameters

site_iduuidrequired
Restrict to pay-by-link payments at the given site.

Responses

200
A response with a list of smart filters to be used on a list report.
400
The request failed.

curl "https://api.playground.try.be/shop/reports/pay-by-link-payments/smart-filters?site_id=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/reports/pay-by-link-payments/smart-filters?site_id=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/reports/pay-by-link-payments/smart-filters?site_id=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/reports/pay-by-link-payments/smart-filters?site_id=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/reports/pay-by-link-payments/smart-filters?site_id=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 response with a list of smart filters to be used on a list report.

{
  "data": [
    {
      "key": "recently_created",
      "name": "Recently created",
      "count": 12,
      "filters": [
        {
          "key": "date_from",
          "type": "string",
          "string_value": "confirmed",
          "date_value": "2026-01-15T09:30:00+00:00",
          "boolean_value": false
        }
      ]
    }
  ]
}

{
  "message": "string"
}

get/shop/reports/payouts/{payoutId}/queue

Queue a CSV export of a single payout

queuePayoutExport

Queues an asynchronous CSV export of every charge included in the given payout. Used to produce the per-payout transaction listing that finance teams reconcile against the deposit appearing in the merchant's bank account.

Path parameters

payoutIdobject-idrequired
Identifier of the payout. Payouts represent transfers from Trybe-managed payment processing into the merchant's bank account; this ID lets you read the payout breakdown or retry a failed transfer.

Responses

200
The job was successfully queued
400
The request failed.

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

const response = await fetch('https://api.playground.try.be/shop/reports/payouts/abc123/queue', {
  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/reports/payouts/abc123/queue",
    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/reports/payouts/abc123/queue', [
    '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/reports/payouts/abc123/queue", 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 job was successfully queued

{
  "data": {
    "id": "00000000-0000-0000-0000-000000000000",
    "status": "pending",
    "output": {},
    "created_at": "2023-11-07T00:00:00+00:00",
    "updated_at": "2023-11-07T01:00:00+00:00"
  }
}

{
  "message": "string"
}

get/shop/reports/practitioner-utilisation

Practitioner utilisation report

listPractitionerUtilisation

For each practitioner working at the given site, returns bookable / booked / blocked minutes and attributed net revenue across the requested date range. Capped to 31 days per request — for larger ranges, queue an export with /shop/reports/practitioner-utilisation/queue.

Query parameters

site_iduuidrequired
Restrict the report to the given site. Required.
date_fromdaterequired
Restrict to bookings on or after this date. Required. The range between date_from and date_to cannot exceed 31 days.
date_todaterequired
Restrict to bookings on or before this date. Required.
zone_idstring[]optional
A comma-separated list of zone IDs to restrict practitioners to.

Responses

200
The report was successfully generated.
400
The request failed.

curl "https://api.playground.try.be/shop/reports/practitioner-utilisation?site_id=00000000-0000-0000-0000-000000000000&date_from=2026-06-01&date_to=2026-06-30" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json"

const response = await fetch('https://api.playground.try.be/shop/reports/practitioner-utilisation?site_id=00000000-0000-0000-0000-000000000000&date_from=2026-06-01&date_to=2026-06-30', {
  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/reports/practitioner-utilisation?site_id=00000000-0000-0000-0000-000000000000&date_from=2026-06-01&date_to=2026-06-30",
    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/reports/practitioner-utilisation?site_id=00000000-0000-0000-0000-000000000000&date_from=2026-06-01&date_to=2026-06-30', [
    '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/reports/practitioner-utilisation?site_id=00000000-0000-0000-0000-000000000000&date_from=2026-06-01&date_to=2026-06-30", 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 report was successfully generated.

{
  "data": [
    {
      "practitioner_id": "60a8c0901d210625e3a87667",
      "practitioner_name": "Sarah Smith",
      "bookable_mins": 2400,
      "appointment_mins": 1500,
      "session_mins": 200,
      "blocked_mins": 60,
      "net_revenue": 180000
    }
  ],
  "totals": {
    "bookable_mins": 1,
    "appointment_mins": 1,
    "session_mins": 1,
    "blocked_mins": 1,
    "net_revenue": 1
  },
  "meta": {
    "date_from": "2026-01-15",
    "date_to": "2026-01-15"
  }
}

{
  "message": "string"
}

get/shop/reports/practitioner-utilisation/queue

Queue an export of the practitioner utilisation report

queuePractitionerUtilisationExport

Queues a CSV export of the practitioner utilisation report. Use this in preference to the synchronous endpoint when the report needs to be delivered to multiple recipients or when the calling context cannot wait for the synchronous response.

Query parameters

site_iduuidrequired
Restrict the report to the given site. Required.
date_fromdaterequired
Restrict to bookings on or after this date. Required. The range between date_from and date_to cannot exceed 31 days.
date_todaterequired
Restrict to bookings on or before this date. Required.
zone_idstring[]optional
A comma-separated list of zone IDs to restrict practitioners to.
emailbooleanoptional
If true, email the completed CSV to the authenticated user when the background job finishes. Defaults to false, in which case the queued job's output URL must be polled via the queued-jobs endpoint.

Responses

200
The job was successfully queued
400
The request failed.

curl "https://api.playground.try.be/shop/reports/practitioner-utilisation/queue?site_id=00000000-0000-0000-0000-000000000000&date_from=2026-06-01&date_to=2026-06-30" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json"

const response = await fetch('https://api.playground.try.be/shop/reports/practitioner-utilisation/queue?site_id=00000000-0000-0000-0000-000000000000&date_from=2026-06-01&date_to=2026-06-30', {
  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/reports/practitioner-utilisation/queue?site_id=00000000-0000-0000-0000-000000000000&date_from=2026-06-01&date_to=2026-06-30",
    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/reports/practitioner-utilisation/queue?site_id=00000000-0000-0000-0000-000000000000&date_from=2026-06-01&date_to=2026-06-30', [
    '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/reports/practitioner-utilisation/queue?site_id=00000000-0000-0000-0000-000000000000&date_from=2026-06-01&date_to=2026-06-30", 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 job was successfully queued

{
  "data": {
    "id": "00000000-0000-0000-0000-000000000000",
    "status": "pending",
    "output": {},
    "created_at": "2023-11-07T00:00:00+00:00",
    "updated_at": "2023-11-07T01:00:00+00:00"
  }
}

{
  "message": "string"
}

get/shop/reports/revenue-by-order-label

Revenue by order label report

listRevenueByOrderLabel

Summarises submitted/settled basket revenue grouped by order label. The response is a display-ready table (header + body rows). For JSON-native consumption use /shop/reports/revenue-by-order-label-v2; for large date ranges export asynchronously via /shop/reports/revenue-by-order-label/queue.

Query parameters

site_iduuidoptional
Restrict the report to baskets at the given site.
revenue_date_fromdaterequired
Restrict to baskets with a revenue date on or after this date.
revenue_date_todaterequired
Restrict to baskets with a revenue date on or before this date.

Responses

200
The report was successfully generated.
400
The request failed.

curl "https://api.playground.try.be/shop/reports/revenue-by-order-label?revenue_date_from=2026-06-01&revenue_date_to=2026-06-30" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json"

const response = await fetch('https://api.playground.try.be/shop/reports/revenue-by-order-label?revenue_date_from=2026-06-01&revenue_date_to=2026-06-30', {
  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/reports/revenue-by-order-label?revenue_date_from=2026-06-01&revenue_date_to=2026-06-30",
    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/reports/revenue-by-order-label?revenue_date_from=2026-06-01&revenue_date_to=2026-06-30', [
    '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/reports/revenue-by-order-label?revenue_date_from=2026-06-01&revenue_date_to=2026-06-30", 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 report was successfully generated.

{
  "rows": [
    {
      "cells": [
        {
          "format": "th",
          "value": "string"
        }
      ]
    }
  ]
}

{
  "message": "string"
}

get/shop/reports/revenue-by-order-label-v2

Revenue by order label report (v2)

listRevenueByOrderLabelV2

Returns submitted/settled basket revenue grouped by order label, in a JSON-native shape suitable for programmatic consumption. Each entry also includes a per-revenue-centre breakdown. All money fields are integers in minor units.

For the legacy display-formatted variant see /shop/reports/revenue-by-order-label.

Query parameters

site_iduuidoptional
Restrict the report to baskets at the given site.
revenue_date_fromdateoptional
Restrict to baskets with a revenue date on or after this date.
revenue_date_todateoptional
Restrict to baskets with a revenue date on or before this date.
item_date_fromdateoptional
Restrict to baskets containing items dated on or after this date.
item_date_todateoptional
Restrict to baskets containing items dated on or before this date.
labelsstring[]optional
A comma-separated list of order label IDs to filter on. Pass none to restrict to baskets with no order labels.
revenue_centrestring[]optional
A comma-separated list of revenue centre keys or IDs to filter on.

Responses

200
The report was successfully generated.
400
The request failed.

curl "https://api.playground.try.be/shop/reports/revenue-by-order-label-v2" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json"

const response = await fetch('https://api.playground.try.be/shop/reports/revenue-by-order-label-v2', {
  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/reports/revenue-by-order-label-v2",
    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/reports/revenue-by-order-label-v2', [
    '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/reports/revenue-by-order-label-v2", 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 report was successfully generated.

{
  "data": [
    {
      "label_id": "69c128c05a210879a60ac1af",
      "label_name": "VIP",
      "gross_revenue": 250000,
      "net_revenue": 208000,
      "revenue_centres": [
        {
          "revenue_centre": "spa",
          "gross_revenue": 120000,
          "net_revenue": 100000
        }
      ]
    }
  ],
  "meta": {
    "revenue_centres": [
      {
        "key": "string",
        "name": "Website"
      }
    ]
  }
}

{
  "message": "string"
}

get/shop/reports/revenue-by-order-label/queue

Queue an export of the revenue by order label report

queueRevenueByOrderLabelExport

Queues a CSV export of the revenue by order label report. Use this in preference to the synchronous endpoint when the date range spans more than a few months.

Query parameters

site_iduuidoptional
Restrict the report to baskets at the given site.
revenue_date_fromdaterequired
Restrict to baskets with a revenue date on or after this date.
revenue_date_todaterequired
Restrict to baskets with a revenue date on or before this date.
emailbooleanoptional
If true, email the completed CSV to the authenticated user when the background job finishes. Defaults to false, in which case the queued job's output URL must be polled via the queued-jobs endpoint.

Responses

200
The job was successfully queued
400
The request failed.

curl "https://api.playground.try.be/shop/reports/revenue-by-order-label/queue?revenue_date_from=2026-06-01&revenue_date_to=2026-06-30" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json"

const response = await fetch('https://api.playground.try.be/shop/reports/revenue-by-order-label/queue?revenue_date_from=2026-06-01&revenue_date_to=2026-06-30', {
  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/reports/revenue-by-order-label/queue?revenue_date_from=2026-06-01&revenue_date_to=2026-06-30",
    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/reports/revenue-by-order-label/queue?revenue_date_from=2026-06-01&revenue_date_to=2026-06-30', [
    '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/reports/revenue-by-order-label/queue?revenue_date_from=2026-06-01&revenue_date_to=2026-06-30", 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 job was successfully queued

{
  "data": {
    "id": "00000000-0000-0000-0000-000000000000",
    "status": "pending",
    "output": {},
    "created_at": "2023-11-07T00:00:00+00:00",
    "updated_at": "2023-11-07T01:00:00+00:00"
  }
}

{
  "message": "string"
}

get/shop/reports/revenue-by-sales-channel

Revenue by sales channel report

listRevenueBySalesChannel

Breaks down submitted and settled basket revenue by sales channel — useful for attributing income to the originating booking journey (website widget, in-spa POS, partner integration, etc.). Each entry also returns a per-revenue-centre split so the same totals can be sliced further.

For exports over very large date ranges, queue a CSV with /shop/reports/revenue-by-sales-channel/queue.

Query parameters

site_iduuidoptional
Restrict the report to baskets at the given site.
revenue_date_fromdateoptional
Restrict to baskets with a revenue date on or after this date.
revenue_date_todateoptional
Restrict to baskets with a revenue date on or before this date.
submitted_at_fromdateoptional
Restrict to baskets submitted on or after this date.
submitted_at_todateoptional
Restrict to baskets submitted on or before this date.
item_date_fromdateoptional
Restrict to baskets containing items dated on or after this date.
item_date_todateoptional
Restrict to baskets containing items dated on or before this date.
sales_channelstring[]optional
A comma-separated list of sales channel IDs to filter on.
revenue_centrestring[]optional
A comma-separated list of revenue centre keys or IDs to filter on.

Responses

200
The report was successfully generated.
400
The request failed.

curl "https://api.playground.try.be/shop/reports/revenue-by-sales-channel" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json"

const response = await fetch('https://api.playground.try.be/shop/reports/revenue-by-sales-channel', {
  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/reports/revenue-by-sales-channel",
    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/reports/revenue-by-sales-channel', [
    '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/reports/revenue-by-sales-channel", 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 report was successfully generated.

{
  "data": [
    {
      "sales_channel_id": "69c128bf5a210879a60ac186",
      "gross_revenue": 250000,
      "net_revenue": 208000,
      "revenue_centres": [
        {
          "revenue_centre": "spa",
          "gross_revenue": 120000,
          "net_revenue": 100000
        }
      ]
    }
  ],
  "meta": {
    "sales_channels": [
      {
        "id": "64a9f3b2c3d8e1f4a5b6c7d8",
        "name": "Website"
      }
    ],
    "revenue_centres": [
      {
        "key": "string",
        "name": "Website"
      }
    ]
  }
}

{
  "message": "string"
}

get/shop/reports/revenue-by-sales-channel/queue

Queue an export of the revenue by sales channel report

queueRevenueBySalesChannelExport

Queues a CSV export of the revenue by sales channel report to be generated asynchronously. Prefer this endpoint over the synchronous variant for date ranges that span more than a couple of months — for shorter ranges, see /shop/reports/revenue-by-sales-channel.

Query parameters

site_iduuidoptional
Restrict the report to baskets at the given site.
revenue_date_fromdateoptional
Restrict to baskets with a revenue date on or after this date.
revenue_date_todateoptional
Restrict to baskets with a revenue date on or before this date.
submitted_at_fromdateoptional
Restrict to baskets submitted on or after this date.
submitted_at_todateoptional
Restrict to baskets submitted on or before this date.
item_date_fromdateoptional
Restrict to baskets containing items dated on or after this date.
item_date_todateoptional
Restrict to baskets containing items dated on or before this date.
sales_channelstring[]optional
A comma-separated list of sales channel IDs to filter on.
revenue_centrestring[]optional
A comma-separated list of revenue centre keys or IDs to filter on.
emailbooleanoptional
If true, email the completed CSV to the authenticated user when the background job finishes. Defaults to false, in which case the queued job's output URL must be polled via the queued-jobs endpoint.

Responses

200
The job was successfully queued
400
The request failed.

curl "https://api.playground.try.be/shop/reports/revenue-by-sales-channel/queue" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json"

const response = await fetch('https://api.playground.try.be/shop/reports/revenue-by-sales-channel/queue', {
  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/reports/revenue-by-sales-channel/queue",
    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/reports/revenue-by-sales-channel/queue', [
    '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/reports/revenue-by-sales-channel/queue", 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 job was successfully queued

{
  "data": {
    "id": "00000000-0000-0000-0000-000000000000",
    "status": "pending",
    "output": {},
    "created_at": "2023-11-07T00:00:00+00:00",
    "updated_at": "2023-11-07T01:00:00+00:00"
  }
}

{
  "message": "string"
}

get/shop/reports/revenue-projection

Revenue projection report

listRevenueProjection

Projects expected revenue across a date range of up to 31 days, broken down by offering and revenue centre. Useful for daily/weekly dashboards that need to look ahead at booked revenue. Money fields are integers in minor units.

For background CSV export — including delivery by email — see /shop/reports/revenue-projection/queue.

Query parameters

site_iduuidoptional
Restrict the projection to baskets at the given site.
revenue_date_fromdateoptional
Restrict to baskets with a revenue date on or after this date. Either this and revenue_date_to must be provided, or item_date_from and item_date_to. The total range cannot exceed 31 days.
revenue_date_todateoptional
Restrict to baskets with a revenue date on or before this date.
item_date_fromdateoptional
Restrict to baskets containing items dated on or after this date.
item_date_todateoptional
Restrict to baskets containing items dated on or before this date.

Responses

200
The projection was successfully generated.
400
The request failed.

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

const response = await fetch('https://api.playground.try.be/shop/reports/revenue-projection', {
  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/reports/revenue-projection",
    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/reports/revenue-projection', [
    '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/reports/revenue-projection", 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 projection was successfully generated.

{
  "data": {
    "with_package_groups": [
      {
        "offering_id": "64a9f3b2c3d8e1f4a5b6c7d8",
        "offering_name": "string",
        "offering_type": "string",
        "package_type_id": "64a9f3b2c3d8e1f4a5b6c7d8",
        "revenue_centre": "string",
        "revenue_centre_name": "string",
        "category": "string",
        "by_date": [
          {
            "date": "2026-06-15",
            "num_items": 4,
            "gross_revenue": 60000,
            "net_revenue": 50000
          }
        ],
        "totals": {
          "num_items": 1,
          "gross_revenue": 1,
          "net_revenue": 1
        }
      }
    ],
    "without_package_groups": [
      {
        "offering_id": "5e932c0901d210625e3a8766",
        "offering_name": "60 Minute Massage",
        "offering_type": "appointment",
        "by_date": [
          {
            "date": "2026-06-15",
            "num_items": 4,
            "gross_revenue": 60000,
            "net_revenue": 50000
          }
        ],
        "totals": {
          "num_items": 1,
          "gross_revenue": 1,
          "net_revenue": 1
        }
      }
    ],
    "by_revenue_centre": [
      {
        "revenue_centre": "string",
        "revenue_centre_name": "string",
        "num_items": 1,
        "gross_revenue": 1,
        "net_revenue": 1,
        "by_date": [
          {
            "date": "2026-06-15",
            "num_items": 4,
            "gross_revenue": 60000,
            "net_revenue": 50000
          }
        ]
      }
    ]
  },
  "totals": {
    "with_package_groups": {
      "num_items": 1,
      "gross_revenue": 1,
      "net_revenue": 1,
      "by_date": [
        {
          "date": "2026-06-15",
          "num_items": 4,
          "gross_revenue": 60000,
          "net_revenue": 50000
        }
      ]
    },
    "without_package_groups": {
      "num_items": 1,
      "gross_revenue": 1,
      "net_revenue": 1,
      "by_date": [
        {
          "date": "2026-06-15",
          "num_items": 4,
          "gross_revenue": 60000,
          "net_revenue": 50000
        }
      ]
    },
    "by_date": [
      {
        "date": "2026-06-15",
        "num_items": 4,
        "gross_revenue": 60000,
        "net_revenue": 50000
      }
    ],
    "num_items": 1,
    "gross_revenue": 1,
    "net_revenue": 1
  }
}

{
  "message": "string"
}

get/shop/reports/revenue-projection/queue

Queue an export of the revenue projection report

queueRevenueProjectionExport

Queues a CSV export of the revenue projection report, generated asynchronously on a background worker. The same 31-day maximum range applies as for the synchronous endpoint.

Query parameters

site_iduuidoptional
Restrict the projection to baskets at the given site.
revenue_date_fromdateoptional
Restrict to baskets with a revenue date on or after this date. Either this and revenue_date_to must be provided, or item_date_from and item_date_to. The total range cannot exceed 31 days.
revenue_date_todateoptional
Restrict to baskets with a revenue date on or before this date.
item_date_fromdateoptional
Restrict to baskets containing items dated on or after this date.
item_date_todateoptional
Restrict to baskets containing items dated on or before this date.
emailbooleanoptional
If true, email the completed CSV to the authenticated user when the background job finishes. Defaults to false, in which case the queued job's output URL must be polled via the queued-jobs endpoint.

Responses

200
The job was successfully queued
400
The request failed.

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

const response = await fetch('https://api.playground.try.be/shop/reports/revenue-projection/queue', {
  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/reports/revenue-projection/queue",
    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/reports/revenue-projection/queue', [
    '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/reports/revenue-projection/queue", 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 job was successfully queued

{
  "data": {
    "id": "00000000-0000-0000-0000-000000000000",
    "status": "pending",
    "output": {},
    "created_at": "2023-11-07T00:00:00+00:00",
    "updated_at": "2023-11-07T01:00:00+00:00"
  }
}

{
  "message": "string"
}

get/shop/reports/room-occupancy

Room occupancy report

listRoomOccupancy

For each room at the requested site, returns bookable / appointment / session / blocked minutes across the requested date range. Capped to 60 days per request — for larger ranges, queue an export with /shop/reports/room-occupancy/queue.

Query parameters

site_iduuidoptional
Restrict the report to the given site.
date_fromdaterequired
Restrict to occupancy on or after this date. Required. The range between date_from and date_to cannot exceed 60 days.
date_todaterequired
Restrict to occupancy on or before this date. Required.
room_idsstring[]optional
A comma-separated list of room IDs to restrict to.
zone_idstring[]optional
A comma-separated list of zone IDs to restrict rooms to.

Responses

200
The report was successfully generated.
400
The request failed.

curl "https://api.playground.try.be/shop/reports/room-occupancy?date_from=2026-06-01&date_to=2026-06-30" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json"

const response = await fetch('https://api.playground.try.be/shop/reports/room-occupancy?date_from=2026-06-01&date_to=2026-06-30', {
  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/reports/room-occupancy?date_from=2026-06-01&date_to=2026-06-30",
    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/reports/room-occupancy?date_from=2026-06-01&date_to=2026-06-30', [
    '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/reports/room-occupancy?date_from=2026-06-01&date_to=2026-06-30", 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 report was successfully generated.

{
  "data": [
    {
      "room": {
        "id": "60a8c0901d210625e3a87667",
        "name": "Treatment Room 1"
      },
      "bookable_mins": 2400,
      "appointment_mins": 1500,
      "session_mins": 200,
      "blocked_mins": 60
    }
  ],
  "totals": {
    "bookable_mins": 1,
    "appointment_mins": 1,
    "session_mins": 1,
    "blocked_mins": 1
  }
}

{
  "message": "string"
}

get/shop/reports/room-occupancy/queue

Queue an export of the room occupancy report

queueRoomOccupancyExport

Queues a CSV export of the room occupancy report to be generated asynchronously.

Query parameters

site_iduuidoptional
Restrict the report to the given site.
date_fromdaterequired
Restrict to occupancy on or after this date. Required. The range between date_from and date_to cannot exceed 60 days.
date_todaterequired
Restrict to occupancy on or before this date. Required.
room_idsstring[]optional
A comma-separated list of room IDs to restrict to.
zone_idstring[]optional
A comma-separated list of zone IDs to restrict rooms to.
emailbooleanoptional
If true, email the completed CSV to the authenticated user when the background job finishes. Defaults to false, in which case the queued job's output URL must be polled via the queued-jobs endpoint.

Responses

200
The job was successfully queued
400
The request failed.

curl "https://api.playground.try.be/shop/reports/room-occupancy/queue?date_from=2026-06-01&date_to=2026-06-30" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json"

const response = await fetch('https://api.playground.try.be/shop/reports/room-occupancy/queue?date_from=2026-06-01&date_to=2026-06-30', {
  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/reports/room-occupancy/queue?date_from=2026-06-01&date_to=2026-06-30",
    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/reports/room-occupancy/queue?date_from=2026-06-01&date_to=2026-06-30', [
    '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/reports/room-occupancy/queue?date_from=2026-06-01&date_to=2026-06-30", 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 job was successfully queued

{
  "data": {
    "id": "00000000-0000-0000-0000-000000000000",
    "status": "pending",
    "output": {},
    "created_at": "2023-11-07T00:00:00+00:00",
    "updated_at": "2023-11-07T01:00:00+00:00"
  }
}

{
  "message": "string"
}

get/shop/reports/run-sheet

Run sheet for a single day

listRunSheet

Returns the chronological list of appointments and sessions taking place at a site on a single day — the operational "run sheet" used by front-of-house staff to walk through the day. Optionally filter to one or more practitioners. CSV output is available via Accept: text/csv.

Query parameters

site_iduuidrequired
The site to generate the run sheet for.
datedaterequired
The date the run sheet covers. Defaults to today in the site's timezone if omitted.
practitioner_idstring[]optional
A comma-separated list of practitioner IDs to restrict the run sheet to.

Responses

200
The run sheet was successfully generated.
400
The request failed.

curl "https://api.playground.try.be/shop/reports/run-sheet?site_id=00000000-0000-0000-0000-000000000000&date=2026-06-15" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json"

const response = await fetch('https://api.playground.try.be/shop/reports/run-sheet?site_id=00000000-0000-0000-0000-000000000000&date=2026-06-15', {
  method: 'GET',
  headers: {
    Authorization: 'Bearer YOUR_API_KEY',
    Accept: 'application/json',
  },
})

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

const data = await response.json()

import httpx

response = httpx.get(
    "https://api.playground.try.be/shop/reports/run-sheet?site_id=00000000-0000-0000-0000-000000000000&date=2026-06-15",
    headers={
        "Authorization": "Bearer YOUR_API_KEY",
        "Accept": "application/json",
    },
)
response.raise_for_status()
data = response.json()

<?php

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://api.playground.try.be/shop/reports/run-sheet?site_id=00000000-0000-0000-0000-000000000000&date=2026-06-15', [
    'headers' => [
        'Authorization' => 'Bearer YOUR_API_KEY',
        'Accept' => 'application/json',
    ],
]);

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

package main

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

func main() {
	req, _ := http.NewRequest("GET", "https://api.playground.try.be/shop/reports/run-sheet?site_id=00000000-0000-0000-0000-000000000000&date=2026-06-15", nil)
	req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
	req.Header.Set("Accept", "application/json")
	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()
	var data map[string]interface{}
	json.NewDecoder(resp.Body).Decode(&data)
}

The run sheet was successfully generated.

{
  "data": [
    {
      "id": "64a9f3b2c3d8e1f4a5b6c7d8",
      "type": "appointment",
      "start_time": "2026-01-15T09:30:00+00:00",
      "end_time": "2026-01-15T09:30:00+00:00",
      "event_name": "60 Minute Massage",
      "practitioner_name": "Sarah Smith",
      "room_name": "Treatment Room 1",
      "customer_name": "string",
      "session_capacity": 1,
      "session_booked_customers": 1
    }
  ]
}

{
  "message": "string"
}

get/shop/reports/top-customers

Top customers report

listTopCustomers

Returns the top 100 customers by net total across the filter range, sorted by net total descending. The customer name returned is the one most frequently used on the orders matched — the source-of-truth customer record lives in the Customers API.

For large date ranges or background CSV delivery, queue an export with /shop/reports/top-customers/queue.

Query parameters

site_iduuidoptional
Restrict the report to baskets at the given site.
revenue_date_fromdateoptional
Restrict to baskets with a revenue date on or after this date.
revenue_date_todateoptional
Restrict to baskets with a revenue date on or before this date.
submitted_at_fromdateoptional
Restrict to baskets submitted on or after this date.
submitted_at_todateoptional
Restrict to baskets submitted on or before this date.

Responses

200
The report was successfully generated.
400
The request failed.

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

const response = await fetch('https://api.playground.try.be/shop/reports/top-customers', {
  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/reports/top-customers",
    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/reports/top-customers', [
    '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/reports/top-customers", 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 report was successfully generated.

{
  "data": [
    {
      "id": "60a8c0901d210625e3a87667",
      "full_name": "Jane Doe",
      "num_orders": 8,
      "total_value_gross": 240000,
      "average_value_gross": 30000,
      "total_value_net": 200000,
      "average_value_net": 25000
    }
  ]
}

{
  "message": "string"
}

get/shop/reports/top-customers/queue

Queue an export of the top customers report

queueTopCustomersExport

Queues a CSV export of the top customers report to be generated asynchronously.

Query parameters

site_iduuidoptional
Restrict the report to baskets at the given site.
revenue_date_fromdateoptional
Restrict to baskets with a revenue date on or after this date.
revenue_date_todateoptional
Restrict to baskets with a revenue date on or before this date.
submitted_at_fromdateoptional
Restrict to baskets submitted on or after this date.
submitted_at_todateoptional
Restrict to baskets submitted on or before this date.
emailbooleanoptional
If true, email the completed CSV to the authenticated user when the background job finishes. Defaults to false, in which case the queued job's output URL must be polled via the queued-jobs endpoint.

Responses

200
The job was successfully queued
400
The request failed.

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

const response = await fetch('https://api.playground.try.be/shop/reports/top-customers/queue', {
  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/reports/top-customers/queue",
    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/reports/top-customers/queue', [
    '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/reports/top-customers/queue", 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 job was successfully queued

{
  "data": {
    "id": "00000000-0000-0000-0000-000000000000",
    "status": "pending",
    "output": {},
    "created_at": "2023-11-07T00:00:00+00:00",
    "updated_at": "2023-11-07T01:00:00+00:00"
  }
}

{
  "message": "string"
}

get/shop/reports/top-offerings

Top offerings report

listTopOfferings

Returns the top-selling offerings (appointments, sessions, products, packages, etc.) across the filter range, alongside per-offering-type roll-up totals. Useful for headline "what's our best seller" dashboards.

For background CSV delivery, use /shop/reports/top-offerings/queue.

Query parameters

site_iduuidoptional
Restrict to items at the given site.
revenue_date_fromdateoptional
Restrict to items belonging to baskets with a revenue date on or after this date.
revenue_date_todateoptional
Restrict to items belonging to baskets with a revenue date on or before this date.
item_date_fromdateoptional
Restrict to items dated on or after this date.
item_date_todateoptional
Restrict to items dated on or before this date.
offering_typestringoptional
Filter to items of a particular offering type.
offering_idsstring[]optional
A comma-separated list of offering IDs to filter on.

Responses

200
The report was successfully generated.
400
The request failed.

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

const response = await fetch('https://api.playground.try.be/shop/reports/top-offerings', {
  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/reports/top-offerings",
    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/reports/top-offerings', [
    '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/reports/top-offerings", 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 report was successfully generated.

{
  "data": [
    {
      "offering_id": "64a9f3b2c3d8e1f4a5b6c7d8",
      "offering_type": "appointment",
      "offering_name": "60 Minute Massage",
      "num_standalone_items": 1,
      "num_package_items": 1,
      "gross_revenue": 1,
      "net_revenue": 1
    }
  ],
  "totals": {
    "by_offering_type": [
      [
        {
          "offering_type": "appointment",
          "num_standalone_items": 1,
          "num_package_items": 1,
          "gross_revenue": 1,
          "net_revenue": 1
        }
      ]
    ]
  }
}

{
  "message": "string"
}

get/shop/reports/top-offerings/queue

Queue an export of the top offerings report

queueTopOfferingsExport

Queues a CSV export of the top offerings report to be generated asynchronously.

Query parameters

site_iduuidoptional
Restrict to items at the given site.
revenue_date_fromdateoptional
Restrict to items belonging to baskets with a revenue date on or after this date.
revenue_date_todateoptional
Restrict to items belonging to baskets with a revenue date on or before this date.
item_date_fromdateoptional
Restrict to items dated on or after this date.
item_date_todateoptional
Restrict to items dated on or before this date.
offering_typestringoptional
Filter to items of a particular offering type.
offering_idsstring[]optional
A comma-separated list of offering IDs to filter on.
emailbooleanoptional
If true, email the completed CSV to the authenticated user when the background job finishes. Defaults to false, in which case the queued job's output URL must be polled via the queued-jobs endpoint.

Responses

200
The job was successfully queued
400
The request failed.

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

const response = await fetch('https://api.playground.try.be/shop/reports/top-offerings/queue', {
  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/reports/top-offerings/queue",
    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/reports/top-offerings/queue', [
    '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/reports/top-offerings/queue", 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 job was successfully queued

{
  "data": {
    "id": "00000000-0000-0000-0000-000000000000",
    "status": "pending",
    "output": {},
    "created_at": "2023-11-07T00:00:00+00:00",
    "updated_at": "2023-11-07T01:00:00+00:00"
  }
}

{
  "message": "string"
}

get/shop/reports/trybe-payments-balance

Trybe Payments balance report

listTrybePaymentsBalance

A running ledger of Trybe Payments (Adyen balance platform) transfers — payments, refunds, and payouts — for the given site over the requested date range. Use this to reconcile the merchant's balance held with Trybe Payments. Defaults to the current calendar month if date_from / date_to are omitted.

Query parameters

site_iduuidrequired
The site whose Trybe Payments balance is being reported on.
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.
pageintegeroptional
The page to retrieve results from

Responses

200
The balance report was successfully generated.
400
The request failed.

curl "https://api.playground.try.be/shop/reports/trybe-payments-balance?site_id=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/reports/trybe-payments-balance?site_id=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/reports/trybe-payments-balance?site_id=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/reports/trybe-payments-balance?site_id=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/reports/trybe-payments-balance?site_id=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)
}

The balance report was successfully generated.

[
  {
    "id": "00000000-0000-0000-0000-000000000000",
    "time": "2026-01-15T09:30:00+00:00",
    "event": "AUTHORISATION",
    "type": "card_payment",
    "payment_id": "64a9f3b2c3d8e1f4a5b6c7d8",
    "refund_id": "64a9f3b2c3d8e1f4a5b6c7d8",
    "payable_id": "64a9f3b2c3d8e1f4a5b6c7d8",
    "payable_type": "string",
    "order_ref": "EXT-12345",
    "amount": 1,
    "balance": 1
  }
]

{
  "message": "string"
}

get/shop/reports/voucher-codes

Voucher codes report

listVoucherCodesReport

A paginated list of voucher codes issued at the given site, with filtering by status, code, face amount, balance, expiry date and creation date. Money values are integers in minor units. For large exports, use /shop/reports/voucher-codes/queue.

Query parameters

site_iduuidrequired
The site to list voucher codes for.
pageintegeroptional
The page to retrieve results from
per_pageintegeroptional
The number of voucher codes to return per page (1-100). Defaults to 30.
codestringoptional
Filter to voucher codes containing this substring (case-insensitive).
statusstring[]optional
A comma-separated list of voucher code statuses to filter on.
amountstringoptional
Filter by code face amount (in minor units). Supports a comparison operator prefix, e.g. >=10000, <5000, =2000, or a bare value (interpreted as equality).
balancestringoptional
Filter by remaining code balance (in minor units), using the same operator syntax as amount.
voucher_type_idstring[]optional
A comma-separated list of voucher type IDs to filter on.
fulfillment_statusstringoptional
Filter by voucher fulfillment status.
created_sincedate-timeoptional
Filter to voucher codes created on or after this date-time.
expired_range_fromdateoptional
Filter to voucher codes whose expiry date falls on or after this date.
expired_range_todateoptional
Filter to voucher codes whose expiry date falls strictly before this date.

Responses

200
The voucher codes were successfully retrieved.
400
The request failed.

curl "https://api.playground.try.be/shop/reports/voucher-codes?site_id=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/reports/voucher-codes?site_id=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/reports/voucher-codes?site_id=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/reports/voucher-codes?site_id=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/reports/voucher-codes?site_id=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)
}

The voucher codes were successfully retrieved.

{
  "data": [
    {
      "id": "64a9f3b2c3d8e1f4a5b6c7d8",
      "code": "TRYBE-ABC123",
      "status": "issued",
      "valid_from_date": "2026-01-15T09:30:00+00:00",
      "valid_to_date": "2026-01-15T09:30:00+00:00",
      "amount_type": "monetary",
      "amount": 5000,
      "balance": 5000,
      "currency": "gbp",
      "value": 1,
      "partially_redeemable": false,
      "imported": false,
      "fulfillment_status": "string",
      "voucher_type": {
        "id": "64a9f3b2c3d8e1f4a5b6c7d8",
        "name": "£50 Spa Day Voucher"
      },
      "recipient": {},
      "delivery": {},
      "order": {},
      "redemptions": [
        {
          "payment_id": "64a9f3b2c3d8e1f4a5b6c7d8",
          "amount": 1,
          "refunded_amount": 1,
          "paid_at": "2026-01-15T09:30:00+00:00",
          "payable_id": "64a9f3b2c3d8e1f4a5b6c7d8",
          "order_ref": "EXT-12345"
        }
      ],
      "created_at": "2026-01-15T09:30:00+00:00",
      "issued_at": "2026-01-15T09:30:00+00: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": "string"
}

get/shop/reports/voucher-codes/queue

Queue an export of the voucher codes report

queueVoucherCodesExport

Queues a CSV export of the voucher codes report to be generated asynchronously. Use this in preference to the synchronous endpoint when issuing a large number of codes.

Query parameters

site_iduuidrequired
The site to list voucher codes for.
codestringoptional
Filter to voucher codes containing this substring (case-insensitive).
statusstring[]optional
A comma-separated list of voucher code statuses to filter on.
amountstringoptional
Filter by code face amount (in minor units). Supports a comparison operator prefix, e.g. >=10000, <5000, =2000, or a bare value (interpreted as equality).
balancestringoptional
Filter by remaining code balance (in minor units), using the same operator syntax as amount.
voucher_type_idstring[]optional
A comma-separated list of voucher type IDs to filter on.
fulfillment_statusstringoptional
Filter by voucher fulfillment status.
created_sincedate-timeoptional
Filter to voucher codes created on or after this date-time.
expired_range_fromdateoptional
Filter to voucher codes whose expiry date falls on or after this date.
expired_range_todateoptional
Filter to voucher codes whose expiry date falls strictly before this date.

Responses

200
The job was successfully queued
400
The request failed.

curl "https://api.playground.try.be/shop/reports/voucher-codes/queue?site_id=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/reports/voucher-codes/queue?site_id=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/reports/voucher-codes/queue?site_id=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/reports/voucher-codes/queue?site_id=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/reports/voucher-codes/queue?site_id=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)
}

The job was successfully queued

{
  "data": {
    "id": "00000000-0000-0000-0000-000000000000",
    "status": "pending",
    "output": {},
    "created_at": "2023-11-07T00:00:00+00:00",
    "updated_at": "2023-11-07T01:00:00+00:00"
  }
}

{
  "message": "string"
}

get/shop/exports/appointment-types

Queue an export of appointment types

queueAppointmentTypesExport

Queues an asynchronous CSV export of every active AppointmentType at the given site, including pricing, durations, resource requirements, and visibility flags. Use this to back up your catalogue before bulk edits, or to feed appointment data into an external analytics tool.

The response is a QueuedJob whose output.url will eventually contain a signed download URL once the export has completed. Poll the job (or subscribe to webhook notifications) until status is complete.

Requires the SETTINGS_VIEW permission on the site.

Query parameters

site_idstringrequired
Filter results by the site they belong to

Responses

200
The job was successfully queued
401
The user is unauthenticated
403
The authenticated user does not have permission.

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

const response = await fetch('https://api.playground.try.be/shop/exports/appointment-types?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/exports/appointment-types?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/exports/appointment-types?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/exports/appointment-types?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 job was successfully queued

{
  "data": {
    "id": "00000000-0000-0000-0000-000000000000",
    "status": "pending",
    "output": {},
    "created_at": "2023-11-07T00:00:00+00:00",
    "updated_at": "2023-11-07T01:00:00+00:00"
  }
}

{
  "message": "Unauthenticated"
}

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

get/shop/exports/area-booking-types

Queue an export of area booking types

queueAreaBookingTypesExport

Queues an asynchronous CSV export of every active AreaBookingType at the given site (e.g. cabana hire, treatment-area rentals). The file lists prices, durations, capacities, and the bookable areas each type is offered against.

The response is a QueuedJob. Poll until status is complete then read output.url for the signed download.

Requires the SETTINGS_VIEW permission on the site.

Query parameters

site_idstringrequired
Filter results by the site they belong to

Responses

200
The job was successfully queued
401
The user is unauthenticated
403
The authenticated user does not have permission.

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

const response = await fetch('https://api.playground.try.be/shop/exports/area-booking-types?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/exports/area-booking-types?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/exports/area-booking-types?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/exports/area-booking-types?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 job was successfully queued

{
  "data": {
    "id": "00000000-0000-0000-0000-000000000000",
    "status": "pending",
    "output": {},
    "created_at": "2023-11-07T00:00:00+00:00",
    "updated_at": "2023-11-07T01:00:00+00:00"
  }
}

{
  "message": "Unauthenticated"
}

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

get/shop/exports/package-types

Queue an export of packages

queuePackageTypesExport

Queues an asynchronous CSV export of every active Package at the given site, including pricing, validity, item choices, and each package's enabled offerings. Useful for catalogue audits before a pricing run or when migrating to a new site.

The response is a QueuedJob; the export file appears at output.url once status becomes complete.

Requires the SETTINGS_VIEW permission on the site.

Query parameters

site_idstringrequired
Filter results by the site they belong to

Responses

200
The job was successfully queued
401
The user is unauthenticated
403
The authenticated user does not have permission.

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

const response = await fetch('https://api.playground.try.be/shop/exports/package-types?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/exports/package-types?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/exports/package-types?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/exports/package-types?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 job was successfully queued

{
  "data": {
    "id": "00000000-0000-0000-0000-000000000000",
    "status": "pending",
    "output": {},
    "created_at": "2023-11-07T00:00:00+00:00",
    "updated_at": "2023-11-07T01:00:00+00:00"
  }
}

{
  "message": "Unauthenticated"
}

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

get/shop/exports/retail-products

Queue an export of retail products

queueRetailProductsExport

Queues an asynchronous CSV export of every retail Product at the given site, including SKU, barcode, pricing, tax configuration, stock-tracking flags, and brand assignments. The resulting file is suitable for re-import into an inventory or accounting system.

The response is a QueuedJob; download the export from output.url once status becomes complete.

Requires the SETTINGS_VIEW permission on the site.

Query parameters

site_idstringrequired
Filter results by the site they belong to

Responses

200
The job was successfully queued
401
The user is unauthenticated
403
The authenticated user does not have permission.

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

const response = await fetch('https://api.playground.try.be/shop/exports/retail-products?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/exports/retail-products?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/exports/retail-products?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/exports/retail-products?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 job was successfully queued

{
  "data": {
    "id": "00000000-0000-0000-0000-000000000000",
    "status": "pending",
    "output": {},
    "created_at": "2023-11-07T00:00:00+00:00",
    "updated_at": "2023-11-07T01:00:00+00:00"
  }
}

{
  "message": "Unauthenticated"
}

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

get/shop/exports/session-types

Queue an export of session types

queueSessionTypesExport

Queues an asynchronous CSV export of every active SessionType at the given site — scheduled classes, group activities, fitness sessions. The file includes capacities, base pricing, durations, and which categories the session belongs to.

The response is a QueuedJob. Poll its status until it is complete; the resulting download URL is in output.url.

Requires the SETTINGS_VIEW permission on the site.

Query parameters

site_idstringrequired
Filter results by the site they belong to

Responses

200
The job was successfully queued
401
The user is unauthenticated
403
The authenticated user does not have permission.

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

const response = await fetch('https://api.playground.try.be/shop/exports/session-types?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/exports/session-types?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/exports/session-types?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/exports/session-types?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 job was successfully queued

{
  "data": {
    "id": "00000000-0000-0000-0000-000000000000",
    "status": "pending",
    "output": {},
    "created_at": "2023-11-07T00:00:00+00:00",
    "updated_at": "2023-11-07T01:00:00+00:00"
  }
}

{
  "message": "Unauthenticated"
}

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

get/shop/reports/deposit-ledger

Get the deposit ledger report

getDepositLedgerReport

Returns the deposit-ledger report — a tabular summary of voucher and credit deposit positions across the site/date range. The response is shaped for display rather than programmatic consumption; consider GET /shop/reports/deposit-ledger-v2/list for a structured per-payable breakdown.

Pass Accept: text/csv to receive the same report as a CSV download instead of a JSON TableReport.

Query parameters

dateFromdate-timeoptional
A date string to retrieve results from
dateTodate-timeoptional
A date string to retrieve results to
site_iduuidoptional
Scope the deposit-ledger report to a single Site. Omit to include every site the caller has reporting access to. Useful when the report is being run on behalf of a multi-site brand.

Responses

200
The deposit ledger report was successfully retrieved.
400
The request failed.

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

const response = await fetch('https://api.playground.try.be/shop/reports/deposit-ledger', {
  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/reports/deposit-ledger",
    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/reports/deposit-ledger', [
    '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/reports/deposit-ledger", 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 deposit ledger report was successfully retrieved.

{
  "data": {
    "rows": [
      {
        "cells": [
          {
            "format": "th",
            "value": "string"
          }
        ]
      }
    ]
  }
}

{
  "message": "string"
}

get/shop/reports/deposit-ledger/queue

Queue the deposit ledger report (v1)

queueDepositLedgerReport

Queues an asynchronous build of the v1 deposit-ledger report. Returns a QueuedJob whose output will contain a download URL once processing finishes. Exposed at the legacy v1 URL alongside the v2 counterpart at /shop/reports/deposit-ledger-v2/queue for callers that have not yet migrated.

Query parameters

dateFromdate-timeoptional
A date string to retrieve results from
dateTodate-timeoptional
A date string to retrieve results to
site_iduuidoptional
Scope the deposit-ledger report to a single Site. Omit to include every site the caller has reporting access to. Useful when the report is being run on behalf of a multi-site brand.

Responses

200
The job was successfully queued
400
The request failed.

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

const response = await fetch('https://api.playground.try.be/shop/reports/deposit-ledger/queue', {
  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/reports/deposit-ledger/queue",
    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/reports/deposit-ledger/queue', [
    '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/reports/deposit-ledger/queue", 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 job was successfully queued

{
  "data": {
    "id": "00000000-0000-0000-0000-000000000000",
    "status": "pending",
    "output": {},
    "created_at": "2023-11-07T00:00:00+00:00",
    "updated_at": "2023-11-07T01:00:00+00:00"
  }
}

{
  "message": "string"
}

get/shop/reports/trybe-payments-balance/queue

Queue the Trybe Payments balance report

queueTrybePaymentsBalanceReport

Queues an asynchronous build of the Trybe Payments balance report for the given site and date range. Returns a QueuedJob whose output will carry a download URL once the job completes. Use this for larger date ranges that the synchronous endpoint (GET /shop/reports/trybe-payments-balance) would time out on.

Query parameters

site_iduuidrequired
The site whose Trybe Payments balance is being reported on.
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.

Responses

200
The job was successfully queued
400
The request failed.

curl "https://api.playground.try.be/shop/reports/trybe-payments-balance/queue?site_id=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/reports/trybe-payments-balance/queue?site_id=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/reports/trybe-payments-balance/queue?site_id=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/reports/trybe-payments-balance/queue?site_id=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/reports/trybe-payments-balance/queue?site_id=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)
}

The job was successfully queued

{
  "data": {
    "id": "00000000-0000-0000-0000-000000000000",
    "status": "pending",
    "output": {},
    "created_at": "2023-11-07T00:00:00+00:00",
    "updated_at": "2023-11-07T01:00:00+00:00"
  }
}

{
  "message": "string"
}