Booking

The Booking module provides complete booking functionality including services, providers, availability, and checkout.

Services

Services represent bookable offerings (haircuts, consultations, classes, etc.).

Create Service

Create a new bookable service.

const result = await sdk.booking.createService({
key: 'haircut',
blocks: [
  {
    key: 'description',
    type: 'TEXT',
    content: {
      body: { en: 'Professional haircut service' }
    }
  }
],
taxonomies: [
  { taxonomyId: 'tax_category', entryId: 'entry_hair' }
],
status: 'ACTIVE'
});

Get Service

Retrieve a service by ID or slug.

// By ID
const result = await sdk.booking.getService({
  id: 'svc_xyz789'
});

// By slug (locale-aware)
const result = await sdk.booking.getService({
  slug: 'haircut'
});

List Services

List all services with filtering.

const result = await sdk.booking.getServices({
ids: ['svc_1', 'svc_2'],
query: 'haircut',
statuses: ['ACTIVE'],
sortField: 'createdAt',
sortDirection: 'desc',
cursor: null,
limit: 20
});

result.items.forEach(service => {
console.log(service.key);
});

Update Service

await sdk.booking.updateService({
  id: 'svc_xyz789',
  key: 'premium-haircut',
  status: 'ACTIVE'
});

Delete Service

await sdk.booking.deleteService({
  id: 'svc_xyz789'
});

Providers

Providers are staff members who perform services.

Create Provider

const result = await sdk.booking.createProvider({
key: 'sarah-johnson',
blocks: [
  {
    key: 'bio',
    type: 'TEXT',
    content: {
      body: { en: 'Senior stylist with 10 years experience' }
    }
  },
  {
    key: 'image',
    type: 'IMAGE',
    content: {
      mediaId: 'media_sarah123'
    }
  }
],
status: 'ACTIVE'
});

Get Provider

// By ID
const result = await sdk.booking.getProvider({
  id: 'prv_abc123'
});

// By slug
const result = await sdk.booking.getProvider({
  slug: 'sarah-johnson'
});

List Providers

const result = await sdk.booking.getProviders({
serviceId: 'svc_haircut',
ids: ['prv_1', 'prv_2'],
query: 'sarah',
statuses: ['ACTIVE'],
sortField: 'createdAt',
sortDirection: 'desc',
cursor: null,
limit: 20
});

result.items.forEach(provider => {
console.log(provider.key, provider.status);
});

Update Provider

await sdk.booking.updateProvider({
  id: 'prv_abc123',
  key: 'sarah-johnson-senior',
  status: 'ACTIVE'
});

Delete Provider

await sdk.booking.deleteProvider({
  id: 'prv_abc123'
});

Service Providers

Service providers link a provider to a service with working time, pricing, and duration configuration.

Find Service Providers

Get all provider connections for a service (or all service-provider connections for the business).

const serviceProviders = await sdk.booking.findServiceProviders({
  serviceId: 'svc_haircut'
});

for (const sp of serviceProviders) {
  console.log(sp.providerId, sp.workingDays, sp.prices);
}

Create Service Provider

Connect a provider to a service with working time and pricing configuration.

const serviceProvider = await sdk.booking.createServiceProvider({
  serviceId: 'svc_haircut',
  providerId: 'prv_sarah',
  workingDays: [
    { day: 'MONDAY', workingHours: [{ from: 540, to: 1020 }] },
    { day: 'TUESDAY', workingHours: [{ from: 540, to: 1020 }] }
  ],
  specificDates: [],
  prices: [{ market: 'us', amount: 5000 }],
  durations: [{ duration: 60, isPause: false }],
  slotInterval: 30
});

Update Service Provider

await sdk.booking.updateServiceProvider({
  id: 'sp_abc123',
  workingDays: [/* ... */],
  specificDates: [],
  slotInterval: 30
});

Delete Service Provider

await sdk.booking.deleteServiceProvider({
  id: 'sp_abc123'
});

Availability

Get Availability

Fetch available slots for a service in a given month. Returns a per-provider, per-day breakdown with open spots.

const availability = await sdk.booking.getAvailability({
serviceId: 'svc_haircut',
month: '2026-04',
providerId: 'prv_sarah' // optional
});

availability.providers.forEach(provider => {
provider.days.forEach(day => {
  day.slots.forEach(slot => {
    console.log(day.date, slot.from, slot.to, 'spots:', slot.spots);
  });
});
});

Cart (Client-Side)

The SDK provides local cart management for building booking flows. The cart lives in memory on the client — it is not persisted server-side.

Add to Cart

