Bookings API

https://deepcontext.app/api/public/tenants/{slug}

const BASE = "https://deepcontext.app/api/public/tenants/YOUR_SLUG";

// 1. Services, their questions, and the tenant's timezone.
const config = await fetch(BASE).then((r) => r.json());
const service = config.services[0];

// 2. Open start times. UTC instants, already filtered for notice/horizon/buffers.
const from = new Date().toISOString();
const to = new Date(Date.now() + 60 * 86_400_000).toISOString();
const { slots } = await fetch(
  `${BASE}/availability?service_id=${service.id}` +
    `&from=${encodeURIComponent(from)}&to=${encodeURIComponent(to)}`,
).then((r) => r.json());

// 3. Submit. One key per booking attempt — reuse it if you retry the SAME booking,
//    generate a new one when the customer picks a different slot.
const res = await fetch(`${BASE}/bookings`, {
  method: "POST",
  headers: {
    "Content-Type": "application/json",
    "Idempotency-Key": crypto.randomUUID(),
  },
  body: JSON.stringify({
    service_id: service.id,
    starts_at: slots[0],
    customer_name: "Jane Customer",
    customer_phone: "+14155550123", // required
    customer_email: "jane@example.com", // optional — send null when not given
    form_data: { "22222222-2222-4222-8222-222222222222": "Wool" },
    turnstile_token: tokenFromWidget,
    website: "", // honeypot — must stay empty
  }),
});

const body = await res.json();
if (res.status === 201) {
  showSuccess(body.booking.status, body.acknowledgment);
}

function normalizeAnswers(fields, answers) {
  const values = {};
  const errors = {};

  for (const field of fields) {
    const raw = answers[field.id];

    // An unchecked box is a real `false`, not a missing answer, so a boolean is
    // never blank and can never fail `required`. Anything that isn't a boolean is
    // an error, not a falsy value — coercing it would store `false` for an answer
    // the server rejects.
    if (field.type === "boolean") {
      if (raw == null) values[field.id] = false;
      else if (typeof raw === "boolean") values[field.id] = raw;
      else errors[field.id] = "Choose yes or no.";
      continue;
    }

    // An empty array is an unanswered multi-select, same as an empty string.
    const blank =
      raw == null ||
      (typeof raw === "string" && raw.trim() === "") ||
      (Array.isArray(raw) && raw.length === 0);
    if (blank) {
      if (field.required) errors[field.id] = "This is required.";
      continue; // omit optional blanks — never send "" or []
    }

    if (field.type === "number") {
      // Inputs give you strings; both a number and a numeric string are accepted.
      // Past 2^53−1 a JS number silently rounds, so the server rejects it.
      const n = Number(raw);
      if (!Number.isFinite(n) || Math.abs(n) > Number.MAX_SAFE_INTEGER) {
        errors[field.id] = "Enter a valid number.";
      } else if (field.min != null && n < field.min) {
        errors[field.id] = `Enter ${field.min} or more.`;
      } else if (field.max != null && n > field.max) {
        errors[field.id] = `Enter ${field.max} or less.`;
      } else {
        values[field.id] = n;
      }
    } else if (field.type === "multi_select") {
      // Array only — a bare string is not a one-element selection. Entries are
      // deduplicated and re-ordered to match `options`, which is what the server
      // stores, so two customers who tick the same boxes submit the same answer.
      const allowed = new Set((field.options ?? []).map((o) => o.value));
      const picked = new Set(
        Array.isArray(raw) ? raw.filter((v) => typeof v === "string").map((v) => v.trim()) : [],
      );
      const ok = Array.isArray(raw) && [...picked].every((v) => allowed.has(v));
      const ordered = (field.options ?? [])
        .map((o) => o.value)
        .filter((v) => picked.has(v));
      if (!ok || ordered.length === 0) {
        errors[field.id] = "Choose from the listed options.";
      } else {
        values[field.id] = ordered;
      }
    } else if (field.type === "email") {
      // Lowercased but NOT canonicalized: `ana+booking@x.com` keeps its suffix,
      // because that is the address the customer chose to give.
      const value = typeof raw === "string" ? raw.trim().toLowerCase() : "";
      if (!/^[^\s@]+@[^\s@]+\.[^\s@]{2,}$/.test(value)) {
        errors[field.id] = "Enter a valid email address.";
      } else {
        values[field.id] = value;
      }
    } else if (field.type === "url") {
      // Protocol-restricted: `new URL()` alone accepts `javascript:` and `data:`,
      // and these answers are rendered as links in the operator's email.
      const value = typeof raw === "string" ? raw.trim() : "";
      let ok = false;
      try {
        ok = ["http:", "https:"].includes(new URL(value).protocol);
      } catch {
        ok = false;
      }
      if (!ok) errors[field.id] = "Enter a link starting with http:// or https://.";
      else values[field.id] = value;
    } else if (field.type === "phone") {
      // The server normalizes to E.164 and assumes +1 for a bare 10-digit number.
      // Send whatever the customer typed; this only catches obvious nonsense.
      const value = typeof raw === "string" ? raw.trim() : "";
      const digits = value.replace(/\D/g, "");
      if (digits.length < 7) errors[field.id] = "Enter a valid phone number.";
      else values[field.id] = value;
    } else if (field.type === "select") {
      // `options` is a list of { value, label } pairs. Store the value, show the
      // label — they're often the same string, but never assume it: the split is
      // what lets a tenant reword a label without invalidating past answers.
      const value = typeof raw === "string" ? raw.trim() : null;
      if (value === null || !(field.options ?? []).some((o) => o.value === value)) {
        errors[field.id] = "Choose one of the listed options.";
      } else {
        values[field.id] = value;
      }
    } else if (field.type === "date") {
      // Round-tripping catches dates the regex accepts but the calendar doesn't:
      // 2026-02-31 rolls forward to March.
      const value = typeof raw === "string" ? raw.trim() : "";
      const real =
        /^\d{4}-\d{2}-\d{2}$/.test(value) &&
        new Date(`${value}T00:00:00.000Z`).toISOString().slice(0, 10) === value;
      // `YYYY-MM-DD` sorts correctly as a string, so bounds need no Date parsing.
      if (!real) errors[field.id] = "Enter a valid date.";
      else if (field.min != null && value < field.min) {
        errors[field.id] = `Choose ${field.min} or later.`;
      } else if (field.max != null && value > field.max) {
        errors[field.id] = `Choose ${field.max} or earlier.`;
      } else values[field.id] = value;
    } else {
      // `text`, `textarea`, and any type added after this snippet was written.
      // Don't coerce: the server requires a string here, so `String(raw)` would
      // accept an answer it rejects.
      if (typeof raw !== "string") errors[field.id] = "Enter a valid answer.";
      else values[field.id] = raw.trim();
    }
  }

  return { values, errors };
}

{ "error": { "code": "invalid_request", "message": "Human-readable explanation" } }