Your booking engine,
as an API.Váš rezervační systém,
jako API.Ihr Buchungssystem,
als API.Tu motor de reservas,
como API.

# Your key from Settings → API keys in the Switchly dashboard.
export SWITCHLY_API_KEY="ak_live_..."
API="https://api.switchly.ai"

# 1. The services, with the IDs you book against
curl -s "$API/v1/assistant/services" -H "X-API-Key: $SWITCHLY_API_KEY"

# 2. Free starts for one service, day by day (up to 31 days)
curl -s "$API/v1/availability?service_id=SERVICE_ID&from=2026-10-05&to=2026-10-11" \
  -H "X-API-Key: $SWITCHLY_API_KEY"

# 3. Book one of them. 409 CONFLICT means somebody was faster: ask again.
curl -s -X POST "$API/v1/appointments" \
  -H "X-API-Key: $SWITCHLY_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "service_id": "SERVICE_ID",
    "start_time": "2026-10-05T09:00:00+02:00",
    "customer_name": "Jana Nováková",
    "customer_mobile": "+420777123456"
  }'

# 4. Move it to another free start
curl -s -X PATCH "$API/v1/appointments/APPOINTMENT_ID" \
  -H "X-API-Key: $SWITCHLY_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{ "start_time": "2026-10-05T11:00:00+02:00" }'

# 5. Cancel it
curl -s -X DELETE "$API/v1/appointments/APPOINTMENT_ID" \
  -H "X-API-Key: $SWITCHLY_API_KEY"

// Node.js 18 or newer: SWITCHLY_API_KEY=ak_live_... node book.mjs
// Keep the key on your server; never ship it to a browser.
const API = "https://api.switchly.ai";

async function call(method, path, body) {
  const res = await fetch(API + path, {
    method,
    headers: {
      "X-API-Key": process.env.SWITCHLY_API_KEY,
      "Content-Type": "application/json",
    },
    body: body && JSON.stringify(body),
  });
  const data = await res.json();
  if (!res.ok) {
    throw Object.assign(new Error(data.message), { status: res.status, key: data.key });
  }
  return data;
}

// 1. Pick a service
const { data: services } = await call("GET", "/v1/assistant/services");
const service = services[0];

// 2. Free starts for the next seven days
const { days } = await call(
  "GET",
  `/v1/availability?service_id=${service.id}&from=2026-10-05&to=2026-10-11`,
);
const [first, second] = days.flatMap((day) => day.slots);

try {
  // 3. Book the first one
  const booked = await call("POST", "/v1/appointments", {
    service_id: service.id,
    start_time: first.start,
    customer_name: "Jana Nováková",
    customer_mobile: "+420777123456",
  });
  console.log("booked", booked.id, "code", booked.secure_id);

  // 4. Move it to the second one
  const moved = await call("PATCH", `/v1/appointments/${booked.id}`, {
    start_time: second.start,
  });
  console.log("moved to", moved.start_time);

  // 5. Cancel it
  const cancelled = await call("DELETE", `/v1/appointments/${booked.id}`);
  console.log("status", cancelled.status);
} catch (err) {
  if (err.key !== "CONFLICT") throw err;
  // The slot went in the meantime: ask for availability again.
  console.log("slot taken:", err.message);
}

# Python 3.9+ with requests: SWITCHLY_API_KEY=ak_live_... python book.py
import os

import requests

API = "https://api.switchly.ai"

session = requests.Session()
session.headers["X-API-Key"] = os.environ["SWITCHLY_API_KEY"]


class SwitchlyError(Exception):
    def __init__(self, status, key, message):
        super().__init__(f"{status} {key}: {message}")
        self.status, self.key = status, key


def call(method, path, **kwargs):
    res = session.request(method, API + path, timeout=15, **kwargs)
    data = res.json()
    if not res.ok:
        raise SwitchlyError(res.status_code, data["key"], data["message"])
    return data


# 1. Pick a service
service = call("GET", "/v1/assistant/services")["data"][0]

# 2. Free starts for the next seven days
availability = call(
    "GET",
    "/v1/availability",
    params={"service_id": service["id"], "from": "2026-10-05", "to": "2026-10-11"},
)
first, second = [slot for day in availability["days"] for slot in day["slots"]][:2]

