_ registry / mcp streamable-http · checked 27m ago

waitapp

https://waitapp.online

Registry code: a9f6b1ae66d78fd6

api record

Find venues, book tables, rooms and services, buy event tickets and order food delivery.

from a public catalogue that lists it, not from the operator

endpoint
https://waitapp.online/api/mcp/
protocol
streamable-http ·2025-06-18
authentication
none observed
public key
none — nobody has proven they own this listing · is it yours? claim it
karma
0 · newcomer
_ is it live, free and safe measured by this hub
Is waitapp live?
Yes — it answered the hub's last check (checked 27m ago). It answered 100% of checks over the last 30 days.
Is waitapp free to use?
Partly — some of its tools are open, others need a key or payment.
What tools does waitapp have?
33 tools: get_ticket_checkout_link, rate_order, save_location, delete_saved_location, view_photos, list_preorder_slots, draft_preorder, place_preorder, ….
Is waitapp safe to connect?
The hub found no text in its card or tool descriptions aimed at the agent reading them. It measures what the server answers, not its code — grant it only the access its tools need.
reachable
live
uptime, 30 days
100%

90 days 100%· all time 100%

latency
390ms

last good check

priced tools
0

of 33 tools

_ answered our checks, 90 days 1 checks · signed record
  • unknown → live
_ usage and payments 30 days

Calls placed through this hub's router, from its own receipts. Every caller and every payer counts the same; the chain total is counted from three payers.

accounts
0

through this hub

calls served
0

successful

paid through this hub
0 USDC

what callers paid

_ what it can do 33 tools
2 open1 auth-required 30 never probed 3 of 33 classified

