Zenoti MCP server for AI agents

Let Claude, ChatGPT or your own agent read and act on Zenoti: 12 typed functions through one MCP server. No Zenoti API key needed.

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

Connect

Just Zenoti

An MCP server for Zenoti 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/zenoti
Every site

One MCP server for Zenoti 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 9
  • findTenantFinds the Zenoti webstore behind a salon, spa or clinic -- from its own website, a booking link, or a <tenant>.zenoti.com URL -- and returns the…

    Arguments

    NameTypeRequired
    businessstringYes

    Returns ZenotiTenantRef

    interface ZenotiTenantRef {
      tenant: string;         // pass to listCenters / searchServices / getAvailableTimes
      webstoreUrl: string;
      apiHost: string;
      defaultCenterId: string;
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/zenoti/findTenant

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.zenoti.findTenant("bishops.co");
  • getAvailableTimesReturns open appointment times for one or more services at a center on a date, optionally for a specific provider.

    Arguments

    NameTypeRequired
    tenantstringYes
    centerIdstringYes
    serviceIdstringYes
    datestringYes

    Returns ZenotiAvailability

    interface ZenotiSlot {
      time: string;           // ISO-8601, the tenant's own local wall time
      available: boolean;
    }
    
    interface ZenotiAvailability {
      tenant: string;
      centerId: string;
      serviceId: string;
      date: string;
      slots: ZenotiSlot[];    // verbatim -- empty is a real answer (fully booked / closed)
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/zenoti/getAvailableTimes

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.zenoti.getAvailableTimes("<tenant>", "<centerId>", "<serviceId>", "<date>");
  • getServiceReturns one service's full detail -- description, price, duration, add-ons and which providers perform it.

    Arguments

    NameTypeRequired
    tenantstringYes
    centerIdstringYes
    serviceIdstringYes

    Returns ZenotiServiceDetail

    interface ZenotiService {
      id: string;             // the serviceId getAvailableTimes takes
      name: string;
      description: string | null;
      durationMinutes: number | null;
      price: number | null;
    }
    
    interface ZenotiServiceDetail extends ZenotiService {
      categoryId: string | null;
      categoryName: string | null;
      canBook: boolean;
      depositRequired: boolean;
      depositAmount: number | null;
      addOns: ZenotiService[];  // bookable alongside this service
    }

    HTTP endpoint

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

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.zenoti.getService("<tenant>", "<centerId>", "<serviceId>");
  • listCentersLists a tenant's locations (Zenoti 'centers') with name, address, phone, time zone and the centerId every other call needs.

    Arguments

    NameTypeRequired
    tenantstringYes

    Returns ZenotiCenter[]

    interface ZenotiCenter {
      id: string;             // the centerId the other functions take
      name: string;
      phone: string | null;
      address: string | null;
      city: string | null;
      state: string | null;
      zipCode: string | null;
      timeZone: string | null;
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/zenoti/listCenters

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.zenoti.listCenters("bishops");
  • listClassSessionsLists scheduled group classes (yoga, fitness, workshops) at a center for a date range with instructor and spots left, for tenants that sell classes.

    Arguments

    NameTypeRequired
    tenantstringYes
    centerIdstringYes
    startDatestringYes
    endDatestringYes

    Returns ZenotiClassSessionList

    interface ZenotiClassInstructor {
      id: string;
      name: string;
    }
    
    interface ZenotiClassSession {
      sessionGuid: string;     // the class session's own id
      className: string;
      classId: number | string;
      startTime: string;       // the tenant's own local wall time, ISO-8601
      endTime: string;
      instructors: ZenotiClassInstructor[];
      capacity: number | null;
      availableSlots: number | null;
      price: number | null;
      canBook: boolean;
    }
    
    interface ZenotiClassSessionList {
      tenant: string;
      centerId: string;
      startDate: string;
      endDate: string;
      sessions: ZenotiClassSession[];  // verbatim -- empty is a real answer (no classes scheduled in range, or this tenant sells none)
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/zenoti/listClassSessions

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.zenoti.listClassSessions("corepoweryoga", "eb794fce-d8e6-4a1e-acd4-8e25c3b0d03a", { $daysFromNow: -90 }, { $daysFromNow: 30 });
  • listMyAppointmentsLists the signed-in caller's own upcoming (default) or past appointments at one business.

    Arguments

    NameTypeRequired
    tenantstringYes
    when"upcoming" | "past"No

    Returns ZenotiAppointment[]

    interface ZenotiAppointment {
      appointmentId: string;
      appointmentGroupId: string | null;
      serviceName: string | null;
      startTime: string;       // the tenant's own local wall time
      status: string | number | null;  // Zenoti's own status code, verbatim
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/zenoti/listMyAppointments

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.zenoti.listMyAppointments("bishops", "upcoming");
  • listProvidersLists the staff (Zenoti 'therapists') who can perform a service at a center, so a caller can ask for a specific person.

    Arguments

    NameTypeRequired
    tenantstringYes
    centerIdstringYes
    serviceIdstringYes

    Returns ZenotiProvider[]

    interface ZenotiProvider {
      id: string;             // a Zenoti 'therapist' -- the staff member
      name: string;           // the display name the webstore shows
      firstName: string | null;
      price: number | null;   // this person's own price for the service
      durationMinutes: number | null;
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/zenoti/listProviders

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.zenoti.listProviders("<tenant>", "<centerId>", "<serviceId>");
  • listServiceCategoriesLists a center's service categories (Hair, Massage, Facials...) with their ids, as the webstore's menu shows them.

    Arguments

    NameTypeRequired
    tenantstringYes
    centerIdstringYes

    Returns ZenotiServiceCategory[]

    interface ZenotiServiceCategory {
      id: string;
      name: string;           // trimmed -- tenants type "Cuts " with a trailing space
      description: string | null;
      sortOrder: number | null;
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/zenoti/listServiceCategories

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.zenoti.listServiceCategories("bishops", "d1f71f1a-ba64-4f2f-9a96-c0e0b6e03739");
  • searchServicesLists or searches a center's bookable services: name, description, price, duration and service id.

    Arguments

    NameTypeRequired
    tenantstringYes
    centerIdstringYes
    querystringNo

    Returns ZenotiService[]

    interface ZenotiService {
      id: string;             // the serviceId getAvailableTimes takes
      name: string;
      description: string | null;
      durationMinutes: number | null;
      price: number | null;
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/zenoti/searchServices

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.zenoti.searchServices("bishops", "d1f71f1a-ba64-4f2f-9a96-c0e0b6e03739", "cut");
Act 3
  • bookAppointmentBooks one or more services at a center for a chosen open time, as the signed-in caller.

    Arguments

    NameTypeRequired
    args{ tenant: string, centerId: string, serviceId: string, time: string, providerId?: string }Yes

    Returns ZenotiBooking

    interface ZenotiBooking {
      status: "booked" | "payment_required";  // payment_required = NOT confirmed; the hold lapses
      reservationId: string;
      invoiceId: string | null;
      bookingId: string | null;
      amountDue: number;       // what the business wants paid at booking; 0 when booked
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/zenoti/bookAppointment

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.zenoti.bookAppointment({});
  • cancelAppointmentCancels one of the signed-in caller's appointments, reporting any cancellation fee the business states before confirming.

    Arguments

    NameTypeRequired
    args{ tenant: string, appointmentId: string, reason?: string }Yes

    Returns ZenotiCancellation

    interface ZenotiCancellation {
      status: "cancelled" | "fee_required";  // fee_required = NOT cancelled; the appointment stands
      appointmentId: string;
      cancellationCharges: number;  // the fee the business states; 0 when cancelled free
      depositRefunded: boolean;
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/zenoti/cancelAppointment

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.zenoti.cancelAppointment({});
  • rescheduleAppointmentMoves the signed-in caller's appointment to another open time for the same service, holding the new time before giving up the old one, and stopping…

    Arguments

    NameTypeRequired
    args{ tenant: string, appointmentId: string, time: string, providerId?: string }Yes

    Returns ZenotiReschedule

    interface ZenotiReschedule {
      status: "rescheduled" | "fee_required" | "payment_required";  // only "rescheduled" moved anything
      appointmentId: string;   // the old appointment
      reservationId: string | null;
      bookingId: string | null;  // the new booking, when rescheduled
      cancellationCharges: number;  // fee the business states for giving up the old time
      amountDue: number;       // what the new slot wants paid at booking
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/zenoti/rescheduleAppointment

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.zenoti.rescheduleAppointment({});

Use it from code