Booker MCP server for AI agents

Let Claude, ChatGPT or your own agent read Booker: 17 typed functions through one MCP server. No Booker API key needed.

Functions
17
Sign-in
For account actions
Works with
MCP, HTTP, Node, Python

Connect

Just Booker

An MCP server for Booker alone, with one tool per function. Paste it into Claude, ChatGPT, Cursor or any MCP client as a remote server.

https://api.bowmark.ai/mcp/site/booker
Every site

One MCP server for Booker and every other site Bowmark covers. Your agent looks up what it needs and calls it.

https://api.bowmark.ai/mcp
Set it up in your client

Both need a Bowmark API key. The quickstart gets you one and a first result in a few minutes. Functions that need a login use the person's own account: how sign-in works.

Functions

Open a function to see its arguments, what it returns and how to call it.

Read 17
  • findLocationResolves a Booker storefront to its location record: pass a slug (kabuki) or a go.booker.com/location/<slug> URL, get back the numeric location id…

    Arguments

    NameTypeRequired
    locationstring
    A location slug (kabuki) or a go.booker.com/location/<slug> URL.
    Yes

    Returns BookerLocation

    interface BookerLocation {
      id: number;
      slug: string;
      name: string;
      businessType: string | null;
      description: string | null;
      address: { street1: string | null; street2: string | null; city: string | null; state: string | null; zip: string | null; country: string | null };
      phone: string | null;
      email: string | null;
      website: string | null;
      timeZone: string | null;
      currency: string | null;
      brandId: number | null;
      brandSlug: string | null;
      closedDates: string[];
      storefrontUrl: string;
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/booker/findLocation

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.booker.findLocation({ location: "kabuki" });
  • getAvailabilityReturns the open appointment start times for a service on one local date at a location, each with the staff ids who can take it, plus the service's…

    Arguments

    NameTypeRequired
    locationstring
    A location slug (kabuki) or a go.booker.com/location/<slug> URL.
    Yes
    serviceIdnumber
    The numeric id from getServiceMenu's serviceId.
    Yes
    datestring
    YYYY-MM-DD, the location's local date.
    No
    staffIdnumber
    Only slots this staff member (listStaff's id) can take.
    No

    Returns BookerAvailability

    interface BookerAvailability {
      serviceId: number;
      serviceName: string | null;
      date: string;
      durationMinutes: number | null;
      price: number | null;
      /** `start` is an ISO instant in the location's own offset; staffIds are listStaff ids. */
      slots: { start: string; staffIds: number[] }[];
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/booker/getAvailability

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.booker.getAvailability({ location: "kabuki", serviceId: 311279 });
  • getAvailableDatesReturns the local dates a service has at least one open appointment at a location over a date range (default 30 days), optionally for one staff…

    Arguments

    NameTypeRequired
    locationstring
    A location slug (kabuki) or a go.booker.com/location/<slug> URL.
    Yes
    serviceIdnumber
    The numeric id from getServiceMenu's serviceId.
    Yes
    fromDatestring
    YYYY-MM-DD, the location's local date.
    No
    toDatestring
    YYYY-MM-DD. Defaults to 30 days after fromDate.
    No
    staffIdnumber
    Only dates this staff member (listStaff's id) has open.
    No

    Returns BookerAvailableDates

    interface BookerAvailableDates {
      serviceId: number;
      /** Local calendar dates (YYYY-MM-DD) with at least one open time. */
      dates: string[];
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/booker/getAvailableDates

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.booker.getAvailableDates({ location: "kabuki", serviceId: 311279 });
  • getBookingPoliciesReturns a location's booking rules: its cancellation policy text and fee window, how far in advance appointments can be booked, whether a card or…

    Arguments

    NameTypeRequired
    locationstring
    A location slug (kabuki) or a go.booker.com/location/<slug> URL.
    Yes

    Returns BookerBookingPolicies

    interface BookerFee {
      type: string | null;
      amount: number | null;
      percentage: number | null;
    }
    
    interface BookerBookingPolicies {
      locationId: number;
      onlineBookingEnabled: boolean | null;
      cancellation: {
        active: boolean | null;
        text: string | null;
        /** Hours of notice a cancel needs to avoid the fee. */
        hoursNotice: number | null;
        appliesTo: string | null;
        fee: BookerFee;
        noShowFee: BookerFee;
        onlineCancelAllowed: boolean | null;
        reasons: string[];
      };
      payment: { cardRequired: boolean | null; preAuthorizeCard: boolean | null; methods: string[] };
      /** How far ahead the storefront books. */
      bookAhead: { amount: number | null; unit: "day" | "week" | "month" | null };
      /** The latest an appointment can be booked before it starts. */
      minNoticeMinutes: number | null;
      startTimeIntervalMinutes: number | null;
      canChooseStaff: boolean | null;
      multiServiceBooking: boolean | null;
      groupBooking: boolean | null;
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/booker/getBookingPolicies

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.booker.getBookingPolicies({ location: "kabuki" });
  • getGroupAvailabilityFinds start times when several guests can each begin a service together (a couples' booking).

    Arguments

    NameTypeRequired
    locationstring
    A location slug (kabuki) or a go.booker.com/location/<slug> URL.
    Yes
    serviceIdsnumber[]
    Two to six numeric serviceIds from getServiceMenu.
    Yes
    datestring
    YYYY-MM-DD, the location's local date.
    No

    Returns BookerGroupAvailability

    interface BookerGroupGuestOption {
      serviceId: number;
      staffId: number | null;
      durationMinutes: number | null;
      price: number | null;
    }
    
    interface BookerGroupAvailability {
      serviceIds: number[];
      /** Empty when nothing fits in the next 30 days. */
      date: string;
      slots: { start: string; options: BookerGroupGuestOption[] }[];
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/booker/getGroupAvailability

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.booker.getGroupAvailability({ location: "kabuki", serviceIds: [311279, 311279] });
  • getLocationHoursReturns a location's recurring weekly opening hours, one row per weekday.

    Arguments

    NameTypeRequired
    locationstring
    A location slug (kabuki) or a go.booker.com/location/<slug> URL.
    Yes

    Returns BookerDayHours[]

    interface BookerDayHours {
      weekday: string;
      /** Local time of day, e.g. "10:00". Null when the day is closed. */
      opens: string | null;
      closes: string | null;
      closedReason: string | null;
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/booker/getLocationHours

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.booker.getLocationHours({ location: "kabuki" });
  • getMultiServiceAvailabilityFinds open times for several services booked as one visit, back to back (for example a facial followed by a massage).

    Arguments

    NameTypeRequired
    locationstring
    A location slug (kabuki) or a go.booker.com/location/<slug> URL.
    Yes
    serviceIdsnumber[]
    Two to six numeric serviceIds from getServiceMenu.
    Yes
    datestring
    YYYY-MM-DD, the location's local date.
    No

    Returns BookerMultiServiceAvailability

    interface BookerVisitItem {
      serviceId: number;
      /** ISO instant in the location's own offset. */
      start: string;
      durationMinutes: number | null;
      staffId: number | null;
    }
    
    interface BookerMultiServiceAvailability {
      serviceIds: number[];
      /** Empty when nothing fits in the next 30 days. */
      date: string;
      visits: { start: string; items: BookerVisitItem[] }[];
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/booker/getMultiServiceAvailability

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.booker.getMultiServiceAvailability({ location: "kabuki", serviceIds: [311279, 311274] });
  • getServiceReturns one service's full detail: description, category, duration, price and whether it requires two technicians.

    Arguments

    NameTypeRequired
    locationstring
    A location slug (kabuki) or a go.booker.com/location/<slug> URL.
    Yes
    serviceIdnumber
    The numeric id from getServiceMenu's serviceId.
    Yes

    Returns BookerService

    interface BookerService {
      id: number;
      name: string;
      displayName: string | null;
      description: string | null;
      category: string | null;
      subCategory: string | null;
      price: { amount: number; currencyCode: string } | null;
      totalDuration: number | null;
      treatmentDuration: number | null;
      requiresTwoTechnicians: boolean;
      isActive: boolean;
      isDeleted: boolean;
      bookableOnline: boolean;
      imageUrl: string | null;
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/booker/getService

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.booker.getService({ location: "kabuki", serviceId: 311279 });
  • getServiceMenuReturns a location's online menu in the order the storefront shows it: each section (Book, Buy) and group with its items.

    Arguments

    NameTypeRequired
    locationstring
    A location slug (kabuki) or a go.booker.com/location/<slug> URL.
    Yes

    Returns BookerServiceMenu

    interface BookerMenuItem {
      menuItemId: number;
      serviceId: number | null;
      name: string;
      type: string | null;
      action: string | null;
      description: string | null;
      duration: string | null;
      price: string | null;
      imageUrl: string | null;
    }
    
    interface BookerMenuSection {
      id: string;
      name: string;
      groups: { id: number; name: string; type: string | null; items: BookerMenuItem[] }[];
    }
    
    interface BookerServiceMenu {
      location: string;
      sections: BookerMenuSection[];
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/booker/getServiceMenu

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.booker.getServiceMenu({ location: "kabuki" });
  • getSpecialLooks up a promo or special by code at a location and returns whether it is valid there and, if so, what it discounts and its booking window.

    Arguments

    NameTypeRequired
    locationstring
    A location slug (kabuki) or a go.booker.com/location/<slug> URL.
    Yes
    codestring
    The promo / coupon code to look up.
    Yes

    Returns BookerSpecialLookup

    interface BookerSpecial {
      id: number;
      name: string | null;
      description: string | null;
      discountAmount: number | null;
      discountType: unknown;
      bookingStartDate: string | null;
      bookingEndDate: string | null;
      maxRedemptions: number | null;
      availableRedemptions: number | null;
    }
    
    interface BookerSpecialLookup {
      code: string;
      /** False when the location does not recognise the code. */
      found: boolean;
      reason: string | null;
      special: BookerSpecial | null;
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/booker/getSpecial

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.booker.getSpecial({ location: "kabuki", code: "TEST" });
  • listBrandLocationsLists every location of a multi-location Booker brand, with each location's slug, id, name, address and business type.

    Arguments

    NameTypeRequired
    brandstring
    A Booker brand account name, e.g. a BookerLocation's brandSlug.
    Yes

    Returns BookerLocationSearchResult

    interface BookerLocationSearchResult {
      /** The business name or brand slug that was searched for. */
      query: string;
    
      totalResultsCount: number;
      locations: BookerLocation[];
    }
    
    interface BookerLocation {
      id: number;
      slug: string;
      name: string;
      businessType: string | null;
      description: string | null;
      address: { street1: string | null; street2: string | null; city: string | null; state: string | null; zip: string | null; country: string | null };
      phone: string | null;
      email: string | null;
      website: string | null;
      timeZone: string | null;
      currency: string | null;
      brandId: number | null;
      brandSlug: string | null;
      closedDates: string[];
      storefrontUrl: string;
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/booker/listBrandLocations

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.booker.listBrandLocations({ brand: "hilton" });
  • listGiftCertificatesLists the gift certificate designs (card art) a location sells online.

    Arguments

    NameTypeRequired
    locationstring
    A location slug (kabuki) or a go.booker.com/location/<slug> URL.
    Yes

    Returns BookerGiftCertificates

    interface BookerGiftCertificateDesign {
      id: number;
      name: string;
      /** The card art's image URL. */
      imageUrl: string | null;
    }
    
    interface BookerGiftCertificates {
      locationId: number;
      designs: BookerGiftCertificateDesign[];
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/booker/listGiftCertificates

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.booker.listGiftCertificates({ location: "kabuki" });
  • listMembershipsLists the membership programs a location sells online, with price, billing period and member benefits.

    Arguments

    NameTypeRequired
    locationstring
    A location slug (kabuki) or a go.booker.com/location/<slug> URL.
    Yes

    Returns BookerMembershipList

    interface BookerMembershipProgram {
      /** The membership program id. */
      id: number;
      name: string;
      description: string | null;
      /** Price charged up front. */
      price: number | null;
      /** The storefront's price line, e.g. "$0.00 One time membership fee". */
      priceDisplay: string | null;
      /** How the fee recurs, e.g. ONETIME or MONTHLY. */
      billing: string | null;
      /** The storefront's term line, e.g. "Auto renews". */
      termDisplay: string | null;
      initiationDisplay: string | null;
      /** Member benefits and terms, verbatim. */
      terms: string | null;
    }
    
    interface BookerMembershipList {
      location: string;
      memberships: BookerMembershipProgram[];
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/booker/listMemberships

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.booker.listMemberships({ location: "kabuki" });
  • listPackagesLists the service packages a location sells, with what each includes and its price.

    Arguments

    NameTypeRequired
    locationstring
    A location slug (kabuki) or a go.booker.com/location/<slug> URL.
    Yes

    Returns BookerPackageList

    interface BookerMoney {
      amount: number;
      currencyCode: string;
    }
    
    interface BookerPackage {
      id: number;
      name: string;
      description: string | null;
      price: BookerMoney | null;
      originalPrice: BookerMoney | null;
      durationMinutes: number | null;
      bookableOnline: boolean;
      services: { id: number; name: string; durationMinutes: number | null; price: BookerMoney | null }[];
    }
    
    interface BookerPackageList {
      locationId: number;
      packages: BookerPackage[];
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/booker/listPackages

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.booker.listPackages({ location: "Francorchamps" });
  • listSeriesLists the prepaid service series (bundles of visits, for example ten baths) a location sells online, with price and visit count.

    Arguments

    NameTypeRequired
    locationstring
    A location slug (kabuki) or a go.booker.com/location/<slug> URL.
    Yes

    Returns BookerSeriesList

    interface BookerMoney {
      amount: number;
      currencyCode: string;
    }
    
    interface BookerSeries {
      id: number;
      name: string;
      description: string | null;
      /** How many visits the series buys. */
      visits: number | null;
      pricePerVisit: BookerMoney | null;
      /** What the whole series costs. */
      price: BookerMoney | null;
      /** The same visits bought one at a time. */
      originalPrice: BookerMoney | null;
      /** Service ids a visit can be redeemed against. */
      serviceIds: number[];
      redeemableForAnyCategory: boolean;
      daysExpireFromPurchase: number | null;
    }
    
    interface BookerSeriesList {
      locationId: number;
      series: BookerSeries[];
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/booker/listSeries

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.booker.listSeries({ location: "Francorchamps" });
  • listStaffLists the staff who perform a service at a location (id, display name, gender, rank, bio, photo), the ids getAvailability can narrow a search to.

    Arguments

    NameTypeRequired
    locationstring
    A location slug (kabuki) or a go.booker.com/location/<slug> URL.
    Yes
    serviceIdnumber
    The numeric id from getServiceMenu's serviceId.
    Yes

    Returns BookerStaff[]

    interface BookerStaff {
      id: number;
      displayName: string;
      firstName: string | null;
      lastName: string | null;
      gender: string | null;
      rank: number | null;
      profileDescription: string | null;
      photoUrl: string | null;
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/booker/listStaff

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.booker.listStaff({ location: "kabuki", serviceId: 311279 });
  • searchLocationsSearches Booker's directory of spas and salons by business name and returns matching locations (slug, id, name, address, business type), so a caller…

    Arguments

    NameTypeRequired
    businessNamestring
    A business name, or part of one.
    Yes

    Returns BookerLocationSearchResult

    interface BookerLocationSearchResult {
      /** The business name or brand slug that was searched for. */
      query: string;
    
      totalResultsCount: number;
      locations: BookerLocation[];
    }
    
    interface BookerLocation {
      id: number;
      slug: string;
      name: string;
      businessType: string | null;
      description: string | null;
      address: { street1: string | null; street2: string | null; city: string | null; state: string | null; zip: string | null; country: string | null };
      phone: string | null;
      email: string | null;
      website: string | null;
      timeZone: string | null;
      currency: string | null;
      brandId: number | null;
      brandSlug: string | null;
      closedDates: string[];
      storefrontUrl: string;
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/booker/searchLocations

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.booker.searchLocations({ businessName: "kabuki" });

Use it from code