# Check Asset Availability Before You Reserve

> Check whether a Capital Asset can be reserved for your dates, or how much Collateral is available on checkout day.

This is the Markdown copy of https://api.exhibitday.com/Help/V1?guide=check-asset-availability for AI tools. Code examples are in curl, JavaScript, Python and C#; the help page shows all 8 languages, and https://api.exhibitday.com/llms-full.txt has the complete reference in one file. Index of all pages: https://api.exhibitday.com/llms.txt

Check whether a Capital Asset can be reserved for your dates, or how much Collateral is available on checkout day.

Example use case

You're preparing for a trade show. You need a display monitor from January 14 through January 17 and 100 tote bags from the warehouse on January 14.

What you'll end up with

The monitor's availability under its reservation policy and a count of the tote bags available on checkout day.

Before you start

Have a workspace API key and the IDs of two Active Assets your workspace owns or that are currently shared with it. In ExhibitDay, find them on the Assets page in the top menu.

Good to know

A Single-Unit Capital Asset tracks one item, like a display monitor. A Collateral / Multi-Quantity Item tracks units, like tote bags or brochures. You check them in different ways.

## At a glance

Time to try

About 5 minutes

Effect on your data

Read-only

Endpoints

1

The check leaves reservations and inventory unchanged. ExhibitDay checks availability and access again when you save a reservation.

