Mangomint MCP server for AI agents

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

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

Connect

Just Mangomint

An MCP server for Mangomint 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/mangomint
Every site

One MCP server for Mangomint 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 13
  • checkAvailabilityLists open appointment times for one or more services over a date range, with any staff member or a named one.

    Arguments

    NameTypeRequired
    argsMangomintCheckAvailabilityArgsYes
    /** A business, as the caller holds it: its booking link
     * ("https://booking.mangomint.com/waxculture"), alias ("waxculture"), numeric
     * company id ("236723"), or its own website ("https://waxculture.com"). */
    interface MangomintBusinessArgs {
      business: string;
      /** Only for a multi-location business: the number after the alias in its booking link. */
      locationId?: number;
    }
    
    interface MangomintAvailabilityRequestService {
      serviceId: number;
      /** A specific staff member, read off listStaff/getService. Omit for "any staff". */
      staffId?: number;
      serviceOptionIds?: number[];
    }
    
    interface MangomintCheckAvailabilityArgs extends MangomintBusinessArgs {
      services: MangomintAvailabilityRequestService[];
      /** YYYY-MM-DD, the first day to check. */
      startDate: string;
      /** How many days forward to check. Default 7. */
      numDays?: number;
    }

    Returns MangomintAvailability

    interface MangomintAvailabilitySlot {
      startAtLocal: string;
    }
    
    interface MangomintAvailabilityDay {
      date: string;
      morningSlots: MangomintAvailabilitySlot[];
      afternoonSlots: MangomintAvailabilitySlot[];
      eveningSlots: MangomintAvailabilitySlot[];
      allowJoinWaitlist: boolean;
    }
    
    interface MangomintAvailability {
      business: { companyId: number; name: string };
      /** The earliest open date the business found, even outside the requested range; null when nothing is open. */
      firstAvailableDate: string | null;
      days: MangomintAvailabilityDay[];
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/mangomint/checkAvailability

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.mangomint.checkAvailability({
      business: "waxculture",
      services: [{ serviceId: 14 }],
      startDate: { $daysFromNow: 7 }
    });
  • findBusinessFinds a Mangomint business from what a caller has: its booking link (booking.mangomint.com/<alias-or-id>[/<locationId>]), its alias ('waxculture')…

    Arguments

    NameTypeRequired
    businessstringYes
    locationIdnumber
    Only for a multi-location business: the number after the alias in its booking link.
    No

    Returns MangomintBusiness

    interface MangomintBusiness {
      companyId: number;
      /** The id or alias as the booking link spells it, pass it back as `business`. */
      key: string;
      locationId: number | null;
      name: string;
      timezoneId: string | null;
      bookingUrl: string;
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/mangomint/findBusiness

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.mangomint.findBusiness({ business: "waxculture" });
  • getBusinessInfoReturns one business's profile: name, address, phone, email, website, time zone, currency, cancellation policy, how far ahead it takes bookings, and…

    Arguments

    NameTypeRequired
    businessstringYes
    locationIdnumber
    Only for a multi-location business: the number after the alias in its booking link.
    No

    Returns MangomintBusinessInfo

    interface MangomintBusiness {
      companyId: number;
      /** The id or alias as the booking link spells it, pass it back as `business`. */
      key: string;
      locationId: number | null;
      name: string;
      timezoneId: string | null;
      bookingUrl: string;
    }
    
    interface MangomintBusinessInfo extends MangomintBusiness {
      email: string | null;
      phone: string | null;
      address: string | null;
      currencyCode: string | null;
      maxDaysFutureBooking: number | null;
      cancellationPolicyHtml: string | null;
      savedCardRequiredHtml: string | null;
      smsSignInEnabled: boolean;
      waitlistEnabled: boolean;
      groupBookingEnabled: boolean;
      /** A Turnstile check guards booking at this business. */
      challengeRequired: boolean;
      packagesUrl: string | null;
      membershipsUrl: string | null;
      giftCardsUrl: string | null;
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/mangomint/getBusinessInfo

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.mangomint.getBusinessInfo({ business: "236723" });
  • getServiceReturns one service with its full description, its add-on options, which staff perform it, and each staff member's own price and duration for it.

    Arguments

    NameTypeRequired
    argsMangomintServiceArgsYes
    /** A business, as the caller holds it: its booking link
     * ("https://booking.mangomint.com/waxculture"), alias ("waxculture"), numeric
     * company id ("236723"), or its own website ("https://waxculture.com"). */
    interface MangomintBusinessArgs {
      business: string;
      /** Only for a multi-location business: the number after the alias in its booking link. */
      locationId?: number;
    }
    
    interface MangomintServiceArgs extends MangomintBusinessArgs {
      /** From listServices. */
      serviceId: number;
    }

    Returns MangomintServiceDetail

    interface MangomintService {
      id: number;
      name: string;
      description: string | null;
      categoryId: number | null;
      categoryName: string | null;
      durationMinutes: number | null;
      price: number | null;
      minPrice: number | null;
      isPriceRange: boolean;
      hidePrice: boolean;
      prepayRequired: boolean;
      savedCardRequired: boolean;
      promptToCall: boolean;
      requiresTwoStaff: boolean;
      isGroupService: boolean;
    }
    
    interface MangomintServiceOption {
      id: number;
      name: string;
      description: string | null;
      durationMinutes: number;
      price: number | null;
    }
    
    interface MangomintServiceOptionGroup {
      id: number;
      name: string;
      prompt: string | null;
      selectAtLeast: number | null;
      selectAtMost: number | null;
      options: MangomintServiceOption[];
    }
    
    interface MangomintServiceStaffPricing {
      staffId: number;
      /** Overrides this service's own price/duration for this staff member.
       * null means the service's own `price`/`durationMinutes` applies. */
      customPrice: number | null;
      customDurationMinutes: number | null;
    }
    
    interface MangomintServiceDetail extends MangomintService {
      staffIds: number[];
      optionGroups: MangomintServiceOptionGroup[];
      staffPricing: MangomintServiceStaffPricing[];
    }

    HTTP endpoint

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

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.mangomint.getService({ business: "waxculture", serviceId: 14 });
  • getStaffReturns one staff member with their bio, photo, the services they perform at their own price, and the weekdays they work.

    Arguments

    NameTypeRequired
    argsMangomintGetStaffArgsYes
    /** A business, as the caller holds it: its booking link
     * ("https://booking.mangomint.com/waxculture"), alias ("waxculture"), numeric
     * company id ("236723"), or its own website ("https://waxculture.com"). */
    interface MangomintBusinessArgs {
      business: string;
      /** Only for a multi-location business: the number after the alias in its booking link. */
      locationId?: number;
    }
    
    interface MangomintGetStaffArgs extends MangomintBusinessArgs {
      /** From listStaff. */
      staffId: number;
    }

    Returns MangomintStaffDetail

    interface MangomintStaffMember {
      id: number;
      firstName: string;
      lastName: string;
      photoUrl: string | null;
      daysWorkedRanges: { beginDayOfWeek: number; endDayOfWeekInclusive: number }[];
    }
    
    interface MangomintStaffService {
      serviceId: number;
      name: string;
      /** This staff member's own price/duration for it; null means the service's own applies. */
      customPrice: number | null;
      customDurationMinutes: number | null;
    }
    
    interface MangomintStaffDetail extends MangomintStaffMember {
      services: MangomintStaffService[];
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/mangomint/getStaff

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.mangomint.getStaff({ business: "waxculture", staffId: 6 });
  • listLocationsLists a multi-location business's locations with their ids and booking links, so a booking can be pointed at the right one.

    Arguments

    NameTypeRequired
    businessstringYes
    locationIdnumber
    Only for a multi-location business: the number after the alias in its booking link.
    No

    Returns MangomintLocationList

    interface MangomintLocation {
      id: number;
      name: string;
      /** Pass this as `locationId` to any other function on this business. */
      locationId: number;
      bookingUrl: string;
      groupBookingEnabled: boolean;
    }
    
    interface MangomintLocationList {
      business: { companyId: number; name: string };
      locations: MangomintLocation[];
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/mangomint/listLocations

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.mangomint.listLocations({ business: "653191" });
  • listMembershipsLists the memberships a business sells online with price, billing period and what each includes.

    Arguments

    NameTypeRequired
    businessstringYes
    locationIdnumber
    Only for a multi-location business: the number after the alias in its booking link.
    No

    Returns MangomintMembershipList

    interface MangomintMembership {
      id: number;
      name: string;
      shortDescription: string | null;
      priceInterval: number | null;
      repeatType: string | null;
      productDiscountPct: number | null;
      serviceDiscountPct: number | null;
    }
    
    interface MangomintMembershipList {
      business: { companyId: number; name: string };
      memberships: MangomintMembership[];
    }

    HTTP endpoint

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

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.mangomint.listMemberships({ business: "waxculture" });
  • listPackagesLists the prepaid service packages a business sells online (e.g. six red-light sessions) with price and the services each covers.

    Arguments

    NameTypeRequired
    businessstringYes
    locationIdnumber
    Only for a multi-location business: the number after the alias in its booking link.
    No

    Returns MangomintPackageList

    interface MangomintPackageItem {
      serviceId: number;
      quantity: number;
    }
    
    interface MangomintPackage {
      id: number;
      name: string;
      shortDescription: string | null;
      totalPrice: number | null;
      items: MangomintPackageItem[];
      expires: boolean;
      expirationValue: number | null;
      expirationUnit: string | null;
    }
    
    interface MangomintPackageList {
      business: { companyId: number; name: string };
      packages: MangomintPackage[];
    }

    HTTP endpoint

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

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.mangomint.listPackages({ business: "waxculture" });
  • listPastServicesLists the services the signed-in caller has had at a business before, so they can rebook the same thing.

    Arguments

    NameTypeRequired
    businessstringYes
    locationIdnumber
    Only for a multi-location business: the number after the alias in its booking link.
    No

    Returns MangomintPastServices

    interface MangomintPastServices {
      business: { companyId: number; name: string };
      /** The booking app's own rows, unparsed, no signed-in answer has been captured yet. */
      pastServices: unknown[];
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/mangomint/listPastServices

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.mangomint.listPastServices({ business: "waxculture" });
  • listServiceCategoriesLists a business's service categories (waxing, facials, massage…) with the services in each.

    Arguments

    NameTypeRequired
    businessstringYes
    locationIdnumber
    Only for a multi-location business: the number after the alias in its booking link.
    No

    Returns MangomintServiceCategoryList

    interface MangomintServiceCategory {
      id: number;
      name: string;
      serviceIds: number[];
    }
    
    interface MangomintServiceCategoryList {
      business: { companyId: number; name: string };
      categories: MangomintServiceCategory[];
    }

    HTTP endpoint

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

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.mangomint.listServiceCategories({ business: "waxculture" });
  • listServicesLists a business's bookable services, optionally within one category: id, name, description, duration, price or price range, and whether it needs…

    Arguments

    NameTypeRequired
    argsMangomintListServicesArgsYes
    /** A business, as the caller holds it: its booking link
     * ("https://booking.mangomint.com/waxculture"), alias ("waxculture"), numeric
     * company id ("236723"), or its own website ("https://waxculture.com"). */
    interface MangomintBusinessArgs {
      business: string;
      /** Only for a multi-location business: the number after the alias in its booking link. */
      locationId?: number;
    }
    
    interface MangomintListServicesArgs extends MangomintBusinessArgs {
      /** Only services in this category. */
      categoryId?: number;
    }

    Returns MangomintServiceList

    interface MangomintService {
      id: number;
      name: string;
      description: string | null;
      categoryId: number | null;
      categoryName: string | null;
      durationMinutes: number | null;
      price: number | null;
      minPrice: number | null;
      isPriceRange: boolean;
      hidePrice: boolean;
      prepayRequired: boolean;
      savedCardRequired: boolean;
      promptToCall: boolean;
      requiresTwoStaff: boolean;
      isGroupService: boolean;
    }
    
    interface MangomintServiceList {
      business: { companyId: number; name: string };
      services: MangomintService[];
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/mangomint/listServices

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.mangomint.listServices({ business: "waxculture" });
  • listStaffLists a business's bookable staff with id, name, photo and the weekdays they work, optionally only those who perform a given service.

    Arguments

    NameTypeRequired
    argsMangomintListStaffArgsYes
    /** A business, as the caller holds it: its booking link
     * ("https://booking.mangomint.com/waxculture"), alias ("waxculture"), numeric
     * company id ("236723"), or its own website ("https://waxculture.com"). */
    interface MangomintBusinessArgs {
      business: string;
      /** Only for a multi-location business: the number after the alias in its booking link. */
      locationId?: number;
    }
    
    interface MangomintListStaffArgs extends MangomintBusinessArgs {
      /** Only staff who perform this service. */
      serviceId?: number;
    }

    Returns MangomintStaffList

    interface MangomintStaffMember {
      id: number;
      firstName: string;
      lastName: string;
      photoUrl: string | null;
      daysWorkedRanges: { beginDayOfWeek: number; endDayOfWeekInclusive: number }[];
    }
    
    interface MangomintStaffList {
      business: { companyId: number; name: string };
      staff: MangomintStaffMember[];
    }

    HTTP endpoint

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

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.mangomint.listStaff({ business: "waxculture" });
  • validateSlotChecks that a time returned by checkAvailability is still free immediately before booking it.

    Arguments

    NameTypeRequired
    argsMangomintValidateSlotArgsYes
    /** A business, as the caller holds it: its booking link
     * ("https://booking.mangomint.com/waxculture"), alias ("waxculture"), numeric
     * company id ("236723"), or its own website ("https://waxculture.com"). */
    interface MangomintBusinessArgs {
      business: string;
      /** Only for a multi-location business: the number after the alias in its booking link. */
      locationId?: number;
    }
    
    interface MangomintAvailabilityRequestService {
      serviceId: number;
      /** A specific staff member, read off listStaff/getService. Omit for "any staff". */
      staffId?: number;
      serviceOptionIds?: number[];
    }
    
    interface MangomintValidateSlotArgs extends MangomintBusinessArgs {
      services: MangomintAvailabilityRequestService[];
    
      startAtLocal: string;
    }

    Returns MangomintSlotCheck

    interface MangomintSlotCheck {
      startAtLocal: string;
      valid: boolean;
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/mangomint/validateSlot

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.mangomint.validateSlot({
      business: "waxculture",
      services: [{ serviceId: 14 }],
      startAtLocal: "2026-11-05T03:00:00"
    });
Act 2
  • bookAppointmentBooks one or more services at a time from checkAvailability for the caller, with their name, phone and email.

    Arguments

    NameTypeRequired
    argsMangomintBookAppointmentArgsYes
    /** A business, as the caller holds it: its booking link
     * ("https://booking.mangomint.com/waxculture"), alias ("waxculture"), numeric
     * company id ("236723"), or its own website ("https://waxculture.com"). */
    interface MangomintBusinessArgs {
      business: string;
      /** Only for a multi-location business: the number after the alias in its booking link. */
      locationId?: number;
    }
    
    interface MangomintAvailabilityRequestService {
      serviceId: number;
      /** A specific staff member, read off listStaff/getService. Omit for "any staff". */
      staffId?: number;
      serviceOptionIds?: number[];
    }
    
    interface MangomintBookAppointmentClient {
      firstName: string;
      lastName: string;
      /** Any format, the site's own form takes free text, e.g. "(201) 555-0147". */
      phone: string;
      email: string;
    }
    
    interface MangomintBookAppointmentArgs extends MangomintBusinessArgs {
      services: MangomintAvailabilityRequestService[];
    
      startAtLocal: string;
      client: MangomintBookAppointmentClient;
      /** Shown to the business with the appointment. */
      notes?: string;
    }

    Returns MangomintBookingConfirmation

    interface MangomintBookingFormLink {
      url: string;
    }
    
    interface MangomintBookingConfirmation {
      business: { companyId: number; name: string };
      appointmentId: number;
      clientId: number;
      startAtLocal: string;
      price: { minPrice: number | null; maxPrice: number | null; isPriceRange: boolean };
      /** Intake forms the business wants filled before the appointment, if any. */
      formLinks: MangomintBookingFormLink[];
    }

    HTTP endpoint

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

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.mangomint.bookAppointment("<args>");
  • joinWaitlistPuts the caller on a business's waitlist for one or more services over a date range, with the times of day they're free.

    Arguments

    NameTypeRequired
    argsMangomintJoinWaitlistArgsYes
    /** A business, as the caller holds it: its booking link
     * ("https://booking.mangomint.com/waxculture"), alias ("waxculture"), numeric
     * company id ("236723"), or its own website ("https://waxculture.com"). */
    interface MangomintBusinessArgs {
      business: string;
      /** Only for a multi-location business: the number after the alias in its booking link. */
      locationId?: number;
    }
    
    interface MangomintAvailabilityRequestService {
      serviceId: number;
      /** A specific staff member, read off listStaff/getService. Omit for "any staff". */
      staffId?: number;
      serviceOptionIds?: number[];
    }
    
    interface MangomintJoinWaitlistClient {
      firstName: string;
      lastName: string;
      /** Any format, the site's own form takes free text, e.g. "(201) 555-0147". */
      phone: string;
      email: string;
    }
    
    interface MangomintJoinWaitlistArgs extends MangomintBusinessArgs {
      services: MangomintAvailabilityRequestService[];
      /** YYYY-MM-DD, the first day the caller is available. */
      startDate: string;
      /** How many days forward from startDate the caller is available. Default 1 (just startDate). */
      numDays?: number;
      /** Which part of the day the caller is available. Default all three. */
      timesOfDay?: ("morning" | "afternoon" | "evening")[];
      client: MangomintJoinWaitlistClient;
      /** Shown to the business with the waitlist entry. */
      notes?: string;
    }

    Returns MangomintWaitlistEntry

    interface MangomintAvailabilityRequestService {
      serviceId: number;
      /** A specific staff member, read off listStaff/getService. Omit for "any staff". */
      staffId?: number;
      serviceOptionIds?: number[];
    }
    
    interface MangomintJoinWaitlistClient {
      firstName: string;
      lastName: string;
      /** Any format, the site's own form takes free text, e.g. "(201) 555-0147". */
      phone: string;
      email: string;
    }
    
    interface MangomintWaitlistEntry {
      business: { companyId: number; name: string };
      services: MangomintAvailabilityRequestService[];
      startDate: string;
      endDateExclusive: string;
      timesOfDay: string[];
      client: MangomintJoinWaitlistClient;
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/mangomint/joinWaitlist

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.mangomint.joinWaitlist("<args>");

Use it from code