ChowNow MCP server for AI agents

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

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

Connect

Just ChowNow

An MCP server for ChowNow 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/chownow
Every site

One MCP server for ChowNow 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 15
  • findRestaurantResolves a ChowNow ordering URL (www/order/direct/eat subdomain, or the bare apex) into its companyId and restaurantId.

    Arguments

    NameTypeRequired
    urlstringYes

    Returns ChownowRestaurantRef

    interface ChownowRestaurantRef {
      companyId: string;
      restaurantId: string | null;
      url: string;
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/chownow/findRestaurant

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.chownow.findRestaurant("<url>");
  • getMenuReads one restaurant's complete menu: categories with items, descriptions, prices, size pickers, and modifier groups with their min/max picks and…

    Arguments

    NameTypeRequired
    restaurantIdstringYes
    atstringNo

    Returns ChownowMenu

    interface ChownowModifier {
      id: string;
      name: string;
      price: number | null;
      isDefault: boolean;
    }
    
    interface ChownowModifierGroup {
      id: string;
      name: string;
      minQty: number | null;
      maxQty: number | null;
      modifiers: ChownowModifier[];
    }
    
    interface ChownowMenuItem {
      id: string;
      name: string;
      description: string;
      price: number | null; // null on a size picker, each size carries its own price
      size: string | null;
      isSizePicker: boolean;
      sizeItemIds: string[]; // the priced items that are this picker's sizes
      modifierGroupIds: string[]; // ids into ChownowMenu.modifierGroups
      imageUrl: string | null;
    }
    
    interface ChownowMenuCategory {
      id: string;
      name: string;
      items: ChownowMenuItem[];
    }
    
    interface ChownowMenu {
      menuId: string; // "<menuId>_<YYYYMMDDHHmm>", what ChowNow's order validation is keyed on
      categories: ChownowMenuCategory[];
      modifierGroups: ChownowModifierGroup[];
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/chownow/getMenu

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.chownow.getMenu("35");
  • getMenuItemReads details for one menu item: name, description, price, and its modifier groups resolved to full detail (name, min/max picks, each option's price)…

    Arguments

    NameTypeRequired
    restaurantIdstringYes
    itemIdstringYes
    atstringNo

    Returns ChownowMenuItemDetail

    interface ChownowModifier {
      id: string;
      name: string;
      price: number | null;
      isDefault: boolean;
    }
    
    interface ChownowModifierGroup {
      id: string;
      name: string;
      minQty: number | null;
      maxQty: number | null;
      modifiers: ChownowModifier[];
    }
    
    interface ChownowMenuItem {
      id: string;
      name: string;
      description: string;
      price: number | null; // null on a size picker, each size carries its own price
      size: string | null;
      isSizePicker: boolean;
      sizeItemIds: string[]; // the priced items that are this picker's sizes
      modifierGroupIds: string[]; // ids into ChownowMenu.modifierGroups
      imageUrl: string | null;
    }
    
    interface ChownowMenuCategory {
      id: string;
      name: string;
      items: ChownowMenuItem[];
    }
    
    interface ChownowMenu {
      menuId: string; // "<menuId>_<YYYYMMDDHHmm>", what ChowNow's order validation is keyed on
      categories: ChownowMenuCategory[];
      modifierGroups: ChownowModifierGroup[];
    }
    
    interface ChownowMenuItemDetail extends ChownowMenuItem {
      categoryId: string;
      categoryName: string;
      modifierGroups: ChownowModifierGroup[]; // resolved from ChownowMenuItem.modifierGroupIds
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/chownow/getMenuItem

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.chownow.getMenuItem("35", "3111147_3723854");
  • getOrderDetailsReads one order's full details: items ordered, customizations, prices, fees, status updates, restaurant name and address, fulfillment time window.

    Arguments

    NameTypeRequired
    orderIdstringYes

    Returns ChownowOrderDetails

    interface ChownowOrderLineItem {
      name: string;
      quantity: number | null;
      price: number | null;
    }
    
    interface ChownowOrderDetails {
      orderId: string;
      restaurantId: string | null;
      restaurantName: string | null;
      status: string | null;  // the site's own labels, read the values off a result, never guess one from prose
      total: number | null;
      orderedAt: string | null;
      fulfillMethod: string | null;
      items: ChownowOrderLineItem[];
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/chownow/getOrderDetails

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.chownow.getOrderDetails("1");
  • getPickupTimesLists the order-ahead time slots a restaurant offers over its coming days, per fulfillment method (pickup, delivery, curbside), as 15-minute slot…

    Arguments

    NameTypeRequired
    restaurantIdstringYes

    Returns ChownowPickupTimes

    interface ChownowSlotDay {
      date: string; // YYYY-MM-DD, restaurant-local
      dow: string;
      pickup: string[]; // slot start times, "HH:MM" restaurant-local, 15 minutes apart
      delivery: string[];
      curbside: string[];
    }
    
    interface ChownowPickupTimes {
      restaurantId: string;
      isPickupAheadAvailable: boolean;
      isDeliveryAheadAvailable: boolean;
      isCurbsideAheadAvailable: boolean;
      days: ChownowSlotDay[];
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/chownow/getPickupTimes

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.chownow.getPickupTimes("35");
  • getRestaurantReads one restaurant location's own details: name, phone, address, whether it is currently live and whether it is flagged busy (orders running…

    Arguments

    NameTypeRequired
    restaurantIdstringYes

    Returns ChownowRestaurantDetails

    interface ChownowFulfillmentMethod {
      isAvailableNow: boolean;
      nextAvailableTime: string | null; // "YYYYMMDDHHmm", ChowNow's own timestamp format
      minLeadTimeMinutes: number | null;
    }
    
    interface ChownowRestaurantDetails {
      restaurantId: string;
      companyId: string;
      name: string;
      phone: string;
      address: {
        street: string;
        city: string;
        state: string;
        zip: string;
        latitude: number | null;
        longitude: number | null;
      };
      isLive: boolean;
      isBusy: boolean;
      pickup: ChownowFulfillmentMethod | null;
      delivery: ChownowFulfillmentMethod | null;
      taxRate: number | null;
      websiteUrl: string | null;
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/chownow/getRestaurant

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.chownow.getRestaurant("35");
  • getRestaurantHoursReads a restaurant's operating hours and closures.

    Arguments

    NameTypeRequired
    restaurantIdstringYes

    Returns ChownowRestaurantHours

    interface ChownowHourRange {
      from: string;
      to: string;
      label: string | null;
    }
    
    interface ChownowHourDay {
      date: string; // YYYY-MM-DD, restaurant-local
      dow: string;
      ranges: ChownowHourRange[];
    }
    
    interface ChownowRestaurantHours {
      restaurantId: string;
      pickup: ChownowHourDay[] | null;
      delivery: ChownowHourDay[] | null;
      curbside: ChownowHourDay[] | null;
      closures: unknown[]; // shape unmeasured, every restaurant captured so far returned []
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/chownow/getRestaurantHours

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.chownow.getRestaurantHours("35");
  • getRewardsBalanceReads the signed-in customer's loyalty rewards points balance and any active promotions or credit.

    Arguments

    None.

    Returns ChownowRewardsBalance

    interface ChownowRewardsPromotion {
      name: string;
      description: string | null;
    }
    
    interface ChownowRewardsBalance {
      pointsBalance: number | null;
      creditBalance: number | null;
      promotions: ChownowRewardsPromotion[];
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/chownow/getRewardsBalance

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.chownow.getRewardsBalance();
  • listMenuCategoriesLists the menu categories for a restaurant without fetching the full menu.

    Arguments

    NameTypeRequired
    restaurantIdstringYes
    atstringNo

    Returns ChownowMenuCategorySummary[]

    interface ChownowMenuCategorySummary {
      id: string;
      name: string;
      itemCount: number;
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/chownow/listMenuCategories

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.chownow.listMenuCategories("35");
  • listMenuItemsLists all menu items for a restaurant in a flattened view, independent of category hierarchy, each carrying its own categoryId/categoryName.

    Arguments

    NameTypeRequired
    restaurantIdstringYes
    atstringNo

    Returns ChownowFlatMenuItem[]

    interface ChownowModifier {
      id: string;
      name: string;
      price: number | null;
      isDefault: boolean;
    }
    
    interface ChownowModifierGroup {
      id: string;
      name: string;
      minQty: number | null;
      maxQty: number | null;
      modifiers: ChownowModifier[];
    }
    
    interface ChownowMenuItem {
      id: string;
      name: string;
      description: string;
      price: number | null; // null on a size picker, each size carries its own price
      size: string | null;
      isSizePicker: boolean;
      sizeItemIds: string[]; // the priced items that are this picker's sizes
      modifierGroupIds: string[]; // ids into ChownowMenu.modifierGroups
      imageUrl: string | null;
    }
    
    interface ChownowMenuCategory {
      id: string;
      name: string;
      items: ChownowMenuItem[];
    }
    
    interface ChownowMenu {
      menuId: string; // "<menuId>_<YYYYMMDDHHmm>", what ChowNow's order validation is keyed on
      categories: ChownowMenuCategory[];
      modifierGroups: ChownowModifierGroup[];
    }
    
    interface ChownowFlatMenuItem extends ChownowMenuItem {
      categoryId: string;
      categoryName: string;
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/chownow/listMenuItems

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.chownow.listMenuItems("35");
  • listOrdersLists the signed-in customer's order history with status, total price, order date, and restaurant name.

    Arguments

    None.

    Returns ChownowOrders

    interface ChownowOrderSummary {
      orderId: string;
      restaurantId: string | null;
      restaurantName: string | null;
      status: string | null; // ChowNow's own order status string, verbatim, the site's own labels, read the values off a result, never guess one from prose
      total: number | null;
      orderedAt: string | null;
    }
    
    interface ChownowOrders {
      orders: ChownowOrderSummary[];
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/chownow/listOrders

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.chownow.listOrders();
  • listRestaurantsLists all restaurants under a company (e.g. a franchise group), with location id, name, address, coordinates, phone, operating status, and…

    Arguments

    NameTypeRequired
    companyIdstringYes

    Returns ChownowBrand

    interface ChownowLocation {
      companyId: string;
      restaurantId: string;
      name: string;
      address: {
        street: string;
        city: string;
        state: string;
        zip: string;
        latitude: number | null;
        longitude: number | null;
      };
      allowsOrderForNow: boolean;
      isLive: boolean;
    }
    
    interface ChownowBrand {
      companyId: string;
      name: string;
      locations: ChownowLocation[];
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/chownow/listRestaurants

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.chownow.listRestaurants("32");
  • listSavedPaymentMethodsLists the signed-in customer's saved cards and payment methods.

    Arguments

    None.

    Returns ChownowSavedPaymentMethods

    interface ChownowSavedPaymentMethod {
      paymentMethodId: string;
      brand: string | null; // e.g. "Visa", the site's own label, verbatim
      last4: string | null;
      expiryMonth: number | null;
      expiryYear: number | null;
      isDefault: boolean | null;
    }
    
    interface ChownowSavedPaymentMethods {
      paymentMethods: ChownowSavedPaymentMethod[];
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/chownow/listSavedPaymentMethods

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.chownow.listSavedPaymentMethods();
  • searchRestaurantsSearches ChowNow restaurants by free text (a cuisine, a dish or a restaurant name) within one city.

    Arguments

    NameTypeRequired
    querystringYes
    citySlugstringYes

    Returns ChownowSearch

    interface ChownowSearchResult {
      restaurantId: string;
      companyId: string;
      name: string;
      shortName: string;
      cuisines: string[];
      phone: string;
      address: {
        street: string;
        city: string;
        state: string;
        zip: string;
        latitude: number | null;
        longitude: number | null;
      };
      isPickupAvailable: boolean;
      isDeliveryAvailable: boolean;
    }
    
    interface ChownowSearch {
      restaurants: ChownowSearchResult[];
      total: number;
      cuisineCounts: Record<string, number>;
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/chownow/searchRestaurants

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.chownow.searchRestaurants("pizza", "los-angeles-ca");
  • validateOrderValidates an order before payment: checks fulfillment method availability, item availability, calculates fees (delivery, service, small-order…

    Arguments

    NameTypeRequired
    restaurantIdstringYes
    menuIdstringYes
    itemsChownowOrderItemInput[]Yes
    options{ fulfillMethod?: "pickup" | "delivery" | "curbside"; when?: string | null; specialInstructions?: string | null; promoCode?: string | null }No
    interface ChownowOrderItemInput {
      itemId: string; // from getMenu/listMenuItems/getMenuItem
      quantity?: number; // default 1
      specialInstructions?: string | null;
      modifierCategories?: unknown[]; // passed through verbatim, shape unmeasured for an item with modifier groups
    }

    Returns ChownowOrderValidation

    interface ChownowValidatedItem {
      itemId: string;
      name: string | null;
      quantity: number | null;
      price: number | null; // the menu's own per-item price
      itemTotal: number | null; // this line's priced total
      taxAmount: number | null;
    }
    
    interface ChownowOrderValidationIssue {
      code: string | null;
      message: string | null; // ChowNow's own wording, e.g. a minimum-order rule
    }
    
    interface ChownowOrderValidation {
      restaurantId: string;
      fulfillMethod: string | null;
      items: ChownowValidatedItem[];
      itemTotal: number | null;
      subtotal: number | null;
      salesTax: number | null;
      serviceFee: number | null;
      deliveryFee: number | null;
      supportLocalFee: number | null; // ChowNow's own "Support Local Fee"
      gratuity: number | null;
      total: number | null;
      totalDue: number | null;
      isValid: boolean; // false when errors is non-empty, check before trusting total
      errors: ChownowOrderValidationIssue[];
      warnings: string[];
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/chownow/validateOrder

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.chownow.validateOrder("<restaurantId>", "<menuId>", []);

Use it from code