- [`GET /v1/assets/availability`](https://api.exhibitday.com/Help/V1?epf=5&amp;topic=availability#get-v1-assets-availability)

## How it works

1. For the Capital Asset, supply the inclusive checkout and return dates. Read the availability result and its reservation policy.
2. For the Collateral item, supply the checkout date. Compare your planned quantity with the count at the Storage Location you'll use.

## Check the monitor and tote bags

## Step 1: Check a Capital Asset for a period

Send `asset_type_id=1` with `start_date` and `end_date`. Use the dates the monitor will be out of storage, including setup or return days as needed.

```bash
curl -X GET "https://api.exhibitday.com/v1/assets/availability?asset_id=12345&asset_type_id=1&start_date=2030-01-14&end_date=2030-01-17" -H "Authorization: Bearer YOUR_API_KEY"
```

**Example response (shortened)**

```json
{
  "asset_reservation_policy_id": 2,
  "is_available_under_reservation_policy": true,
  "overlapping_reservation_count": 1,
  "policy_conflict_count": 0
}
```

**Check:** The existing reservation returns the monitor on January 14, when you want to check it out. The dates overlap, but the Moderate policy allows that day. Use `is_available_under_reservation_policy` to decide whether the proposed period passes the check. Coordinate any same-day handoff with the team.

| Capital Asset reservation policy | Which days an existing reservation blocks |
| --- | --- |
| 1 · Strict | Every day from checkout through return, including both dates. |
| 2 · Moderate | Only the days between checkout and return. A one- or two-day reservation blocks no days. |
| 3 · Liberal | No days. Check the overlap count and coordinate with the people using the Asset. |

To see the setting in ExhibitDay, open the Capital Asset and select **Reservation Policy**.

## Step 2: Check a Collateral quantity on checkout day

Send `asset_type_id=2` and `as_of_date` for the day you need the tote bags. Leave out `start_date` and `end_date`. Collateral uses the Liberal reservation policy, so compare the quantity in storage with what you need. If you omit `as_of_date`, the API uses today in your workspace time zone.

```bash
curl -X GET "https://api.exhibitday.com/v1/assets/availability?asset_id=67890&asset_type_id=2&as_of_date=2030-01-14" -H "Authorization: Bearer YOUR_API_KEY"
```

**Example response (shortened)**

```json
{
  "as_of_date": "2030-01-14",
  "quantity_available_in_storage": 125,
  "storage_locations": [
    { "id": 2001, "name": "Main Warehouse", "quantity_available_in_storage": 80 },
    { "id": 2002, "name": "Office", "quantity_available_in_storage": 45 }
  ]
}
```

**Check:** There are 125 bags across both locations, but only 80 at the Main Warehouse. Plan for the remaining 20 before you reserve. To check the warehouse on its own, add `storage_location_id=2001`. Use a Storage Location that belongs to the workspace that owns the Asset.

## Try it

## Before running the example

| Variable | What to put in it | Required? |
| --- | --- | --- |
| `EXHIBITDAY_API_KEY` | Your workspace API key. | Yes |
| `EXHIBITDAY_CAPITAL_ASSET_ID` | The Capital Asset ID. | Yes |
| `EXHIBITDAY_CAPITAL_START_DATE` | The proposed Capital checkout date in YYYY-MM-DD format. | Yes |
| `EXHIBITDAY_CAPITAL_RETURN_DATE` | The proposed Capital return date in YYYY-MM-DD format, on or after checkout. | Yes |
| `EXHIBITDAY_COLLATERAL_ASSET_ID` | The Collateral item ID. | Yes |
| `EXHIBITDAY_COLLATERAL_CHECKOUT_DATE` | The day you need the units, in YYYY-MM-DD format. | Yes |

The complete example runs both checks and prints the two responses. To check just one type, use the corresponding request above.

## Bash

```
export EXHIBITDAY_API_KEY='YOUR_API_KEY'
export EXHIBITDAY_CAPITAL_ASSET_ID='12345'
export EXHIBITDAY_CAPITAL_START_DATE='2030-01-14'
export EXHIBITDAY_CAPITAL_RETURN_DATE='2030-01-17'
export EXHIBITDAY_COLLATERAL_ASSET_ID='67890'
export EXHIBITDAY_COLLATERAL_CHECKOUT_DATE='2030-01-14'
```

## PowerShell

```
$env:EXHIBITDAY_API_KEY = 'YOUR_API_KEY'
$env:EXHIBITDAY_CAPITAL_ASSET_ID = '12345'
$env:EXHIBITDAY_CAPITAL_START_DATE = '2030-01-14'
$env:EXHIBITDAY_CAPITAL_RETURN_DATE = '2030-01-17'
$env:EXHIBITDAY_COLLATERAL_ASSET_ID = '67890'
$env:EXHIBITDAY_COLLATERAL_CHECKOUT_DATE = '2030-01-14'
```

## Complete example program

Code Samples

```bash
#!/usr/bin/env bash
# Requires Bash, curl and Python3. No API key is written into the program.
python3 - <<'EXHIBITDAY_PY'
# Python 3; standard library only. Set EXHIBITDAY_API_KEY before running.
import http.client
import json
import os
import re
import time
import urllib.error
import urllib.parse
import urllib.request

BASE = "https://api.exhibitday.com/v1"
SPEC = json.loads("{\"preserveNumbers\":true,\"requests\":{\"capital\":{\"method\":\"GET\",\"path\":\"/assets/availability\"},\"collateral\":{\"method\":\"GET\",\"path\":\"/assets/availability\"}}}")
API_KEY = os.environ["EXHIBITDAY_API_KEY"]
if any(ord(char) < 32 or ord(char) > 126 for char in API_KEY):
    raise RuntimeError("Use the API key as one ASCII header value without control characters")
if not API_KEY.strip():
    raise RuntimeError("Set EXHIBITDAY_API_KEY")

def decode_json(text):
    if SPEC["preserveNumbers"]:
        # Quote JSON NUMBER tokens, never text inside a JSON string, to keep CSV decimals exact.
        text = re.sub(r'"(?:\\.|[^"\\])*"|-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?',
                      lambda m: m[0] if m[0].startswith('"') else json.dumps(m[0]), text)
    return json.loads(text)

from pathlib import Path
# This terminal version uses curl for HTTP and Python's standard library for JSON/CSV.
import subprocess
import tempfile

def transport(method, url, headers, data):
    with tempfile.TemporaryDirectory(prefix="exhibitday-guide-") as directory:
        folder = Path(directory)
        # curl may leave no output file for a valid bodyless304 response.
        (folder / "body").write_bytes(b"")
        command = ["curl", "--disable", "--silent", "--show-error", "--request", method, "--url", url,
                   "--max-time", "30", "--dump-header", str(folder / "headers"),
                   "--output", str(folder / "body"), "--write-out", "%{http_code}"]
        for name, value in headers.items():
            command += ["--header", name + ": " + value]
        if data is not None:
            (folder / "request").write_bytes(data)
            command += ["--data-binary", "@" + str(folder / "request")]
        result = subprocess.run(command, capture_output=True, text=True)
        if result.returncode:
            raise urllib.error.URLError(result.stderr.strip())
        response_headers = {}
        blocks = (folder / "headers").read_text(encoding="iso-8859-1").replace("\r\n", "\n").strip().split("\n\n")
        for line in blocks[-1].splitlines()[1:]:
            name, separator, value = line.partition(":")
            if separator:
                response_headers[name] = value.strip()
        return int(result.stdout), (folder / "body").read_bytes(), response_headers


class ApiError(RuntimeError):
    """An API error response. Branch on error_code (and status), never on the message text.
    uncertain is True when a PATCH or DELETE got no response or a server error: it may or may not have been applied."""
    def __init__(self, status, body, uncertain=False):
        self.status = status
        self.uncertain = uncertain
        self.error_code = body.get("error_code") if isinstance(body, dict) else None
        super().__init__(f"{body.get('error_code')} {body.get('error_params')}: {body.get('errors')} (request {body.get('request_id')})"
                         if isinstance(body, dict) else "HTTP " + str(status) if status else "No response")

def call(name, params=None, body=None, key=None):
    route = SPEC["requests"][name]
    headers = {"Authorization": "Bearer " + API_KEY, "Accept": "application/json"}
    if route["method"] == "POST":
        if not key: raise RuntimeError("Save a create key before sending POST")
        headers["Idempotency-Key"] = key
    data = None if body is None else json.dumps(body).encode("utf-8")
    if data is not None:
        headers["Content-Type"] = "application/json"
    query = urllib.parse.urlencode(params or {})
    url = BASE + route["path"] + ("?" + query if query else "")
    # Only GET has automatic retries in this workflow. A PATCH or DELETE that got no response or a
    # server error is never resent blindly: it may already have been applied, so the caller reads the record first.
    resend = route["method"] == "GET"
    for attempt in range(5):
        try:
            status, raw, response_headers = transport(route["method"], url, headers, data)
        except (urllib.error.URLError, TimeoutError, ConnectionError, http.client.HTTPException):
            if not resend:
                raise ApiError(0, None, uncertain=True)
            if attempt == 4:
                raise
            time.sleep(2 ** attempt)
            continue
        response_headers = {k.lower(): v for k, v in response_headers.items()}
        result = None
        if status != 304 and raw:
            try:
                result = decode_json(raw.decode("utf-8"))
            except (ValueError, UnicodeError):
                if status < 400:
                    raise RuntimeError("Expected a JSON success response")
        if status >= 500 and not resend:
            raise ApiError(status, result, uncertain=True)
        retry = resend and (status == 429 or status >= 500)
        if retry:
            if attempt == 4:
                raise RuntimeError("Retry limit reached; check the request outcome before starting a new create")
            delay = response_headers.get("retry-after", str(2 ** attempt))
            time.sleep(max(0, float(delay)))
            continue
        if status >= 400:
            raise ApiError(status, result)
        return {"status": status, "body": result, "headers": response_headers, "raw": raw}
    raise RuntimeError("Retry limit reached")


def positive_id(value):
    if not re.fullmatch(r"[1-9][0-9]*", value) or int(value) > 9223372036854775807: raise RuntimeError("Use a positive record ID")
    return value

def print_value(value):
    print(value if isinstance(value, str) else json.dumps(value, ensure_ascii=False))

def required(name):
    value = os.environ.get(name)
    if value is None or not value.strip(): raise RuntimeError("Set " + name)
    return value


def main():
    capital_id = positive_id(required("EXHIBITDAY_CAPITAL_ASSET_ID"))
    collateral_id = positive_id(required("EXHIBITDAY_COLLATERAL_ASSET_ID"))
    capital_start = required("EXHIBITDAY_CAPITAL_START_DATE")
    capital_return = required("EXHIBITDAY_CAPITAL_RETURN_DATE")
    collateral_date = required("EXHIBITDAY_COLLATERAL_CHECKOUT_DATE")
    capital_response = call("capital", {"asset_id": capital_id, "asset_type_id": "1", "start_date": capital_start, "end_date": capital_return}, None, None)
    print_value(capital_response["raw"].decode("utf-8"))
    collateral_response = call("collateral", {"asset_id": collateral_id, "asset_type_id": "2", "as_of_date": collateral_date}, None, None)
    print_value(collateral_response["raw"].decode("utf-8"))


if __name__ == "__main__":
    main()

EXHIBITDAY_PY
```

```javascript
// Server-side Node.js with fetch; built-in modules only. Set EXHIBITDAY_API_KEY.
const BASE = "https://api.exhibitday.com/v1";
const SPEC = JSON.parse("{\"preserveNumbers\":true,\"requests\":{\"capital\":{\"method\":\"GET\",\"path\":\"/assets/availability\"},\"collateral\":{\"method\":\"GET\",\"path\":\"/assets/availability\"}}}");
const API_KEY = process.env.EXHIBITDAY_API_KEY;
if (!API_KEY || !API_KEY.trim()) throw new Error("Set EXHIBITDAY_API_KEY");
if (/[^\x20-\x7e]/.test(API_KEY)) throw new Error("Use the API key as one ASCII header value without control characters");
const sleep = milliseconds => new Promise(resolve => setTimeout(resolve, milliseconds));

function decodeJson(text) {
  if (SPEC.preserveNumbers) {
    // Keep raw JSON number tokens exact for CSV; quoted JSON strings remain unchanged.
    text = text.replace(/"(?:\\.|[^"\\])*"|-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?/g,
      token => token.startsWith('"') ? token : JSON.stringify(token));
  }
  return JSON.parse(text);
}
// An API error response. Branch on errorCode (and status), never on the message text.
// uncertain is true when a PATCH or DELETE got no response or a server error: it may or may not have been applied.
class ApiError extends Error {
  constructor(status, result, uncertain = false) {
    super(result ? JSON.stringify({ error_code: result.error_code, errors: result.errors,
      error_params: result.error_params, request_id: result.request_id }) : status ? "HTTP " + status : "No response");
    this.status = status;
    this.errorCode = result ? result.error_code : undefined;
    this.uncertain = uncertain;
  }
}
async function call(name, params = {}, body = null, key = null) {
  const route = SPEC.requests[name];
  const headers = { Authorization: "Bearer " + API_KEY, Accept: "application/json" };
  if (route.method === "POST") {
    if (!key) throw new Error("Save a create key before sending POST");
    headers["Idempotency-Key"] = key;
  }
  const data = body === null ? undefined : JSON.stringify(body);
  if (data !== undefined) headers["Content-Type"] = "application/json";
  const query = new URLSearchParams(params).toString();
  const url = BASE + route.path + (query ? "?" + query : "");
  // Only GET has automatic retries in this workflow. A PATCH or DELETE that got no response or a
  // server error is never resent blindly: it may already have been applied, so the caller reads the record first.
  const resend = route.method === "GET";
  for (let attempt = 0; attempt < 5; attempt++) {
    const controller = new AbortController();
    const timer = setTimeout(() => controller.abort(), 30000);
    let response, raw;
    try {
      response = await fetch(url, { method: route.method, headers, body: data, signal: controller.signal, redirect: "error" });
      raw = await response.text();
    } catch (error) {
      if (!resend) throw new ApiError(0, null, true);
      if (attempt === 4) throw error;
      await sleep(1000 * 2 ** attempt);
      continue;
    } finally { clearTimeout(timer); }
    const resultHeaders = {};
    response.headers.forEach((value, name) => { resultHeaders[name.toLowerCase()] = value; });
    let result = null;
    if (response.status !== 304 && raw) {
      try { result = decodeJson(raw); }
      catch (error) { if (response.status < 400) throw new Error("Expected a JSON success response"); }
    }
    if (response.status >= 500 && !resend) throw new ApiError(response.status, result, true);
    const retry = resend && (response.status === 429 || response.status >= 500);
    if (retry) {
      if (attempt === 4) throw new Error("Retry limit reached; check the outcome before starting a new create");
      const requested = Number(resultHeaders["retry-after"]);
      await sleep(1000 * (Number.isFinite(requested) && requested >= 0 ? requested : 2 ** attempt));
      continue;
    }
    if (response.status >= 400) throw new ApiError(response.status, result);
    return { status: response.status, body: result, headers: resultHeaders, raw };
  }
  throw new Error("Retry limit reached");
}

function positive_id(value) { if (!/^[1-9][0-9]*$/.test(value) || BigInt(value) > 9223372036854775807n) throw new Error("Use a positive record ID"); return value; }

function print_value(value) { console.log(typeof value === "string" ? value : JSON.stringify(value)); }

function required(name) { const value = process.env[name]; if (value === undefined || !value.trim()) throw new Error("Set " + name); return value; }


async function main() {
    let capital_id = positive_id(required("EXHIBITDAY_CAPITAL_ASSET_ID"));
    let collateral_id = positive_id(required("EXHIBITDAY_COLLATERAL_ASSET_ID"));
    let capital_start = required("EXHIBITDAY_CAPITAL_START_DATE");
    let capital_return = required("EXHIBITDAY_CAPITAL_RETURN_DATE");
    let collateral_date = required("EXHIBITDAY_COLLATERAL_CHECKOUT_DATE");
    let capital_response = await call("capital", {"asset_id": capital_id, "asset_type_id": "1", "start_date": capital_start, "end_date": capital_return}, null, null);
    print_value(capital_response.raw);
    let collateral_response = await call("collateral", {"asset_id": collateral_id, "asset_type_id": "2", "as_of_date": collateral_date}, null, null);
    print_value(collateral_response.raw);

}
if (require.main === module) main().catch(error => { console.error(error.message); process.exitCode = 1; });
module.exports = { main };
```

```python
# Python 3; standard library only. Set EXHIBITDAY_API_KEY before running.
import http.client
import json
import os
import re
import time
import urllib.error
import urllib.parse
import urllib.request

BASE = "https://api.exhibitday.com/v1"
SPEC = json.loads("{\"preserveNumbers\":true,\"requests\":{\"capital\":{\"method\":\"GET\",\"path\":\"/assets/availability\"},\"collateral\":{\"method\":\"GET\",\"path\":\"/assets/availability\"}}}")
API_KEY = os.environ["EXHIBITDAY_API_KEY"]
if any(ord(char) < 32 or ord(char) > 126 for char in API_KEY):
    raise RuntimeError("Use the API key as one ASCII header value without control characters")
if not API_KEY.strip():
    raise RuntimeError("Set EXHIBITDAY_API_KEY")

def decode_json(text):
    if SPEC["preserveNumbers"]:
        # Quote JSON NUMBER tokens, never text inside a JSON string, to keep CSV decimals exact.
        text = re.sub(r'"(?:\\.|[^"\\])*"|-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?',
                      lambda m: m[0] if m[0].startswith('"') else json.dumps(m[0]), text)
    return json.loads(text)

class NoRedirect(urllib.request.HTTPRedirectHandler):
    def redirect_request(self, request, file, code, message, headers, new_url):
        return None

OPENER = urllib.request.build_opener(NoRedirect())

def transport(method, url, headers, data):
    request = urllib.request.Request(url, data=data, headers=headers, method=method)
    try:
        with OPENER.open(request, timeout=30) as response:
            return response.status, response.read(), dict(response.headers)
    except urllib.error.HTTPError as response:
        try:
            return response.code, response.read(), dict(response.headers)
        finally:
            response.close()


class ApiError(RuntimeError):
    """An API error response. Branch on error_code (and status), never on the message text.
    uncertain is True when a PATCH or DELETE got no response or a server error: it may or may not have been applied."""
    def __init__(self, status, body, uncertain=False):
        self.status = status
        self.uncertain = uncertain
        self.error_code = body.get("error_code") if isinstance(body, dict) else None
        super().__init__(f"{body.get('error_code')} {body.get('error_params')}: {body.get('errors')} (request {body.get('request_id')})"
                         if isinstance(body, dict) else "HTTP " + str(status) if status else "No response")

def call(name, params=None, body=None, key=None):
    route = SPEC["requests"][name]
    headers = {"Authorization": "Bearer " + API_KEY, "Accept": "application/json"}
    if route["method"] == "POST":
        if not key: raise RuntimeError("Save a create key before sending POST")
        headers["Idempotency-Key"] = key
    data = None if body is None else json.dumps(body).encode("utf-8")
    if data is not None:
        headers["Content-Type"] = "application/json"
    query = urllib.parse.urlencode(params or {})
    url = BASE + route["path"] + ("?" + query if query else "")
    # Only GET has automatic retries in this workflow. A PATCH or DELETE that got no response or a
    # server error is never resent blindly: it may already have been applied, so the caller reads the record first.
    resend = route["method"] == "GET"
    for attempt in range(5):
        try:
            status, raw, response_headers = transport(route["method"], url, headers, data)
        except (urllib.error.URLError, TimeoutError, ConnectionError, http.client.HTTPException):
            if not resend:
                raise ApiError(0, None, uncertain=True)
            if attempt == 4:
                raise
            time.sleep(2 ** attempt)
            continue
        response_headers = {k.lower(): v for k, v in response_headers.items()}
        result = None
        if status != 304 and raw:
            try:
                result = decode_json(raw.decode("utf-8"))
            except (ValueError, UnicodeError):
                if status < 400:
                    raise RuntimeError("Expected a JSON success response")
        if status >= 500 and not resend:
            raise ApiError(status, result, uncertain=True)
        retry = resend and (status == 429 or status >= 500)
        if retry:
            if attempt == 4:
                raise RuntimeError("Retry limit reached; check the request outcome before starting a new create")
            delay = response_headers.get("retry-after", str(2 ** attempt))
            time.sleep(max(0, float(delay)))
            continue
        if status >= 400:
            raise ApiError(status, result)
        return {"status": status, "body": result, "headers": response_headers, "raw": raw}
    raise RuntimeError("Retry limit reached")


def positive_id(value):
    if not re.fullmatch(r"[1-9][0-9]*", value) or int(value) > 9223372036854775807: raise RuntimeError("Use a positive record ID")
    return value

def print_value(value):
    print(value if isinstance(value, str) else json.dumps(value, ensure_ascii=False))

def required(name):
    value = os.environ.get(name)
    if value is None or not value.strip(): raise RuntimeError("Set " + name)
    return value


def main():
    capital_id = positive_id(required("EXHIBITDAY_CAPITAL_ASSET_ID"))
    collateral_id = positive_id(required("EXHIBITDAY_COLLATERAL_ASSET_ID"))
    capital_start = required("EXHIBITDAY_CAPITAL_START_DATE")
    capital_return = required("EXHIBITDAY_CAPITAL_RETURN_DATE")
    collateral_date = required("EXHIBITDAY_COLLATERAL_CHECKOUT_DATE")
    capital_response = call("capital", {"asset_id": capital_id, "asset_type_id": "1", "start_date": capital_start, "end_date": capital_return}, None, None)
    print_value(capital_response["raw"].decode("utf-8"))
    collateral_response = call("collateral", {"asset_id": collateral_id, "asset_type_id": "2", "as_of_date": collateral_date}, None, None)
    print_value(collateral_response["raw"].decode("utf-8"))


if __name__ == "__main__":
    main()
```

```csharp
// .NET 8 console program; standard library only. Set EXHIBITDAY_API_KEY.
#nullable disable
using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Net.Http;
using System.Text;
using System.Text.Json;
using System.Text.Json.Nodes;
using System.Threading.Tasks;

class Program
{
    static readonly string BaseUrl = "https://api.exhibitday.com/v1";
    static readonly JsonNode Spec = JsonNode.Parse("{\"preserveNumbers\":true,\"requests\":{\"capital\":{\"method\":\"GET\",\"path\":\"/assets/availability\"},\"collateral\":{\"method\":\"GET\",\"path\":\"/assets/availability\"}}}");
    static readonly string ApiKey = HeaderKey(Required("EXHIBITDAY_API_KEY"));
    static string HeaderKey(string value) { if(value.Any(c=>c<32||c>126))throw new Exception("Use the API key as one ASCII header value without control characters");return value; }
    static readonly HttpClient Client = new HttpClient(new HttpClientHandler { AllowAutoRedirect = false }) { Timeout = TimeSpan.FromSeconds(30) };
    internal static Func<HttpRequestMessage, Task<HttpResponseMessage>> Send = request => Client.SendAsync(request);
    sealed class Result { public int Status; public JsonNode Body; public Dictionary<string, string> Headers; public string Raw; }
    // An API error response. Branch on ErrorCode (and Status), never on the message text.
    // Uncertain is true when a PATCH or DELETE got no response or a server error: it may or may not have been applied.
    sealed class ApiException : Exception
    {
        public int Status { get; }
        public string ErrorCode { get; }
        public bool Uncertain { get; }
        public ApiException(int status, string errorCode, string message, bool uncertain = false) : base(message) { Status = status; ErrorCode = errorCode; Uncertain = uncertain; }
    }
    static string Required(string name)
    { var value = Environment.GetEnvironmentVariable(name); return string.IsNullOrWhiteSpace(value) ? throw new Exception("Set " + name) : value; }
    static string Text(JsonNode value) => value == null ? "" :
        value is JsonValue scalar && scalar.TryGetValue<string>(out var text) ? text : value.ToJsonString();
    static JsonObject Query(params (string Key, string Value)[] values)
    { var result = new JsonObject(); foreach (var value in values) result[value.Key] = value.Value; return result; }
    static async Task<Result> Call(string name, JsonObject query = null, JsonNode body = null,
        string key = null)
    {
        var route = Spec["requests"][name];
        var method = Text(route["method"]);
        var headers = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
            { ["Authorization"] = "Bearer " + ApiKey, ["Accept"] = "application/json" };
        if (method == "POST") { if (string.IsNullOrEmpty(key)) throw new Exception("Save a create key before sending POST"); headers["Idempotency-Key"] = key; }
        var data = body?.ToJsonString();
        var suffix = query == null ? "" : string.Join("&", query.Select(p => Uri.EscapeDataString(p.Key) + "=" + Uri.EscapeDataString(Text(p.Value))));
        var url = BaseUrl + Text(route["path"]) + (suffix.Length == 0 ? "" : "?" + suffix);
        // Only GET has automatic retries in this workflow. A PATCH or DELETE that got no response or a
        // server error is never resent blindly: it may already have been applied, so the caller reads the record first.
        var resend = method == "GET";
        for (var attempt = 0; attempt < 5; attempt++)
        {
            using var request = new HttpRequestMessage(new HttpMethod(method), url);
            foreach (var header in headers) request.Headers.TryAddWithoutValidation(header.Key, header.Value);
            if (data != null) request.Content = new StringContent(data, Encoding.UTF8, "application/json");
            HttpResponseMessage response;
            string raw;
            try { response = await Send(request); }
            catch (Exception error) when (error is HttpRequestException || error is TaskCanceledException)
            { if (!resend) throw new ApiException(0, null, "No response", true); if (attempt == 4) throw; await Task.Delay(TimeSpan.FromSeconds(Math.Pow(2, attempt))); continue; }
            using (response)
            {
                try { raw = await response.Content.ReadAsStringAsync(); }
                catch (Exception error) when (error is HttpRequestException || error is TaskCanceledException)
                { if (!resend) throw new ApiException(0, null, "No response", true); if (attempt == 4) throw; await Task.Delay(TimeSpan.FromSeconds(Math.Pow(2, attempt))); continue; }
                var status = (int)response.StatusCode;
                var resultHeaders = response.Headers.Concat(response.Content.Headers)
                    .ToDictionary(h => h.Key.ToLowerInvariant(), h => string.Join(", ", h.Value));
                JsonNode result = null;
                if (status != 304 && raw.Length > 0)
                {
                    try { result = JsonNode.Parse(raw); }
                    catch (JsonException) { if (status < 400) throw new Exception("Expected a JSON success response"); }
                }
                var errorBody = result as JsonObject;
                if (status >= 500 && !resend) throw new ApiException(status, errorBody == null ? null : Text(errorBody["error_code"]), "HTTP " + status, true);
                var retry = resend && (status == 429 || status >= 500);
                if (retry)
                {
                    if (attempt == 4) throw new Exception("Retry limit reached; check the outcome before starting a new create");
                    var seconds = Math.Pow(2, attempt);
                    if (resultHeaders.TryGetValue("retry-after", out var requested) &&
                        double.TryParse(requested, NumberStyles.Float, CultureInfo.InvariantCulture, out var delay) &&
                        double.IsFinite(delay) && delay >= 0) seconds = delay;
                    await Task.Delay(TimeSpan.FromSeconds(seconds)); continue;
                }
                if (status >= 400) throw new ApiException(status, errorBody == null ? null : Text(errorBody["error_code"]), errorBody == null ? "HTTP " + status :
                    $"{Text(errorBody["error_code"])} {errorBody["error_params"]}: {errorBody["errors"]} (request {Text(errorBody["request_id"])})");
                return new Result { Status = status, Body = result, Headers = resultHeaders, Raw = raw };
            }
        }
        throw new Exception("Retry limit reached");
    }
        static string PositiveId(string value) { if(string.IsNullOrEmpty(value)||value[0]=='0'||!value.All(c=>c>='0'&&c<='9')||!long.TryParse(value,NumberStyles.None,CultureInfo.InvariantCulture,out var id)||id<=0)throw new Exception("Use a positive record ID");return value; }

    static void PrintValue(object value) => Console.WriteLine(value is string text ? text : JsonSerializer.Serialize(value));


    internal static async Task Run()
    {
        var capital_id = PositiveId(Required("EXHIBITDAY_CAPITAL_ASSET_ID"));
        var collateral_id = PositiveId(Required("EXHIBITDAY_COLLATERAL_ASSET_ID"));
        var capital_start = Required("EXHIBITDAY_CAPITAL_START_DATE");
        var capital_return = Required("EXHIBITDAY_CAPITAL_RETURN_DATE");
        var collateral_date = Required("EXHIBITDAY_COLLATERAL_CHECKOUT_DATE");
        var capital_response = await Call("capital", new JsonObject { ["asset_id"] = capital_id, ["asset_type_id"] = "1", ["start_date"] = capital_start, ["end_date"] = capital_return }, null, null);
        PrintValue(capital_response.Raw);
        var collateral_response = await Call("collateral", new JsonObject { ["asset_id"] = collateral_id, ["asset_type_id"] = "2", ["as_of_date"] = collateral_date }, null, null);
        PrintValue(collateral_response.Raw);

    }
    static Task Main() => Run();
}
```

```java
// Java 11+ with Gson on the classpath. Set EXHIBITDAY_API_KEY; save as Main.java.
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.ToNumberPolicy;
import java.io.*;
import java.net.*;
import java.net.http.*;
import java.nio.charset.StandardCharsets;
import java.nio.file.*;
import java.time.*;
import java.util.*;

public class Main {
    static final Gson JSON = new GsonBuilder().setObjectToNumberStrategy(ToNumberPolicy.LAZILY_PARSED_NUMBER).create();
    static final String BASE = "https://api.exhibitday.com/v1";
    static final Map<String,Object> SPEC = JSON.fromJson("{\"preserveNumbers\":true,\"requests\":{\"capital\":{\"method\":\"GET\",\"path\":\"/assets/availability\"},\"collateral\":{\"method\":\"GET\",\"path\":\"/assets/availability\"}}}", Map.class);
    static final String API_KEY = headerKey(required("EXHIBITDAY_API_KEY"));
    static String headerKey(String value){if(value.chars().anyMatch(c->c<32||c>126))throw new IllegalArgumentException("Use the API key as one ASCII header value without control characters");return value;}
    static final HttpClient CLIENT = HttpClient.newBuilder().connectTimeout(Duration.ofSeconds(30)).followRedirects(HttpClient.Redirect.NEVER).build();
    interface RequestSender { HttpResponse<String> send(HttpRequest request)throws IOException,InterruptedException; }
    static RequestSender SEND=request->CLIENT.send(request,HttpResponse.BodyHandlers.ofString(StandardCharsets.UTF_8));
    static class Result { int status; Object body; Map<String,String> headers; String raw;
        Result(int s, Object b, Map<String,String> h,String r) {status=s;body=b;headers=h;raw=r;} }
    // An API error response. Branch on errorCode (and status), never on the message text.
    // uncertain is true when a PATCH or DELETE got no response or a server error: it may or may not have been applied.
    static class ApiException extends IllegalStateException { final int status; final String errorCode; final boolean uncertain;
        ApiException(int status,Object errorCode,String message) {this(status,errorCode,message,false);}
        ApiException(int status,Object errorCode,String message,boolean uncertain) {super(message);this.status=status;this.errorCode=errorCode==null?null:String.valueOf(errorCode);this.uncertain=uncertain;} }
    static String required(String name) {String value=System.getenv(name);if(value==null||value.trim().isEmpty())throw new IllegalArgumentException("Set "+name);return value;}
    static String env(String name,String fallback) {String value=System.getenv(name);return value==null||value.isEmpty()?fallback:value;}
    static String text(Object value) {return value==null?"":value.toString();}
    @SuppressWarnings("unchecked") static Map<String,Object> obj(Object value) {return value==null?new LinkedHashMap<>(): (Map<String,Object>)value;}
    @SuppressWarnings("unchecked") static List<Object> list(Object value) {return value==null?Collections.emptyList():(List<Object>)value;}
    static Map<String,Object> map(Object... pairs) {Map<String,Object> result=new LinkedHashMap<>();for(int i=0;i<pairs.length;i+=2)result.put((String)pairs[i],pairs[i+1]);return result;}
    static void pause(double seconds) {try {Thread.sleep((long)(Math.max(0,seconds)*1000));}catch(InterruptedException error){Thread.currentThread().interrupt();throw new RuntimeException(error);}}
    static Result call(String name,Map<String,Object> query,Object body,String key) {
        Map<String,Object> route=obj(obj(SPEC.get("requests")).get(name));String method=text(route.get("method"));
        Map<String,Object> headers=map("Authorization","Bearer " + API_KEY,"Accept","application/json");
        if(method.equals("POST")){if(key==null||key.isEmpty())throw new IllegalArgumentException("Save a create key before sending POST");headers.put("Idempotency-Key",key);}
        String data=body==null?null:JSON.toJson(body);if(data!=null)headers.put("Content-Type","application/json");
        StringJoiner queryString=new StringJoiner("&");
        if(query!=null)query.forEach((k,v)->queryString.add(URLEncoder.encode(k,StandardCharsets.UTF_8)+"="+URLEncoder.encode(text(v),StandardCharsets.UTF_8)));
        String url=BASE+text(route.get("path"))+(queryString.length()==0?"":"?"+queryString);
        // Only GET has automatic retries in this workflow. A PATCH or DELETE that got no response or a
        // server error is never resent blindly: it may already have been applied, so the caller reads the record first.
        boolean resend=method.equals("GET");
        for(int attempt=0;attempt<5;attempt++) {
            HttpRequest.Builder request=HttpRequest.newBuilder(URI.create(url)).timeout(Duration.ofSeconds(30));
            headers.forEach((k,v)->request.header(k,text(v)));
            request.method(method,data==null?HttpRequest.BodyPublishers.noBody():HttpRequest.BodyPublishers.ofString(data,StandardCharsets.UTF_8));
            HttpResponse<String> response;
            try {response=SEND.send(request.build());}
            catch(InterruptedException error){Thread.currentThread().interrupt();throw new RuntimeException(error);}
            catch(IOException error){if(!resend)throw new ApiException(0,null,"No response",true);if(attempt==4)throw new RuntimeException(error);pause(Math.pow(2,attempt));continue;}
            int status=response.statusCode();Object parsed=null;
            if(status!=304&&!response.body().isEmpty()) {
                try {parsed=JSON.fromJson(response.body(),Object.class);}
                catch(RuntimeException error){if(status<400)throw new IllegalStateException("Expected a JSON success response",error);}
            }
            Map<String,String> responseHeaders=new HashMap<>();response.headers().map().forEach((k,v)->responseHeaders.put(k.toLowerCase(Locale.ROOT),String.join(", ",v)));
            if(status>=500&&!resend)throw new ApiException(status,obj(parsed).get("error_code"),"HTTP "+status,true);
            boolean retry=resend&&(status==429||status>=500);
            if(retry) {
                if(attempt==4)throw new IllegalStateException("Retry limit reached; check the outcome before starting a new create");
                double seconds=Math.pow(2,attempt);
                try {double value=Double.parseDouble(responseHeaders.get("retry-after"));if(Double.isFinite(value)&&value>=0)seconds=value;}catch(Exception ignored){}
                pause(seconds);continue;
            }
            if(status>=400)throw new ApiException(status,obj(parsed).get("error_code"),"HTTP "+status+": "+obj(parsed).get("error_code")+" (request "+obj(parsed).get("request_id")+")");
            return new Result(status,parsed,responseHeaders,response.body());
        }
        throw new IllegalStateException("Retry limit reached");
    }
        static String positive_id(String value){try{if(value==null||!value.matches("[1-9][0-9]*")||Long.parseLong(value)<=0)throw new IllegalArgumentException();return value;}catch(RuntimeException error){throw new IllegalArgumentException("Use a positive record ID");}}

    static void print_value(Object value){try{String text=value instanceof String?(String)value:JSON.toJson(value);System.out.write((text+"\n").getBytes(StandardCharsets.UTF_8));}catch(IOException error){throw new UncheckedIOException(error);}}


    static void run()throws Exception {
        String capital_id = positive_id(required("EXHIBITDAY_CAPITAL_ASSET_ID"));
        String collateral_id = positive_id(required("EXHIBITDAY_COLLATERAL_ASSET_ID"));
        String capital_start = required("EXHIBITDAY_CAPITAL_START_DATE");
        String capital_return = required("EXHIBITDAY_CAPITAL_RETURN_DATE");
        String collateral_date = required("EXHIBITDAY_COLLATERAL_CHECKOUT_DATE");
        Result capital_response = call("capital", map("asset_id", capital_id, "asset_type_id", "1", "start_date", capital_start, "end_date", capital_return), null, null);
        print_value(capital_response.raw);
        Result collateral_response = call("collateral", map("asset_id", collateral_id, "asset_type_id", "2", "as_of_date", collateral_date), null, null);
        print_value(collateral_response.raw);

    }
    public static void main(String[] args)throws Exception {run();}
}
```

```php
<?php
// PHP 8.1+ with the cURL extension. Set EXHIBITDAY_API_KEY before running.
declare(strict_types=1);

const BASE = 'https://api.exhibitday.com/v1';
const SPEC = '{"preserveNumbers":true,"requests":{"capital":{"method":"GET","path":"/assets/availability"},"collateral":{"method":"GET","path":"/assets/availability"}}}';
$spec = json_decode(SPEC, true, 512, JSON_THROW_ON_ERROR);
$apiKey = required('EXHIBITDAY_API_KEY');
if(preg_match('/[^\x20-\x7e]/',$apiKey))throw new RuntimeException('Use the API key as one ASCII header value without control characters');
if (trim($apiKey) === '') throw new RuntimeException('Set EXHIBITDAY_API_KEY');

function required(string $name, bool $allowEmpty = false): string {
    $value = getenv($name);
    if ($value === false || (!$allowEmpty && $value === '')) {
        throw new RuntimeException('Set ' . $name);
    }
    return $value;
}

function optional(string $name, string $fallback): string {
    $value = getenv($name);
    return $value === false ? $fallback : $value;
}

function decodeJson(string $text): mixed {
    global $spec;
    if ($spec['preserveNumbers']) {
        // Quote NUMBER tokens without changing digits inside JSON strings; CSV decimals stay exact.
        $pattern = <<<'JSON_NUMBER'
~"(?:\\.|[^"\\])*"|-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?~
JSON_NUMBER;
        $text = preg_replace_callback($pattern, static function (array $match): string {
            return str_starts_with($match[0], '"') ? $match[0] : json_encode($match[0], JSON_THROW_ON_ERROR);
        }, $text);
        if ($text === null) throw new RuntimeException('Unable to preserve decimal tokens');
    }
    return json_decode($text, true, 512, JSON_THROW_ON_ERROR);
}

function nativeTransport(string $method, string $url, array $headers, ?string $data): array {
    $responseHeaders = [];
    $handle = curl_init($url);
    if ($handle === false) throw new RuntimeException('Unable to initialize cURL');
    $headerLines = [];
    foreach ($headers as $name => $value) $headerLines[] = $name . ': ' . $value;
    $options = [CURLOPT_CUSTOMREQUEST => $method, CURLOPT_RETURNTRANSFER => true, CURLOPT_FOLLOWLOCATION => false,
        CURLOPT_CONNECTTIMEOUT => 30, CURLOPT_TIMEOUT => 30, CURLOPT_HTTPHEADER => $headerLines,
        CURLOPT_HEADERFUNCTION => static function ($handle, string $line) use (&$responseHeaders): int {
            if (str_starts_with($line, 'HTTP/')) $responseHeaders = [];
            $separator = strpos($line, ':');
            if ($separator !== false) {
                $responseHeaders[strtolower(trim(substr($line, 0, $separator)))] = trim(substr($line, $separator + 1));
            }
            return strlen($line);
        }];
    if ($data !== null) $options[CURLOPT_POSTFIELDS] = $data;
    try {
        curl_setopt_array($handle, $options);
        $raw = curl_exec($handle);
        if ($raw === false) throw new RuntimeException('Network request failed: ' . curl_error($handle));
        return [(int)curl_getinfo($handle, CURLINFO_RESPONSE_CODE), $raw, $responseHeaders];
    } finally {
        curl_close($handle);
    }
}

function retryDelay(array $headers, int $attempt): float {
    $value = $headers['retry-after'] ?? '';
    if (is_numeric($value)) return max(0.0, (float)$value);
    $date = $value === '' ? false : strtotime($value);
    return $date === false ? (float)(2 ** $attempt) : max(0.0, (float)($date - time()));
}

// An API error response. Branch on errorCode (and status), never on the message text.
// $uncertain is true when a PATCH or DELETE got no response or a server error: it may or may not have been applied.
final class ApiException extends RuntimeException {
    public function __construct(public readonly int $status, public readonly ?string $errorCode, string $message, public readonly bool $uncertain = false) {
        parent::__construct($message);
    }
}

function call(string $name, array $params = [], mixed $body = null, ?string $key = null): array {
    global $spec, $apiKey, $transport;
    $route = $spec['requests'][$name];
    $headers = ['Authorization' => 'Bearer ' . $apiKey, 'Accept' => 'application/json'];
    if ($route['method'] === 'POST') {
        if ($key === null || $key === '') throw new RuntimeException('Save a create key before sending POST');
        $headers['Idempotency-Key'] = $key; // ONCE, before retries.
    }
    $data = $body === null ? null : json_encode($body, JSON_THROW_ON_ERROR);
    if ($data !== null) $headers['Content-Type'] = 'application/json';
    $query = http_build_query($params, '', '&', PHP_QUERY_RFC3986);
    $url = BASE . $route['path'] . ($query === '' ? '' : '?' . $query);
    // Only GET has automatic retries in this workflow. A PATCH or DELETE that got no response or a
    // server error is never resent blindly: it may already have been applied, so the caller reads the record first.
    $resend = $route['method'] === 'GET';
    for ($attempt = 0; $attempt < 5; $attempt++) {
        try {
            [$status, $raw, $responseHeaders] = $transport($route['method'], $url, $headers, $data);
        } catch (RuntimeException $error) {
            if (!$resend) throw new ApiException(0, null, 'No response', true);
            if ($attempt === 4) throw $error;
            usleep((int)((2 ** $attempt) * 1000000));
            continue;
        }
        $responseHeaders = array_change_key_case($responseHeaders, CASE_LOWER);
        $result = null;
        if ($status !== 304 && $raw !== '') {
            try { $result = decodeJson($raw); }
            catch (JsonException $error) {
                if ($status < 400) throw new RuntimeException('Expected a JSON success response', 0, $error);
            }
        }
        if ($status >= 500 && !$resend) {
            throw new ApiException($status, is_array($result) && isset($result['error_code']) ? (string)$result['error_code'] : null, 'HTTP ' . $status, true);
        }
        $retry = $resend && ($status === 429 || $status >= 500);
        if ($retry) {
            if ($attempt === 4) throw new RuntimeException('Retry limit reached; check the outcome before starting a new create');
            usleep((int)(retryDelay($responseHeaders, $attempt) * 1000000));
            continue;
        }
        if ($status >= 400) {
            if (!is_array($result)) throw new ApiException($status, null, 'HTTP ' . $status);
            throw new ApiException($status, isset($result['error_code']) ? (string)$result['error_code'] : null, json_encode(['error_code' => $result['error_code'] ?? null,
                'error_params' => $result['error_params'] ?? null, 'errors' => $result['errors'] ?? null,
                'request_id' => $result['request_id'] ?? null], JSON_THROW_ON_ERROR));
        }
        return ['status' => $status, 'body' => $result, 'headers' => $responseHeaders, 'raw' => $raw];
    }
    throw new RuntimeException('Retry limit reached');
}


$transport = Closure::fromCallable('nativeTransport');
function positive_id(string $value):string{if(!preg_match("/^[1-9][0-9]*$/D",$value)||strlen($value)>19||(strlen($value)===19&&strcmp($value,"9223372036854775807")>0))throw new RuntimeException("Use a positive record ID");return $value;}

function print_value(mixed $value):void{echo (is_string($value)?$value:json_encode($value,JSON_THROW_ON_ERROR))."\n";}


function main():void {
    $capital_id = positive_id(required('EXHIBITDAY_CAPITAL_ASSET_ID'));
    $collateral_id = positive_id(required('EXHIBITDAY_COLLATERAL_ASSET_ID'));
    $capital_start = required('EXHIBITDAY_CAPITAL_START_DATE');
    $capital_return = required('EXHIBITDAY_CAPITAL_RETURN_DATE');
    $collateral_date = required('EXHIBITDAY_COLLATERAL_CHECKOUT_DATE');
    $capital_response = call('capital', ['asset_id' => $capital_id, 'asset_type_id' => '1', 'start_date' => $capital_start, 'end_date' => $capital_return], null, null);
    print_value($capital_response["raw"]);
    $collateral_response = call('collateral', ['asset_id' => $collateral_id, 'asset_type_id' => '2', 'as_of_date' => $collateral_date], null, null);
    print_value($collateral_response["raw"]);

}
if (realpath($_SERVER['SCRIPT_FILENAME'] ?? '') === __FILE__) main();
```

```ruby
# Ruby 3.1+; standard library only. Set EXHIBITDAY_API_KEY before running.
require 'net/http'
require 'json'
require 'uri'
require 'csv'
require 'fileutils'
require 'securerandom'
require 'date'
require 'time'
require 'timeout'

BASE = 'https://api.exhibitday.com/v1'
SPEC = JSON.parse('{"preserveNumbers":true,"requests":{"capital":{"method":"GET","path":"/assets/availability"},"collateral":{"method":"GET","path":"/assets/availability"}}}')
API_KEY = ENV.fetch('EXHIBITDAY_API_KEY')
raise 'Use the API key as one ASCII header value without control characters' if API_KEY.each_codepoint.any?{|point|point<32||point>126}

def decode_json(text)
  if SPEC.fetch('preserveNumbers')
    # Preserve JSON NUMBER lexemes for CSV, without replacing digits inside JSON strings.
    text = text.gsub(/"(?:\\.|[^"\\])*"|-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?/) do |token|
      token.start_with?('"') ? token : JSON.generate(token)
    end
  end
  JSON.parse(text)
end

def transport(method, url, headers, data)
  uri = URI(url)
  request_type = { 'GET' => Net::HTTP::Get, 'POST' => Net::HTTP::Post,
                   'PATCH' => Net::HTTP::Patch, 'DELETE' => Net::HTTP::Delete }.fetch(method)
  request = request_type.new(uri.request_uri, headers)
  request.body = data unless data.nil?
  http = Net::HTTP.new(uri.host, uri.port)
  http.use_ssl = uri.scheme == 'https'
  http.open_timeout = http.read_timeout = http.write_timeout = 30
  http.max_retries = 0 # The outer loop owns the bounded retry policy.
  response = http.start { |client| client.request(request) }
  [response.code.to_i, response.body.to_s, response.each_header.to_h]
end

def retry_delay(headers, attempt)
  value = headers['retry-after']
  return 2**attempt if value.nil? || value.empty?
  begin
    [Float(value), 0].max
  rescue ArgumentError, TypeError
    begin
      [Time.httpdate(value) - Time.now, 0].max
    rescue ArgumentError
      2**attempt
    end
  end
end

# An API error response. Branch on error_code (and status), never on the message text.
# uncertain is true when a PATCH or DELETE got no response or a server error: it may or may not have been applied.
class ApiError < RuntimeError
  attr_reader :status, :error_code, :uncertain

  def initialize(status, error_code, message, uncertain = false)
    super(message)
    @status = status
    @error_code = error_code
    @uncertain = uncertain
  end
end

def call(name, params = {}, body = nil, key = nil)
  route = SPEC.fetch('requests').fetch(name)
  headers = { 'Authorization' => 'Bearer ' + API_KEY, 'Accept' => 'application/json' }
  if route.fetch('method') == 'POST'
    headers['Idempotency-Key'] = key || raise('Save a create key before sending POST') # ONCE before retries.
  end
  data = body.nil? ? nil : JSON.generate(body)
  headers['Content-Type'] = 'application/json' unless data.nil?
  query = URI.encode_www_form(params)
  url = BASE + route.fetch('path') + (query.empty? ? '' : '?' + query)
  # Only GET has automatic retries in this workflow. A PATCH or DELETE that got no response or a
  # server error is never resent blindly: it may already have been applied, so the caller reads the record first.
  resend = route.fetch('method') == 'GET'
  5.times do |attempt|
    begin
      status, raw, response_headers = transport(route.fetch('method'), url, headers, data)
    rescue IOError, SystemCallError, Timeout::Error, SocketError
      raise ApiError.new(0, nil, 'No response', true) unless resend
      raise if attempt == 4
      sleep(2**attempt)
      next
    end
    response_headers = response_headers.transform_keys(&:downcase)
    result = nil
    unless status == 304 || raw.empty?
      begin
        result = decode_json(raw)
      rescue JSON::ParserError, EncodingError
        raise 'Expected a JSON success response' if status < 400
      end
    end
    if status >= 500 && !resend
      raise ApiError.new(status, result.is_a?(Hash) ? result['error_code'] : nil, "HTTP #{status}", true)
    end
    transient = resend && (status == 429 || (500..599).cover?(status))
    if transient
      raise 'Retry limit reached; check the outcome before starting a new create' if attempt == 4
      sleep(retry_delay(response_headers, attempt))
      next
    end
    if status >= 400
      raise ApiError.new(status, nil, "HTTP #{status}") unless result.is_a?(Hash)
      raise ApiError.new(status, result['error_code'], "#{result['error_code']} #{result['error_params'].inspect}: #{result['errors'].inspect} (request #{result['request_id']})")
    end
    return { status: status, body: result, headers: response_headers, raw: raw }
  end
  raise 'Retry limit reached'
end


def positive_id(value)
  raise "Use a positive record ID" unless /\A[1-9][0-9]*\z/.match?(value) && Integer(value)<=9223372036854775807
  value
end

def print_value(value)
  STDOUT.binmode.write((value.is_a?(String)?value:JSON.generate(value))+"\n")
end

def required(name)
  value=ENV[name]
  raise "Set #{name}" if value.nil? || value.strip.empty?
  value
end


def main
    capital_id = positive_id(required('EXHIBITDAY_CAPITAL_ASSET_ID'))
    collateral_id = positive_id(required('EXHIBITDAY_COLLATERAL_ASSET_ID'))
    capital_start = required('EXHIBITDAY_CAPITAL_START_DATE')
    capital_return = required('EXHIBITDAY_CAPITAL_RETURN_DATE')
    collateral_date = required('EXHIBITDAY_COLLATERAL_CHECKOUT_DATE')
    capital_response = call('capital', {'asset_id' => capital_id, 'asset_type_id' => '1', 'start_date' => capital_start, 'end_date' => capital_return}, nil, nil)
    print_value(capital_response.fetch(:raw))
    collateral_response = call('collateral', {'asset_id' => collateral_id, 'asset_type_id' => '2', 'as_of_date' => collateral_date}, nil, nil)
    print_value(collateral_response.fetch(:raw))

end
main if $PROGRAM_NAME == __FILE__
```

```go
// Go 1.18+; standard library only. Set EXHIBITDAY_API_KEY.
package main

import (
    "bytes"

    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "net/url"
    "os"
    "strconv"
    "strings"
    "time"
)

const base = "https://api.exhibitday.com/v1"
const specification = "{\"preserveNumbers\":true,\"requests\":{\"capital\":{\"method\":\"GET\",\"path\":\"/assets/availability\"},\"collateral\":{\"method\":\"GET\",\"path\":\"/assets/availability\"}}}"
var spec map[string]any
var apiKey string
var client = &http.Client{Timeout: 30 * time.Second, CheckRedirect: func(req *http.Request, via []*http.Request) error { return http.ErrUseLastResponse }}
var send = client.Do

type result struct { status int; body any; headers http.Header; raw []byte }
// An API error response (raised with panic). Branch on code (and status), never on the message text.
// uncertain is true when a PATCH or DELETE got no response or a server error: it may or may not have been applied.
type apiError struct { status int; code string; message string; uncertain bool }
func (failure apiError) Error() string { return failure.message }

func required(name string) string {
    value := os.Getenv(name); if strings.TrimSpace(value) == "" { panic("Set " + name) }; return value
}
func text(value any) string { if value == nil { return "" }; return fmt.Sprint(value) }
func object(value any) map[string]any { if value == nil { return map[string]any{} }; return value.(map[string]any) }
func array(value any) []any { if value == nil { return nil }; return value.([]any) }
func decode(raw []byte) (any, error) {
    var value any
    decoder := json.NewDecoder(bytes.NewReader(raw)); decoder.UseNumber() // keeps exact decimal tokens
    err := decoder.Decode(&value); return value, err
}
func call(name string, query map[string]string, body any, key string) result {
    route := object(object(spec["requests"])[name]); method := text(route["method"])
    headers := map[string]string{"Authorization": "Bearer " + apiKey, "Accept": "application/json"}
    if method == "POST" { if key == "" { panic("Save a create key before sending POST") }; headers["Idempotency-Key"] = key } // before retry loop
    var data []byte
    if body != nil { var err error; data, err = json.Marshal(body); if err != nil { panic(err) }; headers["Content-Type"] = "application/json" }
    values := url.Values{}; for k,v := range query { values.Set(k,v) }
    address := base + text(route["path"]); if len(values) > 0 { address += "?" + values.Encode() }
    // Only GET has automatic retries in this workflow. A PATCH or DELETE that got no response or a
    // server error is never resent blindly: it may already have been applied, so the caller reads the record first.
    resend := method == "GET"
    for attempt := 0; attempt < 5; attempt++ {
        request, err := http.NewRequest(method, address, bytes.NewReader(data)); if err != nil { panic(err) }
        for k,v := range headers { request.Header.Set(k,v) }
        response, err := send(request)
        if err != nil { if !resend { panic(apiError{0, "", "No response", true}) }; if attempt == 4 { panic(err) }; time.Sleep(time.Second*time.Duration(1<<attempt)); continue }
        raw, readErr := io.ReadAll(response.Body); response.Body.Close()
        if readErr != nil { if !resend { panic(apiError{0, "", "No response", true}) }; if attempt == 4 { panic(readErr) }; time.Sleep(time.Second*time.Duration(1<<attempt)); continue }
        var parsed any
        if response.StatusCode != 304 && len(raw)>0 {
            parsed, err = decode(raw)
            if err != nil && response.StatusCode < 400 { panic("Expected a JSON success response") }
        }
        errorBody, _ := parsed.(map[string]any)
        if response.StatusCode >= 500 && !resend { panic(apiError{response.StatusCode, text(errorBody["error_code"]), fmt.Sprintf("HTTP %d", response.StatusCode), true}) }
        retry := resend && (response.StatusCode == 429 || response.StatusCode >= 500)
        if retry {
            if attempt == 4 { panic("Retry limit reached; check the outcome before starting a new create") }
            seconds := float64(int64(1)<<attempt)
            if value, err := strconv.ParseFloat(response.Header.Get("Retry-After"),64); err == nil && value >= 0 { seconds = value }
            time.Sleep(time.Duration(seconds*float64(time.Second))); continue
        }
        if response.StatusCode >= 400 { panic(apiError{response.StatusCode, text(errorBody["error_code"]), fmt.Sprintf("HTTP %d: %v (request %v)",response.StatusCode,errorBody["error_code"],errorBody["request_id"]), false}) }
        return result{response.StatusCode, parsed, response.Header, raw}
    }
    panic("Retry limit reached")
}

func positive_id(value string)string{valid:=len(value)>0&&value[0]!='0';for _,ch:=range value{valid=valid&&ch>='0'&&ch<='9'};id,err:=strconv.ParseInt(value,10,64);if !valid||err!=nil||id<=0{panic("Use a positive record ID")};return value}

func print_value(value any){if result,ok:=value.(string);ok{fmt.Println(result);return};raw,err:=json.Marshal(value);if err!=nil{panic(err)};fmt.Println(string(raw))}


func workflow() {
    capital_id := positive_id(required("EXHIBITDAY_CAPITAL_ASSET_ID"))
    collateral_id := positive_id(required("EXHIBITDAY_COLLATERAL_ASSET_ID"))
    capital_start := required("EXHIBITDAY_CAPITAL_START_DATE")
    capital_return := required("EXHIBITDAY_CAPITAL_RETURN_DATE")
    collateral_date := required("EXHIBITDAY_COLLATERAL_CHECKOUT_DATE")
    capital_response := call("capital", map[string]string{"asset_id": capital_id, "asset_type_id": "1", "start_date": capital_start, "end_date": capital_return}, nil, "")
    print_value(string(capital_response.raw))
    collateral_response := call("collateral", map[string]string{"asset_id": collateral_id, "asset_type_id": "2", "as_of_date": collateral_date}, nil, "")
    print_value(string(collateral_response.raw))

}
func header_key(value string)string{for _,ch:=range value{if ch<32||ch>126{panic("Use the API key as one ASCII header value without control characters")}};return value}
func main(){apiKey=header_key(required("EXHIBITDAY_API_KEY"));if err:=json.Unmarshal([]byte(specification),&spec);err!=nil{panic(err)};workflow()}
```

## Example response

Response 200 — OK 304 — Not Modified 400 — Bad Request 401 — Unauthorized 404 — Not Found 429 — Too Many Requests 500 — Internal Server Error

Example Successful request

```json
{
  "asset_id": 12345,
  "asset_type_id": 1,
  "is_advisory": true,
  "is_asset_owned_by_this_workspace": true,
  "start_date": "2030-01-14",
  "end_date": "2030-01-17",
  "as_of_date": null,
  "asset_reservation_policy_id": 2,
  "is_available_under_reservation_policy": true,
  "overlapping_reservation_count": 1,
  "policy_conflict_count": 0,
  "is_requested_period_unchanged": false,
  "quantity_available_in_storage": null,
  "projected_future_balance": null,
  "storage_locations": null
}
```

Note: This is the full Capital Asset response from Step 1.

Note: There is no response body. Keep using your cached response.

```json
{
  "status_code": 400,
  "status": "Bad Request",
  "message": "HTTP method override is not supported.",
  "error_code": "invalid_request",
  "errors": [
    "Send the documented HTTP method directly. X-HTTP-Method-Override cannot change a request's HTTP method."
  ],
  "error_params": [
    "X-HTTP-Method-Override"
  ],
  "request_id": "0123456789abcdef0123456789abcdef"
}
```

```json
{
  "status_code": 401,
  "status": "Unauthorized",
  "message": "No API key was provided. Send your key in the Authorization header as 'Bearer YOUR_API_KEY'. Alternatively, you can use the api_key parameter.",
  "error_code": "missing_api_key",
  "errors": [
    "Copy the key from Workspace Settings > API & Integrations > API Access in ExhibitDay."
  ],
  "error_params": [
    "api_key"
  ],
  "request_id": "0123456789abcdef0123456789abcdef"
}
```

```json
{
  "status_code": 401,
  "status": "Unauthorized",
  "message": "The API key is not valid. Check that you copied the whole key from Workspace Settings > API & Integrations > API Access, then send it in the Authorization header as 'Bearer YOUR_API_KEY'. Alternatively, you can use the api_key parameter.",
  "error_code": "invalid_api_key",
  "errors": [
    "Check that you sent the whole key. If it was regenerated, use the current key from Workspace Settings > API & Integrations > API Access."
  ],
  "error_params": [
    "api_key"
  ],
  "request_id": "0123456789abcdef0123456789abcdef"
}
```

```json
{
  "status_code": 401,
  "status": "Unauthorized",
  "message": "Access to the ExhibitDay API is not enabled for your workspace. Please contact support@exhibitday.com to enable API Access. Once access is enabled, send your key in the Authorization header as 'Bearer YOUR_API_KEY'.",
  "error_code": "api_access_disabled",
  "errors": [
    "Nothing was read or changed."
  ],
  "error_params": [
    "api_key"
  ],
  "request_id": "0123456789abcdef0123456789abcdef"
}
```

```json
{
  "status_code": 404,
  "status": "Not Found",
  "message": "Asset not found. Invalid Asset ID: 12345.",
  "error_code": "not_found",
  "errors": [
    "Asset not found. Invalid Asset ID: 12345."
  ],
  "error_params": [],
  "request_id": "0123456789abcdef0123456789abcdef"
}
```

```json
{
  "status_code": 429,
  "status": "Too Many Requests",
  "message": "Error 429 - Too Many Requests",
  "error_code": "rate_limited",
  "errors": [
    "Error 429 - Too Many Requests"
  ],
  "error_params": [],
  "request_id": "0123456789abcdef0123456789abcdef"
}
```

```json
{
  "status_code": 500,
  "status": "Unexpected Internal Error",
  "message": "An unexpected error occurred. Please try again later.",
  "error_code": "internal_error",
  "errors": [
    "An unexpected error occurred. Please try again later."
  ],
  "error_params": [],
  "request_id": "0123456789abcdef0123456789abcdef"
}
```

Note: Use the request_id from your own response when contacting support.

```json
{
  "status_code": 500,
  "status": "Unexpected Internal Error",
  "message": "An unexpected error occurred. Please try again later.",
  "error_code": "internal_error",
  "errors": [
    "Check whether your change was saved before trying again."
  ],
  "error_params": [],
  "request_id": "0123456789abcdef0123456789abcdef"
}
```

The curl example uses Bash, curl and Python 3. Node.js needs version 18 or later (save as .cjs). Python uses its standard library. C# needs a .NET 8 console project (Program.cs). Java needs Java 11 or later and Gson 2.14.0 (Main.java). PHP needs PHP 8.1 or later with cURL. Ruby 3.1 or later and Go 1.18 or later use their standard libraries.

## Things to keep in mind

- Collateral availability includes inventory adjustments, Event checkouts and scheduled returns. A scheduled return adds units back from its return date. Confirm physical stock when your plan depends on that return. Negative quantities are returned as recorded.
- `projected_future_balance` includes future inventory movements. Use `quantity_available_in_storage` with your chosen `as_of_date` for the checkout decision.
- When editing an existing reservation, pass its accessible ID in `excluded_reservation_id`. This excludes the reservation's current allocation. An unchanged Capital period can still pass under the existing save rule. For Collateral, both its checkout and its scheduled return are excluded.

## If a request fails

For a validation error, check the Asset type and its date fields. If the Asset can't be found, check that it's Active and still owned by or shared with the workspace for the key you're using.

## Related guides

- [Reserve Assets (Equipment and Materials) for an Event](https://api.exhibitday.com/Help/V1?guide=reserve-change-cancel-assets)
- [Update Collateral Stock After a Delivery or Recount](https://api.exhibitday.com/Help/V1?guide=collateral-inventory-storage)
