Olo MCP server for AI agents

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

Functions
18
Sign-in
Not needed
Works with
MCP, HTTP, Node, Python

Connect

Just Olo

An MCP server for Olo 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/olo
Every site

One MCP server for Olo 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

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

Read 11
  • checkOrderAvailabilityChecks whether a location can take an order right now or at a chosen time for a handoff mode (and, for delivery, whether it covers an address), and…

    Arguments

    NameTypeRequired
    hoststringYes
    vendorIdnumberYes
    handoffModestringNo
    timeWantedType"Immediate" | "Advance"No
    timeWantedstringNo
    addressstringNo

    Returns OloOrderAvailability

    interface OloOrderAvailability {
      isValid: boolean;
      failureCategory: string;
      errorMessage: string | null;
      nextOpenTime: string | null;
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/olo/checkOrderAvailability

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.olo.checkOrderAvailability({ host: "order.fazolis.com", vendorId: 81322 });
  • findBrandFinds the Olo order site for a restaurant chain from what a caller holds -- an order-site link, the chain's own website, or its name -- and returns…

    Arguments

    NameTypeRequired
    chainstringYes

    Returns OloBrand

    interface OloBrand {
      host: string;
      channelSlug: string;
      name: string;
      handoffModes: string[];
      advanceOrderDays: number;
      guestOrdering: boolean;
      groupOrdering: boolean;
      curbside: boolean;
      hasOloAuthProvider: boolean;
      loginProviderName: string | null;
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/olo/findBrand

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.olo.findBrand({ chain: "order.fazolis.com" });
  • getBasketReturns a guest basket's current items, subtotal, tax and total.

    Arguments

    NameTypeRequired
    hoststringYes
    guidstringYes

    Returns OloBasket

    interface OloBasketProduct {
      id: string;
      productId: number;
      name: string;
      quantity: number;
      unitCost: number;
      totalCost: number;
    }
    
    interface OloBasket {
      guid: string;
      vendorId: number;
      handoffMode: string;  // "Unspecified" until the handoff mode and time are set -- not yet built
      items: OloBasketProduct[];
      subTotal: number;
      salesTax: number;
      total: number;
      unavailableItems: string[];
      couponDiscount: number;  // 0 when no coupon is applied
      checkout: OloCheckoutHandoff;  // a refusal listing the items to re-add on the order site (no link restores an Olo basket); Bowmark never pays
    }
    
    // The checkout handoff: where the PERSON finishes. Bowmark never pays, books or orders.
    // Switch on `status`; a status you do not recognise means "show the person `url` and stop".
    interface OloCheckoutHandoff {
      status: "ready_to_checkout" | "needs_login" | "unavailable";
      url: string;                       // the https page to open on the site
      urlKind?: "carries_items" | "signed_in_cart" | "product_page"; // ready_to_checkout only: does the link carry the items, or only open the item's page
      reason?: string;                   // unavailable only: out_of_stock | not_available_for_dates | not_sold_online | region_not_served | quantity_unavailable | empty_cart
      detail?: string;                   // unavailable only: one sentence saying why
      account: { site: string; hint: string; signedInAs?: string };
      summary: { items: { title: string; variant: string | null; quantity: number; unitPrice: string | null; lineTotal: string | null; url?: string; id?: string }[]; total: string | null; currency: string } | null;
      warnings: string[];
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/olo/getBasket

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.olo.getBasket({ host: "<host>", guid: "<guid>" });
  • getLocationReturns one location's details: address, coordinates, phone, open-now status, whether it accepts advance orders, its tax rate and the handoff modes…

    Arguments

    NameTypeRequired
    hoststringYes
    slugstringYes
    handoffModestringNo

    Returns OloLocationDetail

    interface OloLocationDetail {
      id: number;
      name: string;
      phoneNumber: string;
      streetAddress: string;
      city: string;
      state: string;
      zipCode: string;
      latitude: number;
      longitude: number;
      isOpen: boolean;
      isAcceptingOrders: boolean;
      allowAdvanceOrders: boolean;
      taxRate: number;
      supportedHandoffModes: string[];
      attributes: string[];
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/olo/getLocation

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.olo.getLocation({ host: "order.fazolis.com", slug: "abilene-tx" });
  • getMenuReturns a location's menu: categories in order, and each product's id, name, description, price (resolved from its option groups when the chain…

    Arguments

    NameTypeRequired
    hoststringYes
    slugstringYes
    handoffModestringNo

    Returns OloMenu

    interface OloMenuProduct {
      id: number;
      name: string;
      description: string;
      price: number | null;
      pricedByOptions: boolean;
      optionGroupIds: number[];
    }
    
    interface OloMenuCategory {
      id: number;
      name: string;
      products: OloMenuProduct[];
    }
    
    interface OloMenu {
      categories: OloMenuCategory[];
    }

    HTTP endpoint

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

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.olo.getMenu({ host: "order.fazolis.com", slug: "abilene-tx" });
  • getOrderStatusReturns a placed order's status from its order id (the confirmation page link): status, items, total and pickup time.

    Arguments

    NameTypeRequired
    hoststringYes
    orderIdstringYes

    Returns OloOrderStatus

    interface OloOrderStatus {
      id: string;
      status: string;  // the site's own labels, read the values off a result, never guess one from prose
      items: Array<{ name: string; quantity: number }>;
      total: number | null;
      pickupTime: string | null;
      locationName: string | null;
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/olo/getOrderStatus

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.olo.getOrderStatus({
      host: "order.fazolis.com",
      orderId: "00000000-0000-0000-0000-000000000000"
    });
  • getProductOptionsReturns the customisation tree for a product's option groups -- whether each is mandatory and each choice's id, name and price difference, with any…

    Arguments

    NameTypeRequired
    hoststringYes
    vendorIdnumberYes
    optionGroupIdsnumber[]Yes
    handoffModestringNo

    Returns OloOptionGroup[]

    interface OloOptionChoice {
      id: number;
      name: string;
      priceDifference: number;
      nestedOptionGroupIds: number[];
    }
    
    interface OloOptionGroup {
      id: number;
      name: string;
      isMandatory: boolean;
      choices: OloOptionChoice[];
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/olo/getProductOptions

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.olo.getProductOptions({
      host: "order.fazolis.com",
      vendorId: 81322,
      optionGroupIds: [3834875756]
    });
  • listOrderDaysLists the days a location will take an order for, for a handoff mode (today through the chain's advance-order window).

    Arguments

    NameTypeRequired
    hoststringYes
    vendorIdnumberYes
    handoffModestringNo

    Returns string[]

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/olo/listOrderDays

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.olo.listOrderDays({ host: "order.fazolis.com", vendorId: 81322 });
  • listRegionsLists the states where a chain has Olo-ordering locations.

    Arguments

    NameTypeRequired
    hoststringYes

    Returns OloRegion[]

    interface OloRegion {
      name: string;
      code: string;
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/olo/listRegions

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.olo.listRegions("order.fazolis.com");
  • listTimeSlotsLists the pickup or delivery time slots a location offers on one day, for a handoff mode, as UTC instants.

    Arguments

    NameTypeRequired
    hoststringYes
    vendorIdnumberYes
    datestringYes
    handoffModestringNo

    Returns OloTimeSlot[]

    interface OloTimeSlot {
      utc: string;
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/olo/listTimeSlots

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.olo.listTimeSlots({ host: "<host>", vendorId: 1, date: "<date>" });
  • searchLocationsSearches a chain's locations near an address, a lat/lng, or in a state, optionally for a handoff mode, returning each location's id, slug, name…

    Arguments

    NameTypeRequired
    hoststringYes
    addressstringNo
    latitudenumberNo
    longitudenumberNo
    regionCodestringNo
    handoffModestringNo

    Returns OloLocationSummary[]

    interface OloLocationSummary {
      id: number;
      slug: string;
      name: string;
      phoneNumber: string;
      streetAddress: string;
      city: string;
      state: string;
      distanceMiles?: number;
      isAcceptingOrders: boolean;
      todaysHours: string;
      supportedHandoffModes?: string[];
    }

    HTTP endpoint

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

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.olo.searchLocations({ host: "order.fazolis.com", regionCode: "TX" });
Act 7
  • addToBasketAdds a product to a guest basket from startOrder, with a quantity and any option choices, and returns the updated basket with its running subtotal…

    Arguments

    NameTypeRequired
    hoststringYes
    guidstringYes
    vendorIdnumberYes
    vendorProductIdnumberYes
    quantitynumberYes
    choiceIdsnumber[]No
    specialInstructionsstringNo
    recipientNamestringNo

    Returns OloBasket

    interface OloBasketProduct {
      id: string;
      productId: number;
      name: string;
      quantity: number;
      unitCost: number;
      totalCost: number;
    }
    
    interface OloBasket {
      guid: string;
      vendorId: number;
      handoffMode: string;  // "Unspecified" until the handoff mode and time are set -- not yet built
      items: OloBasketProduct[];
      subTotal: number;
      salesTax: number;
      total: number;
      unavailableItems: string[];
      couponDiscount: number;  // 0 when no coupon is applied
      checkout: OloCheckoutHandoff;  // a refusal listing the items to re-add on the order site (no link restores an Olo basket); Bowmark never pays
    }
    
    // The checkout handoff: where the PERSON finishes. Bowmark never pays, books or orders.
    // Switch on `status`; a status you do not recognise means "show the person `url` and stop".
    interface OloCheckoutHandoff {
      status: "ready_to_checkout" | "needs_login" | "unavailable";
      url: string;                       // the https page to open on the site
      urlKind?: "carries_items" | "signed_in_cart" | "product_page"; // ready_to_checkout only: does the link carry the items, or only open the item's page
      reason?: string;                   // unavailable only: out_of_stock | not_available_for_dates | not_sold_online | region_not_served | quantity_unavailable | empty_cart
      detail?: string;                   // unavailable only: one sentence saying why
      account: { site: string; hint: string; signedInAs?: string };
      summary: { items: { title: string; variant: string | null; quantity: number; unitPrice: string | null; lineTotal: string | null; url?: string; id?: string }[]; total: string | null; currency: string } | null;
      warnings: string[];
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/olo/addToBasket

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.olo.addToBasket({
      host: "<host>",
      guid: "<guid>",
      vendorId: 1,
      vendorProductId: 1,
      quantity: 1
    });
  • applyCouponApplies a coupon or promo code to the basket and reports the discount, or removes one.

    Arguments

    NameTypeRequired
    hoststringYes
    guidstringYes
    codestring | null
    Omitted or null removes whatever coupon is applied.
    No

    Returns OloBasket

    interface OloBasketProduct {
      id: string;
      productId: number;
      name: string;
      quantity: number;
      unitCost: number;
      totalCost: number;
    }
    
    interface OloBasket {
      guid: string;
      vendorId: number;
      handoffMode: string;  // "Unspecified" until the handoff mode and time are set -- not yet built
      items: OloBasketProduct[];
      subTotal: number;
      salesTax: number;
      total: number;
      unavailableItems: string[];
      couponDiscount: number;  // 0 when no coupon is applied
      checkout: OloCheckoutHandoff;  // a refusal listing the items to re-add on the order site (no link restores an Olo basket); Bowmark never pays
    }
    
    // The checkout handoff: where the PERSON finishes. Bowmark never pays, books or orders.
    // Switch on `status`; a status you do not recognise means "show the person `url` and stop".
    interface OloCheckoutHandoff {
      status: "ready_to_checkout" | "needs_login" | "unavailable";
      url: string;                       // the https page to open on the site
      urlKind?: "carries_items" | "signed_in_cart" | "product_page"; // ready_to_checkout only: does the link carry the items, or only open the item's page
      reason?: string;                   // unavailable only: out_of_stock | not_available_for_dates | not_sold_online | region_not_served | quantity_unavailable | empty_cart
      detail?: string;                   // unavailable only: one sentence saying why
      account: { site: string; hint: string; signedInAs?: string };
      summary: { items: { title: string; variant: string | null; quantity: number; unitPrice: string | null; lineTotal: string | null; url?: string; id?: string }[]; total: string | null; currency: string } | null;
      warnings: string[];
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/olo/applyCoupon

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.olo.applyCoupon({ host: "<host>", guid: "<guid>" });
  • removeBasketItemRemoves an item from a guest basket, by the item's id off getBasket, and returns the basket that is left.

    Arguments

    NameTypeRequired
    hoststringYes
    guidstringYes
    basketProductIdstring
    An item's id off getBasket / addToBasket.
    Yes

    Returns OloBasket

    interface OloBasketProduct {
      id: string;
      productId: number;
      name: string;
      quantity: number;
      unitCost: number;
      totalCost: number;
    }
    
    interface OloBasket {
      guid: string;
      vendorId: number;
      handoffMode: string;  // "Unspecified" until the handoff mode and time are set -- not yet built
      items: OloBasketProduct[];
      subTotal: number;
      salesTax: number;
      total: number;
      unavailableItems: string[];
      couponDiscount: number;  // 0 when no coupon is applied
      checkout: OloCheckoutHandoff;  // a refusal listing the items to re-add on the order site (no link restores an Olo basket); Bowmark never pays
    }
    
    // The checkout handoff: where the PERSON finishes. Bowmark never pays, books or orders.
    // Switch on `status`; a status you do not recognise means "show the person `url` and stop".
    interface OloCheckoutHandoff {
      status: "ready_to_checkout" | "needs_login" | "unavailable";
      url: string;                       // the https page to open on the site
      urlKind?: "carries_items" | "signed_in_cart" | "product_page"; // ready_to_checkout only: does the link carry the items, or only open the item's page
      reason?: string;                   // unavailable only: out_of_stock | not_available_for_dates | not_sold_online | region_not_served | quantity_unavailable | empty_cart
      detail?: string;                   // unavailable only: one sentence saying why
      account: { site: string; hint: string; signedInAs?: string };
      summary: { items: { title: string; variant: string | null; quantity: number; unitPrice: string | null; lineTotal: string | null; url?: string; id?: string }[]; total: string | null; currency: string } | null;
      warnings: string[];
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/olo/removeBasketItem

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.olo.removeBasketItem({
      host: "<host>",
      guid: "<guid>",
      basketProductId: "<basketProductId>"
    });
  • setHandoffSets how and when a guest basket is picked up (carryout, drive-thru, curbside, delivery; ASAP or a time slot) and runs the site's own checkout…

    Arguments

    NameTypeRequired
    hoststringYes
    guidstring
    From startOrder.
    Yes
    vendorIdnumber
    The same vendorId startOrder took.
    Yes
    handoffModestring
    "CounterPickup" (default), "DriveThru", "CurbsidePickup", "Dispatch".
    No
    timeWantedType"Immediate" | "Advance"
    Default "Immediate" (ASAP).
    No
    timeWantedstring
    A UTC instant from listTimeSlots, when "Advance".
    No
    addressstring
    Delivery address, for "Dispatch".
    No

    Returns OloHandoffResult

    interface OloBasketProduct {
      id: string;
      productId: number;
      name: string;
      quantity: number;
      unitCost: number;
      totalCost: number;
    }
    
    interface OloBasket {
      guid: string;
      vendorId: number;
      handoffMode: string;  // "Unspecified" until the handoff mode and time are set -- not yet built
      items: OloBasketProduct[];
      subTotal: number;
      salesTax: number;
      total: number;
      unavailableItems: string[];
      couponDiscount: number;  // 0 when no coupon is applied
      checkout: OloCheckoutHandoff;  // a refusal listing the items to re-add on the order site (no link restores an Olo basket); Bowmark never pays
    }
    
    interface OloHandoffResult extends OloBasket {
      readyForCheckout: boolean;  // the site's own checkout validation passed
    }
    
    // The checkout handoff: where the PERSON finishes. Bowmark never pays, books or orders.
    // Switch on `status`; a status you do not recognise means "show the person `url` and stop".
    interface OloCheckoutHandoff {
      status: "ready_to_checkout" | "needs_login" | "unavailable";
      url: string;                       // the https page to open on the site
      urlKind?: "carries_items" | "signed_in_cart" | "product_page"; // ready_to_checkout only: does the link carry the items, or only open the item's page
      reason?: string;                   // unavailable only: out_of_stock | not_available_for_dates | not_sold_online | region_not_served | quantity_unavailable | empty_cart
      detail?: string;                   // unavailable only: one sentence saying why
      account: { site: string; hint: string; signedInAs?: string };
      summary: { items: { title: string; variant: string | null; quantity: number; unitPrice: string | null; lineTotal: string | null; url?: string; id?: string }[]; total: string | null; currency: string } | null;
      warnings: string[];
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/olo/setHandoff

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.olo.setHandoff({ host: "<host>", guid: "<guid>", vendorId: 1 });
  • startCheckoutTakes a guest basket (products added, setHandoff run) to the payment step: runs the site's checkout validation and returns the final total, handoff…

    Arguments

    NameTypeRequired
    hoststringYes
    guidstringYes

    Returns OloCheckout

    interface OloBasketProduct {
      id: string;
      productId: number;
      name: string;
      quantity: number;
      unitCost: number;
      totalCost: number;
    }
    
    interface OloBasket {
      guid: string;
      vendorId: number;
      handoffMode: string;  // "Unspecified" until the handoff mode and time are set -- not yet built
      items: OloBasketProduct[];
      subTotal: number;
      salesTax: number;
      total: number;
      unavailableItems: string[];
      couponDiscount: number;  // 0 when no coupon is applied
      checkout: OloCheckoutHandoff;  // a refusal listing the items to re-add on the order site (no link restores an Olo basket); Bowmark never pays
    }
    
    interface OloPaymentMethod {
      id: number;
      name: string;
      provider: string;
      isGiftCard: boolean;
    }
    
    interface OloCheckout extends OloBasket {
      readyForCheckout: boolean;
      paymentMethods: OloPaymentMethod[];
      canPayCash: boolean;
      checkoutUrl: string;
    }
    
    // The checkout handoff: where the PERSON finishes. Bowmark never pays, books or orders.
    // Switch on `status`; a status you do not recognise means "show the person `url` and stop".
    interface OloCheckoutHandoff {
      status: "ready_to_checkout" | "needs_login" | "unavailable";
      url: string;                       // the https page to open on the site
      urlKind?: "carries_items" | "signed_in_cart" | "product_page"; // ready_to_checkout only: does the link carry the items, or only open the item's page
      reason?: string;                   // unavailable only: out_of_stock | not_available_for_dates | not_sold_online | region_not_served | quantity_unavailable | empty_cart
      detail?: string;                   // unavailable only: one sentence saying why
      account: { site: string; hint: string; signedInAs?: string };
      summary: { items: { title: string; variant: string | null; quantity: number; unitPrice: string | null; lineTotal: string | null; url?: string; id?: string }[]; total: string | null; currency: string } | null;
      warnings: string[];
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/olo/startCheckout

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.olo.startCheckout({ host: "<host>", guid: "<guid>" });
  • startOrderOpens a guest basket at a location, returning the basket guid every other basket call (addToBasket, getBasket) needs.

    Arguments

    NameTypeRequired
    hoststringYes
    vendorIdnumberYes

    Returns OloBasket

    interface OloBasketProduct {
      id: string;
      productId: number;
      name: string;
      quantity: number;
      unitCost: number;
      totalCost: number;
    }
    
    interface OloBasket {
      guid: string;
      vendorId: number;
      handoffMode: string;  // "Unspecified" until the handoff mode and time are set -- not yet built
      items: OloBasketProduct[];
      subTotal: number;
      salesTax: number;
      total: number;
      unavailableItems: string[];
      couponDiscount: number;  // 0 when no coupon is applied
      checkout: OloCheckoutHandoff;  // a refusal listing the items to re-add on the order site (no link restores an Olo basket); Bowmark never pays
    }
    
    // The checkout handoff: where the PERSON finishes. Bowmark never pays, books or orders.
    // Switch on `status`; a status you do not recognise means "show the person `url` and stop".
    interface OloCheckoutHandoff {
      status: "ready_to_checkout" | "needs_login" | "unavailable";
      url: string;                       // the https page to open on the site
      urlKind?: "carries_items" | "signed_in_cart" | "product_page"; // ready_to_checkout only: does the link carry the items, or only open the item's page
      reason?: string;                   // unavailable only: out_of_stock | not_available_for_dates | not_sold_online | region_not_served | quantity_unavailable | empty_cart
      detail?: string;                   // unavailable only: one sentence saying why
      account: { site: string; hint: string; signedInAs?: string };
      summary: { items: { title: string; variant: string | null; quantity: number; unitPrice: string | null; lineTotal: string | null; url?: string; id?: string }[]; total: string | null; currency: string } | null;
      warnings: string[];
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/olo/startOrder

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.olo.startOrder({ host: "<host>", vendorId: 1 });
  • updateBasketItemChanges a basket item's quantity, options or instructions, by the item's id off getBasket, and returns the updated basket with its new subtotal, tax…

    Arguments

    NameTypeRequired
    hoststringYes
    guidstringYes
    basketProductIdstring
    An item's id off getBasket / addToBasket, not the product id.
    Yes
    vendorIdnumberYes
    vendorProductIdnumber
    The same product the item already is.
    Yes
    quantitynumberYes
    choiceIdsnumber[]
    The FULL choice list the item should end with.
    No
    specialInstructionsstringNo
    recipientNamestringNo

    Returns OloBasket

    interface OloBasketProduct {
      id: string;
      productId: number;
      name: string;
      quantity: number;
      unitCost: number;
      totalCost: number;
    }
    
    interface OloBasket {
      guid: string;
      vendorId: number;
      handoffMode: string;  // "Unspecified" until the handoff mode and time are set -- not yet built
      items: OloBasketProduct[];
      subTotal: number;
      salesTax: number;
      total: number;
      unavailableItems: string[];
      couponDiscount: number;  // 0 when no coupon is applied
      checkout: OloCheckoutHandoff;  // a refusal listing the items to re-add on the order site (no link restores an Olo basket); Bowmark never pays
    }
    
    // The checkout handoff: where the PERSON finishes. Bowmark never pays, books or orders.
    // Switch on `status`; a status you do not recognise means "show the person `url` and stop".
    interface OloCheckoutHandoff {
      status: "ready_to_checkout" | "needs_login" | "unavailable";
      url: string;                       // the https page to open on the site
      urlKind?: "carries_items" | "signed_in_cart" | "product_page"; // ready_to_checkout only: does the link carry the items, or only open the item's page
      reason?: string;                   // unavailable only: out_of_stock | not_available_for_dates | not_sold_online | region_not_served | quantity_unavailable | empty_cart
      detail?: string;                   // unavailable only: one sentence saying why
      account: { site: string; hint: string; signedInAs?: string };
      summary: { items: { title: string; variant: string | null; quantity: number; unitPrice: string | null; lineTotal: string | null; url?: string; id?: string }[]; total: string | null; currency: string } | null;
      warnings: string[];
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/olo/updateBasketItem

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.olo.updateBasketItem({
      host: "<host>",
      guid: "<guid>",
      basketProductId: "<basketProductId>",
      vendorId: 1,
      vendorProductId: 1,
      quantity: 1
    });

Use it from code