try:
    # 3. Book the first one
    booked = call("POST", "/v1/appointments", json={
        "service_id": service["id"],
        "start_time": first["start"],
        "customer_name": "Jana Nováková",
        "customer_mobile": "+420777123456",
    })
    print("booked", booked["id"], "code", booked["secure_id"])

    # 4. Move it to the second one
    moved = call("PATCH", f"/v1/appointments/{booked['id']}", json={
        "start_time": second["start"],
    })
    print("moved to", moved["start_time"])

    # 5. Cancel it
    cancelled = call("DELETE", f"/v1/appointments/{booked['id']}")
    print("status", cancelled["status"])
except SwitchlyError as err:
    if err.key != "CONFLICT":
        raise
    # The slot went in the meantime: ask for availability again.
    print("slot taken:", err)

// Go 1.21+: SWITCHLY_API_KEY=ak_live_... go run main.go
package main

import (
	"bytes"
	"encoding/json"
	"errors"
	"fmt"
	"log"
	"net/http"
	"os"
	"time"
)

const api = "https://api.switchly.ai"

var client = &http.Client{Timeout: 15 * time.Second}

// apiError is the body of every error the API returns.
type apiError struct {
	Status  int    `json:"-"`
	Key     string `json:"key"`
	Message string `json:"message"`
}

func (e *apiError) Error() string {
	return fmt.Sprintf("%d %s: %s", e.Status, e.Key, e.Message)
}

func call(method, path string, body, out any) error {
	var payload bytes.Buffer
	if body != nil {
		if err := json.NewEncoder(&payload).Encode(body); err != nil {
			return err
		}
	}
	req, err := http.NewRequest(method, api+path, &payload)
	if err != nil {
		return err
	}
	req.Header.Set("X-API-Key", os.Getenv("SWITCHLY_API_KEY"))
	req.Header.Set("Content-Type", "application/json")

	res, err := client.Do(req)
	if err != nil {
		return err
	}
	defer res.Body.Close()

	if res.StatusCode >= 300 {
		apiErr := &apiError{Status: res.StatusCode}
		_ = json.NewDecoder(res.Body).Decode(apiErr)
		return apiErr
	}
	return json.NewDecoder(res.Body).Decode(out)
}

type slot struct {
	Start time.Time `json:"start"`
	End   time.Time `json:"end"`
}

type appointment struct {
	ID        string    `json:"id"`
	SecureID  string    `json:"secure_id"`
	Status    string    `json:"status"`
	StartTime time.Time `json:"start_time"`
}

func main() {
	// 1. Pick a service
	var services struct {
		Data []struct {
			ID   string `json:"id"`
			Name string `json:"name"`
		} `json:"data"`
	}
	if err := call(http.MethodGet, "/v1/assistant/services", nil, &services); err != nil {
		log.Fatal(err)
	}
	service := services.Data[0]

	// 2. Free starts for the next seven days
	var availability struct {
		Days []struct {
			Date  string `json:"date"`
			Slots []slot `json:"slots"`
		} `json:"days"`
	}
	path := "/v1/availability?service_id=" + service.ID + "&from=2026-10-05&to=2026-10-11"
	if err := call(http.MethodGet, path, nil, &availability); err != nil {
		log.Fatal(err)
	}
	var free []slot
	for _, day := range availability.Days {
		free = append(free, day.Slots...)
	}
	if len(free) < 2 {
		log.Fatal("not enough free starts this week")
	}

	// 3. Book the first one
	var booked appointment
	err := call(http.MethodPost, "/v1/appointments", map[string]any{
		"service_id":      service.ID,
		"start_time":      free[0].Start,
		"customer_name":   "Jana Nováková",
		"customer_mobile": "+420777123456",
	}, &booked)
	var apiErr *apiError
	if errors.As(err, &apiErr) && apiErr.Key == "CONFLICT" {
		// The slot went in the meantime: ask for availability again.
		log.Fatal("slot taken: ", apiErr)
	}
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println("booked", booked.ID, "code", booked.SecureID)

	// 4. Move it to the second one
	var moved appointment
	err = call(http.MethodPatch, "/v1/appointments/"+booked.ID, map[string]any{
		"start_time": free[1].Start,
	}, &moved)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println("moved to", moved.StartTime)

	// 5. Cancel it
	var cancelled appointment
	if err := call(http.MethodDelete, "/v1/appointments/"+booked.ID, nil, &cancelled); err != nil {
		log.Fatal(err)
	}
	fmt.Println("status", cancelled.Status)
}