> This page is for Entria API Reference.

> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://docs.navipartner.com/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://docs.navipartner.com/_mcp/server.

# Get ticket availability and schedules for a date range

GET https://api.entria.app/api/schedules/ticket

Returns the dates, timeslots, remaining capacity, and indicative prices for ticket and package products between fromDate and toDate. A package lists the start times every one of its components can honour, priced as the sum of its components (see items). This is availability data with no customer context, so it is cheap to call and safe to cache; use it to build a calendar or date-picker. It does not reserve capacity and the prices shown do not reflect any customer-specific discounts. Note that a single product can have several admissions, each with its own schedule and price. Scope the search with the category and skus query filters; one of the two is required, and skus alone searches every category. An unknown category or SKU is not an error, it just returns no results.

Reference: https://docs.navipartner.com/entria-api/entria-api-reference/ticketing/get-ticketing-get-schedules

## Request

### Query parameters

- `fromDate` (date, required) — Start of the date range to check, in YYYY-MM-DD format. Required, and not after toDate. The range from fromDate to toDate cannot exceed 60 days.
- `toDate` (date, required) — End of the date range to check, in YYYY-MM-DD format. Required, and not before fromDate. The range from fromDate to toDate cannot exceed 60 days.
- `category` (string, optional, nullable) — Medusa category handle to filter by, e.g. tickets or memberships. Matched exactly against the product's own categories, so a parent handle does not match its children. Omit it to match products in any category — skus must then scope the search. Either this or skus is required.
- `skus` (string, optional, nullable) — Comma-separated list of product SKUs to filter by. Either this or category is required.
- `withCapacity` (enum, optional) — Whether capacity must be realtime. Defaults to true: capacity-tracked products are read live from Business Central (60s edge cache), so `remainingCapacity` is current and sold-out slots are omitted. Pass false when the caller needs only times and prices — a "from" price preview, a calendar of opening days — and products answer from the schedule index instead, which is cheaper and cached longer. NOTE what the index cannot say: it stores no capacity count, so such a response carries no `remainingCapacity`, never reports SOLD_OUT, and still lists slots that are sold out. Do not price or gate a purchase on it. Products without capacity control are unaffected and answer from the index either way.
  - Allowed values: `true`, `false`

### Headers

- `x-entria` (string, required) — Identifies which store this request is for. Required on every store-scoped route. It is not authentication and not a secret — it grants no privileges and is safe to send from a browser. You receive the value once your Entria backend has been created and configured. Missing header returns 400; an unknown store returns 404.

## Response

### 200

Dates in the requested range, each with the products available on that date, their timeslots, indicative price, and — for capacity-tracked products when `withCapacity` is not false — remaining capacity.

- `map from string to map from string to ApiSchedulesTicketGetResponsesContentApplicationJsonSchema`

## Errors

### 400 Bad Request Error

Invalid date range: a missing, malformed or impossible date (2026-09-31 is not a real date), a reversed range, a range entirely in the past, or a range longer than 60 days. Also returned when neither category nor skus is given, since that would search the whole catalog. An unknown category or SKU is not a 400 — it returns 200 with no results. A failure caught by the request schema carries code VALIDATION_ERROR and a per-field details array; the rest carry error alone.

- `error` (string, required)
- `code` (string, optional)
- `details` (list of ErrorResponseDetailsItems, optional) — Per-field validation failures; present when code is VALIDATION_ERROR.
- `success` (boolean, optional, deprecated) — Deprecated. Use code === VALIDATION_ERROR.
- `errors` (list of any, optional, deprecated) — Deprecated. Raw zod issues; use details instead.

## Types

### ApiSchedulesTicketGetResponsesContentApplicationJsonSchema

- `available` (enum, required)
  - Allowed values: `NOT_AVAILABLE`, `AVAILABLE`, `CLOSED`, `SOLD_OUT`
- `schedules` (list of ApiSchedulesTicketGetResponsesContentApplicationJsonSchemaSchedulesItems, required)
- `error` (string, optional)

### ErrorResponseDetailsItems

- `path` (string, required)
- `message` (string, required)

### ApiSchedulesTicketGetResponsesContentApplicationJsonSchemaSchedulesItems

- `scheduleNumber` (double, required)
- `scheduleCode` (string, required)
- `admissionCode` (string, required)
- `startTime` (string, required)
- `endTime` (string, required)
- `remainingCapacity` (double, required)
- `price` (double, required)
- `basePrice` (double, required)
- `currencyCode` (string, required)
- `scheduleSelection` (enum, optional) — BC decides who picks the slot; absent = BC did not say, treat as user-selected
  - Allowed values: `userSelectedSchedule`, `nextAvailableSchedule`
- `items` (list of ApiSchedulesTicketGetResponsesContentApplicationJsonSchemaSchedulesItemsItemsItems, optional)

### ApiSchedulesTicketGetResponsesContentApplicationJsonSchemaSchedulesItemsItemsItems

- `sku` (string, required)
- `qty` (double, required)
- `price` (double, required)
- `basePrice` (double, required)

## Examples

**Response**

```json
{}
```

**SDK Code**

```python
import requests

url = "https://api.entria.app/api/schedules/ticket"

querystring = {"fromDate":"fromDate","toDate":"toDate"}

headers = {"x-entria": "x-entria"}

response = requests.get(url, headers=headers, params=querystring)

print(response.json())
```

```javascript
const url = 'https://api.entria.app/api/schedules/ticket?fromDate=fromDate&toDate=toDate';
const options = {method: 'GET', headers: {'x-entria': 'x-entria'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://api.entria.app/api/schedules/ticket?fromDate=fromDate&toDate=toDate"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("x-entria", "x-entria")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby
require 'uri'
require 'net/http'

url = URI("https://api.entria.app/api/schedules/ticket?fromDate=fromDate&toDate=toDate")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["x-entria"] = 'x-entria'

response = http.request(request)
puts response.read_body
```

```java
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.get("https://api.entria.app/api/schedules/ticket?fromDate=fromDate&toDate=toDate")
  .header("x-entria", "x-entria")
  .asString();
```

```php
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://api.entria.app/api/schedules/ticket?fromDate=fromDate&toDate=toDate', [
  'headers' => [
    'x-entria' => 'x-entria',
  ],
]);

echo $response->getBody();
```

```csharp
using RestSharp;

var client = new RestClient("https://api.entria.app/api/schedules/ticket?fromDate=fromDate&toDate=toDate");
var request = new RestRequest(Method.GET);
request.AddHeader("x-entria", "x-entria");
IRestResponse response = client.Execute(request);
```

```swift
import Foundation

let headers = ["x-entria": "x-entria"]

let request = NSMutableURLRequest(url: NSURL(string: "https://api.entria.app/api/schedules/ticket?fromDate=fromDate&toDate=toDate")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```