sdk.booking.addToCart({
  id: 'slot_123',
  serviceId: 'svc_haircut',
  providerId: 'prv_sarah',
  from: 1704110400,  // Unix timestamp
  to: 1704112200,
  timeText: '10:00 AM',
  dateText: 'Jan 15, 2024'
});

Get Cart

const cart = sdk.booking.getCart();
// Returns array of Slot objects
console.log(cart);

Remove from Cart

sdk.booking.removeFromCart('slot_123');

Clear Cart

sdk.booking.clearCart();

Bookings

Create Booking

Create a booking directly (without going through checkout). Most flows should use checkout() instead.

const result = await sdk.booking.createBooking({
  // booking payload
});

Get Booking

const result = await sdk.booking.getBooking({
  id: 'bkg_xyz789'
});

console.log(result.status, result.parts, result.payment);

Search Bookings

const result = await sdk.booking.searchBookings({
query: 'john@example.com',
serviceIds: ['svc_haircut'],
providerIds: ['prv_sarah'],
from: 1704067200,  // Unix timestamp
to: 1704672000,
status: 'CONFIRMED',
sortField: 'createdAt',
sortOrder: 'desc',
cursor: null,
limit: 50
});

result.items.forEach(booking => {
console.log(booking.id, booking.status);
});

Update Booking

await sdk.booking.updateBooking({
  id: 'bkg_xyz789',
  status: 'CANCELLED',
  forms: [/* updated form submissions */],
  parts: [/* updated booking parts */],
  payment: null
});

Checkout

Get Quote

Calculate pricing before checkout. Items are grouped by service + provider, with an array of slot ranges.

const quote = await sdk.booking.getQuote({
items: [
  {
    serviceId: 'svc_haircut',
    providerId: 'prv_sarah',
    slots: [
      { from: 1704110400, to: 1704112200 }
    ]
  }
],
paymentMethodId: 'pm_card_visa',
promoCode: 'FIRSTVISIT',
location: {
  country: 'US',
  state: 'NY',
  postalCode: '10001'
}
});

console.log('Subtotal:', quote.subtotal);
console.log('Total:', quote.total);

Checkout

Process payment and create a booking. If items is omitted, the SDK groups the client-side cart into items automatically.

// Using cart items (if cart has items)
const result = await sdk.booking.checkout({
paymentMethodId: 'pm_card_visa',
forms: [
  {
    formId: 'form_customer_info',
    values: {
      email: 'customer@example.com',
      firstName: 'John',
      lastName: 'Doe',
      phone: '+1234567890'
    }
  }
],
promoCodeId: 'promo_firstvisit',
location: {
  country: 'US',
  state: 'NY',
  postalCode: '10001'
}
});

// Or provide items directly
const result2 = await sdk.booking.checkout({
items: [
  {
    serviceId: 'svc_haircut',
    providerId: 'prv_sarah',
    slots: [{ from: 1704110400, to: 1704112200 }]
  }
],
paymentMethodId: 'pm_card_visa',
forms: []
});

Complete Booking Flow

async function bookAppointment() {
  // 1. Get available services
  const services = await sdk.booking.getServices({
    statuses: ['ACTIVE']
  });

  // 2. Get providers for a service
  const providers = await sdk.booking.getProviders({
    serviceId: 'svc_haircut',
    statuses: ['ACTIVE']
  });

  // 3. Get availability for a given month
  const availability = await sdk.booking.getAvailability({
    serviceId: 'svc_haircut',
    month: '2026-04'
  });

  // 4. User selects a slot - add to cart
  sdk.booking.addToCart({
    id: 'slot_unique_id',
    serviceId: 'svc_haircut',
    providerId: 'prv_sarah',
    from: 1704110400,
    to: 1704112200,
    timeText: '10:00 AM',
    dateText: 'Jan 15, 2024'
  });

  // 5. Get quote (items are grouped by service + provider with slots[])
  const cart = sdk.booking.getCart();
  const quote = await sdk.booking.getQuote({
    items: [
      {
        serviceId: 'svc_haircut',
        providerId: 'prv_sarah',
        slots: cart.map(s => ({ from: s.from, to: s.to }))
      }
    ],
    promoCode: 'FIRSTVISIT'
  });

  console.log('Total:', quote.total);

  // 6. Checkout (uses cart automatically if items omitted)
  const result = await sdk.booking.checkout({
    paymentMethodId: 'pm_card_visa',
    forms: [
      {
        formId: 'form_customer_info',
        values: {
          email: 'customer@example.com',
          firstName: 'John',
          lastName: 'Doe'
        }
      }
    ]
  });

  // 7. Clear cart after successful booking
  sdk.booking.clearCart();

  return result;
}