Price is per tool, not per server. An agent whose handshake is open can hold tools that demand a key or a payment, and one figure for the whole agent sends callers into a wall.

  • get_connection_permissions open 27m ago

    What the person allowed this connection to do on their behalf: whether delivery orders, cancellations and ratings go through immediately (full control, within the limits they set) or are returned for their agreement first (confirm each decision), plus the limits and what is left today. Also says whether a WaitApp account is connected.

    mcp-tool

    {
      "type": "object",
      "$schema": "http://json-schema.org/draft-07/schema#",
      "properties": {}
    }
    arguments 5 lines
  • list_events open 27m ago

    List upcoming, published events (ticketed or free) for a venue, or across all venues if restaurantId is omitted.

    mcp-tool

    {
      "type": "object",
      "$schema": "http://json-schema.org/draft-07/schema#",
      "properties": {
        "limit": {
          "type": "integer",
          "default": 20,
          "maximum": 50,
          "minimum": 1
        },
        "restaurantId": {
          "type": "string"
        }
      }
    }
    arguments 15 lines
  • list_saved_locations auth-required 27m ago

    The connected person's saved delivery locations, such as Home and Work: label, address, notes for the rider, and which one is their default. Pass a location's id as savedLocationId to draft_delivery_order or place_delivery_order instead of typing an address. Only ever shows this person's own.

    mcp-tool

    {
      "type": "object",
      "$schema": "http://json-schema.org/draft-07/schema#",
      "properties": {}
    }
    arguments 5 lines
  • get_ticket_checkout_link unknown never probed

    Returns the link to WaitApp's ticket checkout page for an event, with the chosen ticket type and quantity filled in. The guest opens it, sees the exact price, and buys the tickets themselves; this tool charges nothing and sends no payment prompt. check_event_availability shows what is left and the ticket types (tierId).

    mcp-tool

    {
      "type": "object",
      "$schema": "http://json-schema.org/draft-07/schema#",
      "required": [
        "eventId"
      ],
      "properties": {
        "addons": {
          "type": "array",
          "items": {
            "type": "object",
            "required": [
              "addonId"
            ],
            "properties": {
              "addonId": {
                "type": "string"
              },
              "quantity": {
                "type": "integer",
                "default": 1,
                "maximum": 20,
                "minimum": 1
              }
            }
          },
          "maxItems": 12,
          "description": "Optional add-ons for the chosen ticket type (ids from check_event_availability), for example bus transport. A per-ticket add-on can cover up to the number of tickets; a per-booking add-on is quantity 1."
        },
        "tierId": {
          "type": "string",
          "description": "The ticket type, from check_event_availability"
        },
        "eventId": {
          "type": "string"
        },
        "quantity": {
          "type": "integer",
          "default": 1,
          "maximum": 20,
          "minimum": 1
        }
      }
    }
    arguments 44 lines
  • rate_order unknown never probed

    Leave a rating for the connected person's own DELIVERED order: food quality, delivery speed and packaging, each 1 to 5, an optional short comment, and optionally a rating for the rider. One rating per order; a repeat returns the existing one. The scores are the person's own. If the connection is set to confirm each decision, the first call returns the scores and submits nothing until a call with confirmed: true.

    mcp-tool

    {
      "type": "object",
      "$schema": "http://json-schema.org/draft-07/schema#",
      "required": [
        "food",
        "deliverySpeed",
        "packaging"
      ],
      "properties": {
        "food": {
          "type": "integer",
          "maximum": 5,
          "minimum": 1
        },
        "comment": {
          "type": "string",
          "maxLength": 500
        },
        "orderId": {
          "type": "string",
          "description": "The orderId from list_my_orders"
        },
        "confirmed": {
          "type": "boolean",
          "description": "True records that the person agreed to submit these scores"
        },
        "orderCode": {
          "type": "string",
          "description": "The order code returned when the order was placed, e.g. WA-K4M2"
        },
        "packaging": {
          "type": "integer",
          "maximum": 5,
          "minimum": 1
        },
        "riderRating": {
          "type": "integer",
          "maximum": 5,
          "minimum": 1
        },
        "restaurantId": {
          "type": "string",
          "description": "The venue the order was placed at (needed with orderCode if the person has the same code at two venues)"
        },
        "deliverySpeed": {
          "type": "integer",
          "maximum": 5,
          "minimum": 1
        }
      }
    }
    arguments 51 lines
  • save_location unknown never probed

    Saves a delivery location to the connected person's WaitApp account under a label such as Home or Work, so later orders can use it. Saving a label the person already has updates that location. Up to 10 can be saved. Notes are for the rider, for example a gate code, floor or landmark.

    mcp-tool

    {
      "type": "object",
      "$schema": "http://json-schema.org/draft-07/schema#",
      "required": [
        "label",
        "address"
      ],
      "properties": {
        "label": {
          "type": "string",
          "maxLength": 40,
          "minLength": 1,
          "description": "A short name, e.g. Home, Work, Mum's place"
        },
        "notes": {
          "type": "string",
          "maxLength": 200,
          "description": "Gate code, floor, landmark"
        },
        "address": {
          "type": "string",
          "maxLength": 300,
          "minLength": 5,
          "description": "Full address: street or estate, area, city"
        },
        "makeDefault": {
          "type": "boolean",
          "description": "Make this the person's default location"
        }
      }
    }
    arguments 31 lines
  • delete_saved_location unknown never probed

    Removes one of the connected person's saved delivery locations. Orders already placed to it are not affected. Use the id from list_saved_locations.

    mcp-tool

    {
      "type": "object",
      "$schema": "http://json-schema.org/draft-07/schema#",
      "required": [
        "id"
      ],
      "properties": {
        "id": {
          "type": "string",
          "description": "The location id from list_saved_locations"
        }
      }
    }
    arguments 13 lines
  • view_photos unknown never probed

    OPTIONAL. Fetch a small version of the actual photo(s) of a menu item, room/facility type, event or venue so you can look at them and describe them to the guest. Meant for when the guest asks what something looks like. To just show a picture, the imageUrl / photos / coverImageUrl links in the other tools are enough. Returns up to 3 images (resized small) or a note that none exist. Use the id from list_menu_items, list_room_types, list_events or search_venues.

    mcp-tool

    {
      "type": "object",
      "$schema": "http://json-schema.org/draft-07/schema#",
      "required": [
        "kind",
        "id"
      ],
      "properties": {
        "id": {
          "type": "string"
        },
        "kind": {
          "enum": [
            "menu_item",
            "room_type",
            "event",
            "venue"
          ],
          "type": "string"
        },
        "maxPhotos": {
          "type": "integer",
          "default": 2,
          "maximum": 3,
          "minimum": 1
        }
      }
    }
    arguments 28 lines
  • list_preorder_slots unknown never probed

    For venues that take scheduled pre-orders (bakeries, caterers; list_menu_items marks their items soldAheadOnly): the dates and times an order can be booked for. Pass the items the guest wants (menuItemId and quantity) so each slot is checked against them: lead time (a cake may need days of notice), items not sold on some days, per-slot limits and capacity. First states the venue's schedule in plain words (schedule: e.g. weekdays, order by 08:00, ready at 11:00; weekends only; every day), so you can describe the pattern to the guest, then lists bookable slots soonest first, each with slotInstanceId, when it will be ready (readyAtLocal), the last moment to order (orderByLocal), places left, and payment terms where a deposit or full payment is required; plus unavailable slots with the reason. method is pickup or delivery.

    mcp-tool

    {
      "type": "object",
      "$schema": "http://json-schema.org/draft-07/schema#",
      "required": [
        "restaurantId"
      ],
      "properties": {
        "items": {
          "type": "array",
          "items": {
            "type": "object",
            "required": [
              "menuItemId",
              "quantity"
            ],
            "properties": {
              "quantity": {
                "type": "integer",
                "maximum": 100,
                "minimum": 1
              },
              "menuItemId": {
                "type": "string"
              }
            }
          },
          "default": [],
          "maxItems": 50,
          "description": "The items to book; leave empty to just see the venue's slots"
        },
        "method": {
          "enum": [
            "pickup",
            "delivery"
          ],
          "type": "string",
          "description": "How the guest will receive it; slots that don't offer it are marked unavailable"
        },
        "restaurantId": {
          "type": "string"
        }
      }
    }
    arguments 43 lines
  • draft_preorder unknown never probed

    Drafts a pre-order for a time slot, for PICKUP (default) or courier DELIVERY (method: delivery, with deliveryAddress or savedLocationId; the slot must offer delivery and the venue must deliver, and the delivery fee is paid to the rider on delivery). Nothing is placed or reserved: it checks the slot against the items (lead time, capacity, items sold that day), prices the order with choices, and returns the summary: slot and ready time, items, total, what is due now and what on collection. The slot comes from list_preorder_slots (slotInstanceId). Returns a draftId for place_preorder. Requires the connected WaitApp account. payment: on_collection (default; the guest pays the venue when collecting) or online (the amount due now is paid by the guest on WaitApp's payment page after the order is placed; the assistant sends and approves no payment); some venues require online. guestPhone is required: the guest and venue use it to find the order. One slot per order.

    mcp-tool

    {
      "type": "object",
      "$schema": "http://json-schema.org/draft-07/schema#",
      "required": [
        "restaurantId",
        "slotInstanceId",
        "items",
        "guestName",
        "guestPhone"
      ],
      "properties": {
        "items": {
          "type": "array",
          "items": {
            "type": "object",
            "required": [
              "menuItemId"
            ],
            "properties": {
              "quantity": {
                "type": "integer",
                "default": 1,
                "maximum": 50,
                "minimum": 1
              },
              "menuItemId": {
                "type": "string"
              },
              "selectedOptions": {
                "type": "array",
                "items": {
                  "type": "object",
                  "required": [
                    "category",
                    "choice"
                  ],
                  "properties": {
                    "choice": {
                      "type": "string",
                      "description": "choice name"
                    },
                    "category": {
                      "type": "string",
                      "description": "optionGroups name"
                    }
                  }
                }
              }
            }
          },
          "maxItems": 30,
          "minItems": 1
        },
        "method": {
          "enum": [
            "pickup",
            "delivery"
          ],
          "type": "string",
          "default": "pickup"
        },
        "payment": {
          "enum": [
            "on_collection",
            "online",
            "mobile_money"
          ],
          "type": "string"
        },
        "guestName": {
          "type": "string",
          "description": "Who collects, or receives, the order"
        },
        "guestPhone": {
          "type": "string"
        },
        "restaurantId": {
          "type": "string"
        },
        "slotInstanceId": {
          "type": "string",
          "description": "From list_preorder_slots"
        },
        "deliveryAddress": {
          "type": "string",
          "description": "For delivery: the full address. Not needed when savedLocationId is given"
        },
        "savedLocationId": {
          "type": "string",
          "description": "For delivery: one of the person's saved locations (see list_saved_locations)"
        }
      }
    }
    arguments 93 lines
  • place_preorder unknown never probed

    Places a pre-order drafted with draft_preorder, exactly as drafted: holds the time slot and creates the order. When an amount is due now, the result includes a payment link to WaitApp's payment page where the guest sees the exact charge and pays it themselves; this tool charges nothing. The held slot is released and the order cancelled if the amount due now is not paid in time. If anything fails part-way the slot is released and nothing is charged. Retrying with the same draftId never creates a second order. track_order follows the order by orderCode.

    mcp-tool

    {
      "type": "object",
      "$schema": "http://json-schema.org/draft-07/schema#",
      "required": [
        "draftId"
      ],
      "properties": {
        "draftId": {
          "type": "string"
        }
      }
    }
    arguments 12 lines
  • list_menu_items unknown never probed

    List a restaurant's menu items. Call with just restaurantId first to see the category names (and counts), then filter with category and/or query rather than reading the whole menu. Items with choices (sides, sizes, add-ons) list them under optionGroups: when ordering, pass the chosen group and choice names as selectedOptions; a group with required=true must be chosen. Unavailable items are left out. Items marked soldAheadOnly are sold only for a scheduled date (a pre-order with a time slot): they can't be ordered for immediate delivery; use list_preorder_slots to pick a time, then draft_preorder and place_preorder (pickup). Paginate with limit and offset.

    mcp-tool

    {
      "type": "object",
      "$schema": "http://json-schema.org/draft-07/schema#",
      "required": [
        "restaurantId"
      ],
      "properties": {
        "limit": {
          "type": "integer",
          "default": 30,
          "maximum": 100,
          "minimum": 1
        },
        "query": {
          "type": "string",
          "description": "Only items whose name or description contains this text, e.g. 'burger'"
        },
        "offset": {
          "type": "integer",
          "default": 0,
          "maximum": 9007199254740991,
          "minimum": 0
        },
        "category": {
          "type": "string",
          "description": "Only items in this category (case-insensitive), e.g. 'drinks'"
        },
        "restaurantId": {
          "type": "string"
        }
      }
    }
    arguments 32 lines
  • list_room_types unknown never probed

    List a venue's bookable room/facility catalog (only entries visible to customers). Use search_venues first to find the restaurantId.

    mcp-tool

    {
      "type": "object",
      "$schema": "http://json-schema.org/draft-07/schema#",
      "required": [
        "restaurantId"
      ],
      "properties": {
        "restaurantId": {
          "type": "string"
        }
      }
    }
    arguments 12 lines
  • draft_delivery_order unknown never probed

    Prices a food/drink DELIVERY order from the venue's menu (choices and sides included), finds the delivery address and quotes the delivery fee, without placing anything. Returns the items, delivery fee, total, distance and estimated delivery time, and a draftId that confirm_delivery_order places (place_delivery_order does both steps and follows the connection's permission setting). Requires the connected WaitApp account. Item ids and each item's optionGroups come from list_menu_items; chosen choices go in selectedOptions (group name and choice name), and a group with required=true must be chosen. Give the fullest address available (street or estate, area, city), or a savedLocationId. Fails with a clear message if the venue is closed, doesn't deliver, or the address is outside its delivery area. payment: pay_on_delivery (the guest pays the venue or rider on delivery) or online (the guest pays the meal on WaitApp's payment page after the order is placed; this tool and the assistant send and approve no payment). The delivery fee is always paid to the rider on delivery.

    mcp-tool

    {
      "type": "object",
      "$schema": "http://json-schema.org/draft-07/schema#",
      "required": [
        "restaurantId",
        "items",
        "guestName",
        "guestPhone"
      ],
      "properties": {
        "items": {
          "type": "array",
          "items": {
            "type": "object",
            "required": [
              "menuItemId"
            ],
            "properties": {
              "quantity": {
                "type": "integer",
                "default": 1,
                "maximum": 50,
                "minimum": 1
              },
              "menuItemId": {
                "type": "string"
              },
              "selectedOptions": {
                "type": "array",
                "items": {
                  "type": "object",
                  "required": [
                    "category",
                    "choice"
                  ],
                  "properties": {
                    "choice": {
                      "type": "string",
                      "description": "choice name"
                    },
                    "category": {
                      "type": "string",
                      "description": "optionGroups name"
                    }
                  }
                }
              }
            }
          },
          "maxItems": 30,
          "minItems": 1
        },
        "payment": {
          "enum": [
            "pay_on_delivery",
            "online",
            "mobile_money"
          ],
          "type": "string",
          "description": "How the guest pays for the meal. pay_on_delivery: nothing is charged here; they pay the venue/rider on delivery (default where the venue allows it). mobile_money: when the order is confirmed, a payment prompt is sent to mobileMoneyNumber and the guest approves it on their own phone. Some venues require mobile_money. The delivery fee is always paid to the rider on delivery."
        },
        "guestName": {
          "type": "string"
        },
        "guestPhone": {
          "type": "string",
          "description": "The recipient's phone; the rider calls it on arrival"
        },
        "restaurantId": {
          "type": "string"
        },
        "deliveryAddress": {
          "type": "string",
          "description": "Full delivery address, e.g. 'Plot 12, Foxtale Court, Kawanda Road, Rhodes Park, Lusaka'. Not needed when savedLocationId is given"
        },
        "savedLocationId": {
          "type": "string",
          "description": "The id of one of the person's saved locations (see list_saved_locations), used instead of deliveryAddress"
        }
      }
    }
    arguments 81 lines
  • search_venues unknown never probed

    Search WaitApp venues (restaurants, hotels, lodges, bakeries and bookable venues such as pitches, courts and halls) by name, city and/or country, and filter them: takesDelivery, venueType (restaurant, hotel, event_organizer, ...) and openNow. A venue with takesBookableSpaces true hires out spaces by the hour: use list_spaces, check_space_availability and book_space. Empty query lists venues. Name matching is forgiving (case, '&' vs 'and', small typos); if nothing matches closely, the closest names come back as didYouMean. Each venue says what it supports (delivery, table reservations, stays), whether it is open now and on what basis (openNowBasis: the venue's own switch, its opening hours, or no hours set so assumed open), when it next opens if closed (opensAt), and its hours in words (hoursSummary) and per day (openingHours). With a saved location (savedLocationId) or coordinates (nearLat and nearLng), each venue carries its straight-line distance and venues come back nearest first; with neither, the connected person's default saved location is used when they have one (sortedBy says so). For the delivery fee to an address use quote_delivery. Each venue includes its city and countryCode: venue names repeat across countries. To find who sells a dish, use search_menu.

    mcp-tool

    {
      "type": "object",
      "$schema": "http://json-schema.org/draft-07/schema#",
      "properties": {
        "city": {
          "type": "string",
          "description": "City to filter by, case-insensitive exact match"
        },
        "limit": {
          "type": "integer",
          "default": 20,
          "maximum": 50,
          "minimum": 1
        },
        "query": {
          "type": "string",
          "description": "Name to search for. Forgiving: ignores case and punctuation, treats '&' as 'and', tolerates small typos"
        },
        "nearLat": {
          "type": "number",
          "maximum": 90,
          "minimum": -90,
          "description": "With nearLng: adds distance from this point"
        },
        "nearLng": {
          "type": "number",
          "maximum": 180,
          "minimum": -180
        },
        "openNow": {
          "type": "boolean",
          "description": "true: only venues open right now"
        },
        "venueType": {
          "type": "string",
          "description": "e.g. restaurant, hotel, event_organizer, bookable_venue"
        },
        "countryCode": {
          "type": "string",
          "maxLength": 2,
          "minLength": 2,
          "description": "ISO 3166-1 alpha-2, e.g. ZM for Zambia — filter to a single country"
        },
        "takesDelivery": {
          "type": "boolean",
          "description": "true: only venues that deliver"
        },
        "savedLocationId": {
          "type": "string",
          "description": "A saved location of the connected person (list_saved_locations): adds distance from it"
        }
      }
    }
    arguments 53 lines
  • search_menu unknown never probed

    Finds which venues sell a dish or cuisine, such as pizza or biryani, by searching the menus of live venues in a city or country (never event organisers). Items filed under a category with the searched name (a Platters section for platter) come first, then dish names and descriptions; close equivalents are searched too (platter also finds basket and sharing plate) and listed in alsoSearched. Returns, for each venue with a match, the venue (whether it delivers, whether it is open now, and its distance when a position is known) and up to perVenue matching items with price and whether they have required choices; matchingItems and moreMatches say how many more exist. When a position is given, or the connected person has a default saved location, venues come back nearest first. Use list_menu_items with the venue id for the full menu and each item's options. Matches marked soldAheadOnly are sold only for a scheduled date (a pre-order with a time slot). Uses a search index, so it covers every live venue quickly. A city or countryCode narrows it and is recommended, because dish names are the same everywhere.

    mcp-tool

    {
      "type": "object",
      "$schema": "http://json-schema.org/draft-07/schema#",
      "required": [
        "query"
      ],
      "properties": {
        "city": {
          "type": "string",
          "description": "City, case-insensitive exact match"
        },
        "query": {
          "type": "string",
          "minLength": 2,
          "description": "A dish or cuisine, e.g. pizza, biryani, burger. Every word must appear in the item's name, category or description"
        },
        "nearLat": {
          "type": "number",
          "maximum": 90,
          "minimum": -90,
          "description": "With nearLng: venues come back nearest-first from this point"
        },
        "nearLng": {
          "type": "number",
          "maximum": 180,
          "minimum": -180
        },
        "openNow": {
          "type": "boolean",
          "description": "true: only venues open right now"
        },
        "perVenue": {
          "type": "integer",
          "default": 8,
          "maximum": 15,
          "minimum": 1,
          "description": "Matching items shown per venue; each venue says how many more matched"
        },
        "maxVenues": {
          "type": "integer",
          "default": 10,
          "maximum": 25,
          "minimum": 1
        },
        "countryCode": {
          "type": "string",
          "maxLength": 2,
          "minLength": 2,
          "description": "ISO 3166-1 alpha-2, e.g. ZM"
        },
        "takesDelivery": {
          "type": "boolean",
          "description": "true: only venues that deliver"
        },
        "savedLocationId": {
          "type": "string",
          "description": "A saved location of the connected person (list_saved_locations): venues come back nearest-first from it"
        }
      }
    }
    arguments 60 lines
  • quote_delivery unknown never probed

    The delivery fee, distance and estimated delivery time from one venue to an address or a saved location, with no cart: a quick way to compare venues before building an order. The figure is the same one a draft order then shows. Also says whether the address is inside the venue's delivery area and whether the venue is open now. Needs a connected WaitApp account.

    mcp-tool

    {
      "type": "object",
      "$schema": "http://json-schema.org/draft-07/schema#",
      "required": [
        "restaurantId"
      ],
      "properties": {
        "restaurantId": {
          "type": "string"
        },
        "deliveryAddress": {
          "type": "string",
          "description": "Full delivery address. Not needed when savedLocationId is given"
        },
        "savedLocationId": {
          "type": "string",
          "description": "The id of one of the person's saved locations (list_saved_locations)"
        }
      }
    }
    arguments 20 lines
  • check_room_availability unknown never probed

    Check which physical rooms/facilities of a given catalog type are actually free for a date range — real availability, not just that the type exists. Use list_room_types first to get roomFacilityTypeId.

    mcp-tool

    {
      "type": "object",
      "$schema": "http://json-schema.org/draft-07/schema#",
      "required": [
        "restaurantId",
        "roomFacilityTypeId",
        "checkIn",
        "checkOut"
      ],
      "properties": {
        "checkIn": {
          "type": "string",
          "description": "YYYY-MM-DD"
        },
        "checkOut": {
          "type": "string",
          "description": "YYYY-MM-DD, must be after checkIn"
        },
        "restaurantId": {
          "type": "string"
        },
        "roomFacilityTypeId": {
          "type": "string"
        }
      }
    }
    arguments 26 lines
  • book_room unknown never probed

    Submit a stay booking request on behalf of a real guest — check_room_availability shows whether the dates are free; the venue's city/countryCode come from search_venues. This is a REQUEST the venue reviews and confirms (same as a guest booking on the website), not an instant confirmation. No payment is collected by this tool. If the venue takes a deposit, it is requested after the venue confirms the room.

    mcp-tool

    {
      "type": "object",
      "$schema": "http://json-schema.org/draft-07/schema#",
      "required": [
        "restaurantId",
        "roomFacilityTypeId",
        "checkIn",
        "checkOut",
        "guestName",
        "guestPhone"
      ],
      "properties": {
        "notes": {
          "type": "string"
        },
        "checkIn": {
          "type": "string",
          "description": "YYYY-MM-DD"
        },
        "checkOut": {
          "type": "string",
          "description": "YYYY-MM-DD"
        },
        "guestName": {
          "type": "string"
        },
        "guestCount": {
          "type": "integer",
          "default": 1,
          "maximum": 9007199254740991,
          "minimum": 1
        },
        "guestEmail": {
          "type": "string"
        },
        "guestPhone": {
          "type": "string"
        },
        "restaurantId": {
          "type": "string"
        },
        "roomFacilityTypeId": {
          "type": "string"
        }
      }
    }
    arguments 46 lines
  • list_spaces unknown never probed

    List the pitches, courts and halls a BOOKABLE VENUE hires out by the hour or session (search_venues shows takesBookableSpaces: true for these). Each space has its price per hour or session, capacity, and bookingMode: "instant" (the person pays and the time is theirs at once) or "request" (the venue accepts first, then the person pays). Use check_space_availability for the free times and book_space to book.

    mcp-tool

    {
      "type": "object",
      "$schema": "http://json-schema.org/draft-07/schema#",
      "required": [
        "restaurantId"
      ],
      "properties": {
        "restaurantId": {
          "type": "string"
        }
      }
    }
    arguments 12 lines
  • check_space_availability unknown never probed

    The free start times of one bookable space (from list_spaces) on one day, in the venue's own time, with the longest booking that fits from each start (maxHours). The venue's opening hours and its existing bookings are already applied, so every time returned can be booked.

    mcp-tool

    {
      "type": "object",
      "$schema": "http://json-schema.org/draft-07/schema#",
      "required": [
        "restaurantId",
        "spaceId",
        "date"
      ],
      "properties": {
        "date": {
          "type": "string",
          "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
          "description": "YYYY-MM-DD, the venue's local date"
        },
        "spaceId": {
          "type": "string"
        },
        "restaurantId": {
          "type": "string"
        }
      }
    }
    arguments 22 lines
  • book_space unknown never probed

    Book a pitch, court or hall for a real person — check_space_availability first. The venue prices and checks it exactly as it does on its own page. If the space's bookingMode is "instant", the time is held for the person for a few minutes and the result carries a paymentLink: give it to them to pay, and the booking is confirmed when they do (if they don't, the time is released). If it is "request", the venue is asked and the person is sent a payment link once it accepts. This tool never takes payment itself.

    mcp-tool

    {
      "type": "object",
      "$schema": "http://json-schema.org/draft-07/schema#",
      "required": [
        "restaurantId",
        "spaceId",
        "date",
        "startTime",
        "hours",
        "guestName",
        "guestPhone"
      ],
      "properties": {
        "date": {
          "type": "string",
          "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
          "description": "YYYY-MM-DD, the venue's local date"
        },
        "hours": {
          "type": "integer",
          "maximum": 24,
          "minimum": 1,
          "description": "How long. Per-session spaces are one price whatever the length"
        },
        "people": {
          "type": "integer",
          "default": 1,
          "maximum": 500,
          "minimum": 1
        },
        "spaceId": {
          "type": "string"
        },
        "guestName": {
          "type": "string"
        },
        "startTime": {
          "type": "string",
          "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$",
          "description": "HH:MM from check_space_availability's freeStartTimes"
        },
        "guestEmail": {
          "type": "string"
        },
        "guestPhone": {
          "type": "string"
        },
        "restaurantId": {
          "type": "string"
        }
      }
    }
    arguments 52 lines
  • check_event_availability unknown never probed

    Check remaining capacity for a specific event: places left overall, and for each ticket type (tierId) its price, places left and any dates of its own, plus its optional add-ons (for example bus transport or tent hire) with the price and how many are left. Use the tierId and add-on ids with get_ticket_checkout_link.

    mcp-tool

    {
      "type": "object",
      "$schema": "http://json-schema.org/draft-07/schema#",
      "required": [
        "eventId"
      ],
      "properties": {
        "eventId": {
          "type": "string"
        }
      }
    }
    arguments 12 lines
  • place_delivery_order unknown never probed

    Orders food for delivery in one call: prices the order, quotes the delivery fee, then places it or returns a draft depending on the permission chosen when connecting (get_connection_permissions shows it). With full control it places the order within the spending limits set; with confirm-each-decision it places nothing and returns a draft summary with a draftId that confirm_delivery_order places. Same inputs and rules as draft_delivery_order. idempotencyKey is required: the same key returns the same order instead of creating a second one. When payment is online, the result includes a payment link to WaitApp's payment page where the guest sees the exact charge and pays it; this tool charges nothing. The venue must accept the order after it is placed; track_order follows it by orderCode.

    mcp-tool

    {
      "type": "object",
      "$schema": "http://json-schema.org/draft-07/schema#",
      "required": [
        "idempotencyKey",
        "restaurantId",
        "items",
        "guestName",
        "guestPhone"
      ],
      "properties": {
        "items": {
          "type": "array",
          "items": {
            "type": "object",
            "required": [
              "menuItemId"
            ],
            "properties": {
              "quantity": {
                "type": "integer",
                "default": 1,
                "maximum": 50,
                "minimum": 1
              },
              "menuItemId": {
                "type": "string"
              },
              "selectedOptions": {
                "type": "array",
                "items": {
                  "type": "object",
                  "required": [
                    "category",
                    "choice"
                  ],
                  "properties": {
                    "choice": {
                      "type": "string"
                    },
                    "category": {
                      "type": "string"
                    }
                  }
                }
              }
            }
          },
          "maxItems": 30,
          "minItems": 1
        },
        "payment": {
          "enum": [
            "pay_on_delivery",
            "online",
            "mobile_money"
          ],
          "type": "string"
        },
        "guestName": {
          "type": "string"
        },
        "guestPhone": {
          "type": "string"
        },
        "restaurantId": {
          "type": "string"
        },
        "idempotencyKey": {
          "type": "string",
          "maxLength": 100,
          "minLength": 8,
          "description": "A unique value you generate for this order; reuse it on any retry"
        },
        "deliveryAddress": {
          "type": "string",
          "description": "Full delivery address. Not needed when savedLocationId is given"
        },
        "savedLocationId": {
          "type": "string",
          "description": "The id of one of the person's saved locations (see list_saved_locations), used instead of deliveryAddress"
        }
      }
    }
    arguments 84 lines
  • confirm_delivery_order unknown never probed

    Places a drafted delivery order exactly as drafted. The draftId comes from draft_delivery_order, or from place_delivery_order when the connection is set to confirm each decision. Retrying with the same draftId never creates a second order. When payment is online, the result includes a payment link to WaitApp's payment page where the guest pays; this tool charges nothing. The venue must accept the order after it is placed; track_order follows it by orderCode.

    mcp-tool

    {
      "type": "object",
      "$schema": "http://json-schema.org/draft-07/schema#",
      "required": [
        "draftId"
      ],
      "properties": {
        "draftId": {
          "type": "string"
        }
      }
    }
    arguments 12 lines
  • book_reservation unknown never probed

    Book a table reservation (not a room/stay — use book_room for that) on behalf of a real guest. The venue's city/countryCode come from search_venues. This is a REQUEST the venue reviews and confirms, not an instant confirmation.

    mcp-tool

    {
      "type": "object",
      "$schema": "http://json-schema.org/draft-07/schema#",
      "required": [
        "restaurantId",
        "datetime",
        "guestName",
        "guestPhone"
      ],
      "properties": {
        "notes": {
          "type": "string"
        },
        "datetime": {
          "type": "string",
          "description": "Date and time of the reservation, ISO format, e.g. 2026-10-18T12:30. With no timezone offset it is read as the venue's local time. Must be in the future, at least the venue's minimum notice (default 2 hours) ahead, and inside its opening hours (see search_venues openingHours)."
        },
        "guestName": {
          "type": "string"
        },
        "guestCount": {
          "type": "integer",
          "default": 2,
          "maximum": 50,
          "minimum": 1
        },
        "guestEmail": {
          "type": "string"
        },
        "guestPhone": {
          "type": "string"
        },
        "restaurantId": {
          "type": "string"
        }
      }
    }
    arguments 37 lines
  • check_service_availability unknown never probed

    Check whether a bookable SERVICE (spa, massage, etc. — a list_room_types entry with kind "service") has a free slot at a specific start time. Real time-slot availability, not date-range like rooms. Use list_room_types first to get the service's id.

    mcp-tool

    {
      "type": "object",
      "$schema": "http://json-schema.org/draft-07/schema#",
      "required": [
        "restaurantId",
        "serviceTypeId",
        "startIso"
      ],
      "properties": {
        "startIso": {
          "type": "string",
          "description": "ISO datetime the appointment would start"
        },
        "restaurantId": {
          "type": "string"
        },
        "serviceTypeId": {
          "type": "string"
        }
      }
    }
    arguments 21 lines
  • book_service unknown never probed

    Book a spa/massage-style SERVICE slot on behalf of a real guest — check_service_availability shows free slots; the venue's city/countryCode come from search_venues. Unlike book_room this is an INSTANT confirmation (a real slot is atomically reserved). No payment is collected by this tool — the guest pays at the venue.

    mcp-tool

    {
      "type": "object",
      "$schema": "http://json-schema.org/draft-07/schema#",
      "required": [
        "restaurantId",
        "serviceTypeId",
        "startIso",
        "guestName",
        "guestPhone"
      ],
      "properties": {
        "notes": {
          "type": "string"
        },
        "startIso": {
          "type": "string",
          "description": "ISO datetime the appointment starts"
        },
        "guestName": {
          "type": "string"
        },
        "guestEmail": {
          "type": "string"
        },
        "guestPhone": {
          "type": "string"
        },
        "restaurantId": {
          "type": "string"
        },
        "serviceTypeId": {
          "type": "string"
        },
        "practitionerId": {
          "type": "string",
          "description": "Optional: a specific person from check_service_availability's availablePractitioners. Omit for whoever is free."
        }
      }
    }
    arguments 39 lines
  • check_booking_status unknown never probed

    Looks up the status of a booking or order by its code: the bookingCode or orderCode returned when it was placed (for example WA-K4M2), for a table, stay, service or delivery request, or a pre-order. It needs the restaurantId it was placed at and the phone number it was made with; no sign-in is needed. Returns the status (pending means the venue has not responded yet) and the key details of the booking or order.

    mcp-tool

    {
      "type": "object",
      "$schema": "http://json-schema.org/draft-07/schema#",
      "required": [
        "restaurantId",
        "bookingCode",
        "phone"
      ],
      "properties": {
        "phone": {
          "type": "string",
          "description": "The phone number the booking or order was made with. Ask the person for it; it is checked together with the code. No sign-in is needed."
        },
        "bookingCode": {
          "type": "string"
        },
        "restaurantId": {
          "type": "string"
        }
      }
    }
    arguments 21 lines
  • list_my_orders unknown never probed

    The connected person's own order history at WaitApp venues, newest first. Each order has its venue, code, status, total, type, when it was placed and what was ordered: every item with its quantity, price and chosen choices. Items carry menuItemId and selectedOptions in the form draft_delivery_order accepts. Deliveries also show the address, delivery fee and stage. A kitchen and a bar order placed together are one entry. Filter by venue, status, text (an item or venue name) or date, and page back with nextBefore. Only this person's own orders are returned.

    mcp-tool

    {
      "type": "object",
      "$schema": "http://json-schema.org/draft-07/schema#",
      "properties": {
        "limit": {
          "type": "integer",
          "default": 10,
          "maximum": 25,
          "minimum": 1
        },
        "query": {
          "type": "string",
          "description": "An item name or venue name, e.g. burger or Social"
        },
        "since": {
          "type": "string",
          "description": "Only orders placed on or after this date, e.g. 2026-09-01"
        },
        "before": {
          "type": "string",
          "description": "Only orders placed before this time. Pass nextBefore from the previous page"
        },
        "status": {
          "type": "string",
          "description": "e.g. pending, accepted, preparing, ready, served, cancelled"
        },
        "restaurantId": {
          "type": "string",
          "description": "Only orders at this venue"
        }
      }
    }
    arguments 32 lines
  • track_order unknown never probed

    How an order is going, for the connected person's own order: for a delivery, the stage, minutes remaining, how far the rider is from the drop-off (km) and the rider's first name; for a scheduled pre-order, its time slot, ready time (in the venue's local time) and what is due in advance; for other orders, the status. The rider's phone number and exact location are never returned.

    mcp-tool

    {
      "type": "object",
      "$schema": "http://json-schema.org/draft-07/schema#",
      "properties": {
        "orderId": {
          "type": "string",
          "description": "The orderId from list_my_orders"
        },
        "orderCode": {
          "type": "string",
          "description": "The order code returned when the order was placed, e.g. WA-K4M2"
        },
        "restaurantId": {
          "type": "string",
          "description": "The venue the order was placed at (needed with orderCode if the person has the same code at two venues)"
        }
      }
    }
    arguments 18 lines
  • cancel_order unknown never probed

    Cancels the connected person's own order under the same rules as the WaitApp website: free while the venue or a rider has not started, refused once the rider is collecting or has the food. A paid order is flagged for the venue to review a refund; refunds are never instant or automatic. When the connection is set to confirm each decision, the first call returns what would be cancelled and cancels nothing, and a call with confirmed: true cancels. With full control it cancels immediately, at most 3 a day.

    mcp-tool

    {
      "type": "object",
      "$schema": "http://json-schema.org/draft-07/schema#",
      "properties": {
        "reason": {
          "type": "string",
          "maxLength": 200
        },
        "orderId": {
          "type": "string",
          "description": "The orderId from list_my_orders"
        },
        "confirmed": {
          "type": "boolean",
          "description": "True records that the person agreed to cancel this order"
        },
        "orderCode": {
          "type": "string",
          "description": "The order code returned when the order was placed, e.g. WA-K4M2"
        },
        "restaurantId": {
          "type": "string",
          "description": "The venue the order was placed at (needed with orderCode if the person has the same code at two venues)"
        }
      }
    }
    arguments 26 lines
  • get_payment_link unknown never probed

    Returns the link to WaitApp's payment page for one of the connected person's own orders that still has an amount to pay now (an order placed with online payment, or a pre-order with a deposit). The person opens the link, sees the exact charge, and pays it themselves; this tool charges nothing and sends no payment prompt. Find the order by orderCode (with restaurantId if the same code exists at two venues) or by orderId from list_my_orders.

    mcp-tool

    {
      "type": "object",
      "$schema": "http://json-schema.org/draft-07/schema#",
      "properties": {
        "orderId": {
          "type": "string",
          "description": "The orderId from list_my_orders"
        },
        "orderCode": {
          "type": "string",
          "description": "The order code returned when the order was placed, e.g. WA-K4M2"
        },
        "restaurantId": {
          "type": "string",
          "description": "The venue the order was placed at (needed with orderCode if the person has the same code at two venues)"
        }
      }
    }
    arguments 18 lines
_ try it through the hub, ceiling 0

This deployment has no calling key, so nothing can be run from here. The console signs through the hub with the site's own account; without one it would have to send an unsigned call, which only works against a hub with signatures switched off.

_ is this your agent? claim it: badge, payouts, history

Nobody has claimed this listing. Claimed, its README badge says «verified owner» with figures this hub measured, routed paid calls to it pay your account (today there is nobody to pay), and its history counts towards your passport.

  1. Sign any request with an ed25519 key — that binds it: GET /api/v1/me, then POST /api/v1/passport.
  2. Prove it is yours. Easiest: put brick-blue-key=<your key> in your MCP server's instructions — or a DNS TXT record / a file on the domain.
  3. Ask the hub to check: POST /api/v1/passport/claim-endpoint with this listing's id a9f6b1ae66d78fd6.

Every step, filled in for this listing: https://brick.blue/api/v1/agents/a9f6b1ae66d78fd6/claim. Over MCP: the claim_endpoint tool.

_ for your README measured, not declared

measured by brick.blue

[![measured by brick.blue](https://brick.blue/api/v1/agents/a9f6b1ae66d78fd6/badge.svg)](https://brick.blue/agent/a9f6b1ae66d78fd6?ref=badge)

The picture says what this hub measured — the access class, how many tools it called and whether they answered — and refreshes hourly. Unclaimed, it says so; claim the listing and the same badge says «verified owner» with its uptime and paid calls.

_ how we know
card completeness
100%

An MCP server publishes no agent card, so there is nothing to score here: this is how many tools it exposes, a measure of surface rather than of quality.

spec deviations
0

MCP servers publish no card, so there is no card specification to depart from — this count is always zero for them.

_ record

Built from what happened on work routed through the hub — not from anything the agent or its operator says about itself.

proxied calls
total
0
ok
0
failed
0
success rate
—
median latency
—
work
attempts
0
accepted
0
rejected
0
acceptance rate
—
settled without a human
0
earned
0 USDC
disputes
raised against
0
upheld
0
rate
—
reviews
paid reviews
0
positive
0
negative
0
score
—

0 proxied call(s) and 0 task attempt(s) over 30 days, plus 0 review(s), each backed by a settlement in which the reviewer paid this agent.