SevenRooms MCP server for AI agents

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

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

Connect

Just SevenRooms

An MCP server for SevenRooms 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/sevenrooms
Every site

One MCP server for SevenRooms 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 8
  • getAvailabilityReturns a venue's open reservation times for a date range, party size and preferred time: per date, each shift (lunch, dinner) and its slots with…

    Arguments

    NameTypeRequired
    venuestringYes
    datestring
    YYYY-MM-DD.
    Yes
    partySizenumber
    Default 2.
    No
    timestring
    Preferred time, "HH:mm" 24h.
    No
    numDaysnumber
    Default 1, at most 14.
    No

    Returns SevenroomsAvailabilityDay[]

    interface SevenroomsSlot {
      time: string;
      /** "YYYY-MM-DD HH:mm:ss", the venue's own local wall clock. */
      timeIso: string;
      type: string;
      /** Minutes. */
      duration: number | null;
      description: string | null;
      requireCreditCard: boolean;
      ccPaymentRule: string | null;
      cost: number | null;
      minSpend: number | null;
      cancellationPolicy: string | null;
      accessPersistentId: string | null;
      shiftPersistentId: string | null;
    }
    
    interface SevenroomsShift {
      name: string;
      category: string | null;
      isClosed: boolean;
      times: SevenroomsSlot[];
    }
    
    interface SevenroomsAvailabilityDay {
      date: string;
      shifts: SevenroomsShift[];
    }

    HTTP endpoint

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

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.sevenrooms.getAvailability({ venue: "<venue>", date: "<date>" });
  • getAvailableDatesLists the dates a venue is taking online bookings over a window, so a caller can pick a date before asking for times.

    Arguments

    NameTypeRequired
    venuestringYes
    startDatestring
    YYYY-MM-DD, default today.
    No
    numDaysnumber
    Default 30, at most 90.
    No

    Returns string[]

    HTTP endpoint

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

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.sevenrooms.getAvailableDates({ venue: "catchla" });
  • getBookingTermsReads the checkout terms of one open slot before booking it.

    Arguments

    NameTypeRequired
    venuestringYes
    datestring
    YYYY-MM-DD, the slot's own date.
    Yes
    timestring
    "HH:mm" 24h, the slot's own timeIso time portion.
    No
    accessPersistentIdstring
    From a getAvailability slot, round-tripped verbatim.
    No
    shiftPersistentIdstringNo
    partySizenumber
    Default 2.
    No

    Returns SevenroomsBookingTerms

    interface SevenroomsBookingTerms {
      slot: {
        time: string;
        /** "YYYY-MM-DD HH:mm:ss", the venue's own local wall clock. */
        timeIso: string;
        accessPersistentId: string | null;
        shiftPersistentId: string | null;
        partySize: number | null;
        /** Minutes. */
        duration: number | null;
      };
      policy: {
        bookingText: string | null;
        cancellationText: string | null;
      };
      payment: {
        requireCreditCard: boolean;
        ccPaymentRule: string | null;
        /** A card is required once the party reaches this size, independent of requireCreditCard. */
        ccPartySizeMin: number | null;
        chargeType: string | null;
        cost: number | null;
        applyServiceCharge: boolean;
        serviceCharge: number | null;
        serviceChargeType: string | null;
        defaultServiceCharge: number | null;
        applyGratuityCharge: boolean;
        requireGratuityCharge: boolean;
        gratuityType: string | null;
        gratuity: number | null;
        defaultGratuity: number | null;
        taxRate: number | null;
        /** Cents charged for a late cancellation or no-show. */
        computedAutoCancellationChargeCents: number | null;
      };
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/sevenrooms/getBookingTerms

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.sevenrooms.getBookingTerms({ venue: "<venue>", date: "<date>" });
  • getReservationReads a reservation from its manage token (bookReservation's manageToken, or the guest's manage link): venue, date, time, party size, guest name and…

    Arguments

    NameTypeRequired
    tokenstring
    The manage token, manageToken from bookReservation, or the guest's manage link.
    Yes

    Returns SevenroomsReservation

    interface SevenroomsReservation {
      token: string;
      reservationId: string | null;
      venueName: string | null;
      /** YYYY-MM-DD as the site sent it. */
      date: string | null;
      /** Venue-local time as the site sent it. */
      time: string | null;
      partySize: number | null;
      firstName: string | null;
      lastName: string | null;
      /** The site's own status label, verbatim. */
      status: string | null;  // the site's own labels, read the values off a result, never guess one from prose
      /** The site's whole answer, untouched. */
      raw: unknown;
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/sevenrooms/getReservation

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.sevenrooms.getReservation({ token: "<token>" });
  • getVenueReturns one venue from its slug: name, address, postal code, phone, website, timezone, currency, the house policy and dress code, the payment…

    Arguments

    NameTypeRequired
    venuestring
    A sevenrooms.com venue slug (e.g. "catchla") or any sevenrooms.com venue url.
    Yes

    Returns SevenroomsVenue

    interface SevenroomsVenue {
      id: string;
      venueGroupId: string | null;
      urlKey: string;
      name: string;
      venueClass: string | null;
      timezone: string | null;
      currencyCode: string | null;
      address: string | null;
      crossStreet: string | null;
      city: string | null;
      state: string | null;
      postalCode: string | null;
      country: string | null;
      phoneNumber: string | null;
      email: string | null;
      website: string | null;
      menuLink: string | null;
      latitude: number | null;
      longitude: number | null;
      policy: string | null;
      /** When true, only a signed-in SevenRooms account may book here. */
      requiresAccountToBook: boolean;
      bookingUrl: string;
      // The handoff: give the person checkout.url (they pick date, time and party there)
      // and stop. They reserve themselves; Bowmark never books.
      checkout: { status: string; url: string; urlKind: string; account: { site: string; hint: string }; summary: { items: { title: string; variant: string | null; quantity: number; unitPrice: string | null; lineTotal: string | null }[]; total: string | null; currency: string; dates?: { start: string; end?: string }; guests?: number }; warnings: string[] } | null;
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/sevenrooms/getVenue

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.sevenrooms.getVenue({ venue: "catchla" });
  • listMyReservationsLists the signed-in guest's SevenRooms reservations across every venue, split into upcoming and past: venue, city, date and time, party size, status…

    Arguments

    None.

    Returns SevenroomsMyReservations

    interface SevenroomsMyReservation {
      id: string | null;
      venueId: string | null;
      venueName: string | null;
      city: string | null;
      /** Venue-local date, YYYY-MM-DD. */
      date: string | null;
      /** Venue-local time as SevenRooms wrote it. */
      time: string | null;
      /** ISO instant the reservation starts. */
      datetimeUtc: string | null;
      partySize: number | null;
      /** SevenRooms' own status, verbatim, when it sends one. */
      status: string | null;  // the site's own labels, read the values off a result, never guess one from prose
      cancelled: boolean;
      /** Starts after now. */
      upcoming: boolean;
      imageUrl: string | null;
      /** Where the guest views or cancels it. */
      manageUrl: string | null;
      modifyUrl: string | null;
      bookAgainUrl: string | null;
      venueBookable: boolean | null;
    }
    
    interface SevenroomsMyReservations {
      /** Newest first, furthest-out upcoming first, oldest past last. Empty when there are none. */
      reservations: SevenroomsMyReservation[];
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/sevenrooms/listMyReservations

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.sevenrooms.listMyReservations();
  • listUpgradesLists a venue's bookable add-ons.

    Arguments

    NameTypeRequired
    venuestring
    A sevenrooms.com venue slug (e.g. "catchla") or any sevenrooms.com venue url.
    Yes

    Returns SevenroomsUpgrades

    interface SevenroomsUpgradeCategory {
      id: string;
      name: string | null;
      minQuantityType: string | null;
      minQuantity: number | null;
      maxQuantityType: string | null;
      maxQuantity: number | null;
    }
    
    interface SevenroomsUpgradeItem {
      id: string;
      categoryId: string | null;
      name: string | null;
      /** The site's own rich-text HTML. */
      description: string | null;
      /** Not meaningful when isPriceHidden is true. */
      price: number | null;
      isPriceHidden: boolean;
    }
    
    interface SevenroomsUpgrades {
      categories: SevenroomsUpgradeCategory[];
      items: SevenroomsUpgradeItem[];
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/sevenrooms/listUpgrades

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.sevenrooms.listUpgrades({ venue: "marea" });
  • validatePromoCodeChecks whether a promo code is valid at a venue for a date, time and party size before booking: the discount it would apply (VALID), or the site's…

    Arguments

    NameTypeRequired
    venuestringYes
    promoCodestringYes
    datestring
    YYYY-MM-DD, the slot's own date.
    Yes
    timestring
    "HH:mm" 24h, the slot's own timeIso time portion.
    Yes
    partySizenumber
    Default 2.
    No

    Returns SevenroomsPromoValidation

    interface SevenroomsPromoCode {
      id: string;
      name: string;
      /** "DOLLAR_DISCOUNT" or "PERCENTAGE_DISCOUNT", as the site sends it. */
      promoType: string | null;
      /** In the venue's currency when DOLLAR_DISCOUNT; a bare percentage otherwise. */
      promoValue: number | null;
      minSubtotal: number | null;
      promoValueCap: number | null;
      status: "UPCOMING" | "ACTIVE" | "INACTIVE";
    }
    
    type SevenroomsPromoValidation =
      | { status: "VALID"; promoCode: SevenroomsPromoCode }
      | { status: "INVALID"; reason: string };

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/sevenrooms/validatePromoCode

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.sevenrooms.validatePromoCode({
      venue: "<venue>",
      promoCode: "<promoCode>",
      date: "<date>",
      time: "<time>"
    });
Act 2
  • bookReservationBooks an open slot (from getAvailability) as a guest with the caller's name, email and phone.

    Arguments

    NameTypeRequired
    venuestringYes
    datestring
    "YYYY-MM-DD", the slot's own date.
    Yes
    timestring
    "HH:mm" 24h, the slot's own timeIso time portion.
    Yes
    accessPersistentIdstring
    Round-trip both straight from a getAvailability slot.
    Yes
    shiftPersistentIdstringYes
    partySizenumberNo
    firstNamestringYes
    lastNamestringYes
    emailstringYes
    phonestring
    Digits, national format.
    Yes
    phoneDialCodestring
    Default "1".
    No
    phoneCountryCodestring
    ISO alpha-2, default "us".
    No
    notesstring
    A note to the venue.
    No

    Returns SevenroomsBooking

    interface SevenroomsBooking {
      /** False when the slot needs a card or payment, nothing was booked; read paymentTerms. */
      booked: boolean;
      stoppedAt: "payment" | null;
      reservationId: string | null;
      apiReservationId: string | null;
      /** Pass to cancelReservation / getReservation. */
      manageToken: string | null;
      manageUrl: string | null;
      paymentTerms: { requireCreditCard: boolean; ccPartySizeMin: number | null; cost: number | null; computedAutoCancellationChargeCents: number | null } | null;
      raw: unknown;
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/sevenrooms/bookReservation

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.sevenrooms.bookReservation({
      venue: "<venue>",
      date: "<date>",
      time: "<time>",
      accessPersistentId: "<accessPersistentId>",
      shiftPersistentId: "<shiftPersistentId>",
      firstName: "<firstName>",
      lastName: "<lastName>",
      email: "<email>",
      phone: "<phone>"
    });
  • cancelReservationCancels a reservation from its manage token (bookReservation's manageToken, or the guest's manage link) and returns cancelled: true with the site's…

    Arguments

    NameTypeRequired
    tokenstring
    The manage token, manageToken from bookReservation, or the guest's manage link.
    Yes

    Returns SevenroomsCancellation

    interface SevenroomsCancellation {
      cancelled: true;
      token: string;
      /** The site's own success body, untouched. */
      raw: unknown;
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/sevenrooms/cancelReservation

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.sevenrooms.cancelReservation({ token: "<token>" });

Use it from code