order APIorder.store ↗
Fetch full menus, item customizations, pricing, store hours, and shareable order links from order.store restaurants via 3 JSON endpoints.
What is the order API?
The order.store API exposes 3 endpoints that return the complete online-ordering catalogue for any store on order.store: menu structure, item-level detail, and ready-to-share ordering links. The get_menu endpoint alone surfaces store coordinates, operating hours, currency, open/orderable state, and every category with its items including prices and availability flags. get_menu_item goes deeper, returning a full customization tree with nested option groups, add-on prices, and per-option sold-out status.
curl -X GET 'https://api.parse.bot/scraper/8b173766-3e9f-4f5e-a6d2-842d4b78ce98/get_menu?dining_mode=DELIVERY' \ -H 'X-API-Key: $PARSE_API_KEY'
Typed, relational, agent-ready
A generated client with real types, enums, and the links between objects — the structure a flat JSON response can't carry. Autocompletes in your editor and reads cleanly to coding agents.
- Fully typed · autocompletes
- Objects link to objects
- Typed errors & pagination
Typed Python client. Set up the SDK in your uv project, then pull this API’s typed client:
uv add parse-sdk uv run parse init uv run parse add --marketplace order-store-api
uv run parse add --marketplace pulls a pinned snapshot of this canonical API — it won’t change underneath you. To customize it, subscribe and swap to your own copy.
"""Walkthrough: browse the Slice of Fire Pizza menu, inspect customizations, and generate an order link."""
from parse_apis.order_store_api import OrderStore, DiningMode, InputNotFound
client = OrderStore()
# Load the full store menu for pickup mode.
store = client.stores.get(dining_mode=DiningMode.PICKUP)
print(store.store_name, "|", store.address)
print(f"Open: {store.is_open} Orderable: {store.is_orderable} ETA: {store.delivery_eta}")
print(f"Cuisines: {', '.join(store.cuisines)} Price: {store.price_bucket}")
print(f"{store.category_count} categories, {store.item_count} items\n")
# Walk each category and its items.
for cat in store.categories or []:
print(f"[{cat.name}] ({cat.item_count} items) {cat.description or ''}")
for item in cat.items:
print(f" {item.name} {item.price_display} sold_out={item.is_sold_out}")
# Drill into the first available item's full detail via the summary→detail link.
first_summary = None
for cat in store.categories or []:
for item in cat.items:
if item.is_available and not item.is_sold_out:
first_summary = item
break
if first_summary is not None:
break
if first_summary is not None:
detail = first_summary.details()
print(f"\nItem detail: {detail.name} ${detail.price}")
print(f"Description: {detail.description}")
for cust in detail.customizations:
print(f" Customization: {cust.name} (pick {cust.min_permitted}-{cust.max_permitted})")
for opt in cust.options:
print(f" - {opt.name} +${opt.price} sold_out={opt.is_sold_out}")
# Generate an ordering link for the item we just inspected.
order_info = client.order_links.get(item_ids=first_summary.item_id, dining_mode=DiningMode.PICKUP)
print(f"\nStore URL: {order_info.store_url}")
if order_info.items:
link_item = order_info.items[0]
print(f"Order link for {link_item.name}: {link_item.order_link}")
# Point-lookup by a known item_id.
if first_summary is not None:
try:
looked_up = client.items.get(item_id=first_summary.item_id)
print(f"\nLooked up: {looked_up.name}")
except InputNotFound:
print("Item no longer on the menu.")
print("\nexercised: stores.get / item_summary.details / order_links.get / items.get")
Returns the complete menu catalogue of the store in one call: store details (address, coordinates, hours, open/orderable state, currency), the menus, and every category with its items (item_id, name, description, price as a decimal in the store currency, display price, image, availability, sold-out flag and whether the item has customization options). The whole catalogue is returned in a single response with no pagination; item_count and category_count are the counts of what is returned. Pass items[*].item_id to get_menu_item to read customization options. dining_mode selects the ordering mode the store page is loaded in: it changes the mode-specific store fields (delivery_eta, closed_message such as 'Delivery unavailable', is_orderable) while the catalogue itself was observed identical for both modes.
| Param | Type | Description |
|---|---|---|
| store_path | string | Store page path on order.store in the form <country>/store/<slug>/<store-key>. Omit to read the Slice of Fire Pizza store. |
| dining_mode | string | Ordering mode used when loading the store page; affects delivery_eta, closed_message and is_orderable. |
{
"type": "object",
"fields": {
"hours": "array of {day_range, section_hours[{start, end, section_title}]}; start/end are minutes after midnight local store time",
"menus": "array of {menu_id, name, hours} for each menu the store publishes",
"address": "full street address of the store",
"is_open": "whether the store is currently open (boolean)",
"cuisines": "array of cuisine labels",
"currency": "ISO currency code all prices are in (e.g. CAD)",
"latitude": "store latitude (number)",
"store_id": "store UUID used by the site",
"longitude": "store longitude (number)",
"categories": "array of {category_id, menu_id, name, description, item_count, items[]}; each item is {item_id, name, description, price (decimal number or null), price_display, image_url, is_available, is_sold_out, has_customizations, section_id, subsection_id}",
"item_count": "total number of item rows returned across categories (an item may appear in more than one category)",
"store_name": "store display name",
"delivery_eta": "site-displayed time range text for the selected dining_mode, or null",
"is_orderable": "whether the store currently accepts orders in the selected dining_mode (boolean)",
"price_bucket": "site price-level indicator such as $",
"category_count": "number of categories returned",
"closed_message": "site message when ordering in the selected mode is unavailable (e.g. 'Delivery unavailable'), empty string otherwise"
},
"sample": {
"data": {
"hours": [
{
"day_range": "Sunday",
"section_hours": [
{
"end": 1170,
"start": 660,
"section_title": ""
}
]
},
{
"day_range": "Monday",
"section_hours": []
},
{
"day_range": "Tuesday - Saturday",
"section_hours": [
{
"end": 1200,
"start": 660,
"section_title": ""
}
]
}
],
"menus": [
{
"name": "Slice of Fire Menu",
"hours": "11:00 a.m. – 8:00 p.m.",
"menu_id": "a4f74af0-88a6-4111-88b6-bbe905aec28b"
}
],
"address": "123 Main St, Springfield, IL 62704",
"is_open": true,
"cuisines": [
"Pizza",
"American",
"Italian"
],
"currency": "CAD",
"latitude": 43.8765149,
"store_id": "a0deb4a2-b3e7-459d-9429-0d5924172461",
"longitude": -79.2605762,
"categories": [
{
"name": "Starters",
"items": [
{
"name": "Mozzarella Sticks 🧀🧀🧀",
"price": 19.99,
"item_id": "03f36b94-329e-4d73-9aaf-bb085550c4c0",
"image_url": "https://tb-static.uber.com/prod/image-proc/processed_images/453a29c1d928d236ac470144e7ccb2f9/b4facf495c22df52f3ca635379ebe613.jpeg",
"section_id": "a4f74af0-88a6-4111-88b6-bbe905aec28b",
"description": "Our real mozzarella sticks are dipped in a delicate, crispy breading for the ultimate cheesy indulgence. 10 pieces. Served with creamy garlic and marinara (1.5oz) on the side.",
"is_sold_out": false,
"is_available": true,
"price_display": "$19.99",
"subsection_id": "c83e5673-da13-41a9-a2cc-494ac273c849",
"has_customizations": true
}
],
"menu_id": "a4f74af0-88a6-4111-88b6-bbe905aec28b",
"item_count": 6,
"category_id": "c83e5673-da13-41a9-a2cc-494ac273c849",
"description": null
}
],
"item_count": 98,
"store_name": "Slice of Fire Pizza",
"delivery_eta": "11–21 Min",
"is_orderable": true,
"price_bucket": "$",
"category_count": 9,
"closed_message": ""
},
"status": "success"
}
}About the order API
Menu Catalogue
get_menu accepts a store_path parameter in the form <country>/store/<slug>/<store-key> and an optional dining_mode (PICKUP or DELIVERY). It returns a single response containing store metadata — address, latitude, longitude, currency (ISO code, e.g. CAD), is_open, and cuisines — alongside a menus array and a categories array. Each category carries a category_id, menu_id, name, description, item_count, and a full items array. Each item exposes item_id, name, description, price as a decimal number, a formatted display price, image_url, and availability flags. The hours field is an array of objects keyed by day_range, with per-section start/end values expressed as minutes after midnight in the store's local time.
Per-Item Customizations
get_menu_item takes a required item_id (a UUID from get_menu categories) and an optional store_path. It returns the item's base price, is_sold_out flag, section_id, and subsection_id, plus a customizations array. Each customization group includes customization_id, name, min_permitted, max_permitted, and an options array. Each option carries option_id, name, price (add-on cost as a decimal), min_permitted, max_permitted, default_quantity, a sold-out flag, and optionally nested child customization groups — letting you represent modifier trees of arbitrary depth.
Shareable Order Links
get_order_link accepts a comma-separated list of up to 50 item_ids, an optional store_path, and an optional dining_mode. It returns an items array where each entry includes item_id, name, price, is_sold_out, and an order_link URL that opens the store page with that specific item pre-selected. The response also includes store_url, store_name, store_id, address, currency, and item_count. Note that order.store cart state is per-visitor session, so the links open an item selector rather than a pre-filled checkout.
The order API is a managed, monitored endpoint for order.store — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when order.store changes and a check fails, the API is automatically queued for repair and re-verified. It is built to keep working as the site underneath it changes.
This isn't an official order.store API — it's an independent, maintained REST wrapper over public data. Where the source has no official API (or only a limited one), Parse gives you a stable contract over a source that never promised one, and keeps it current. Need a new endpoint or field? You can revise it yourself in plain English and the agent rebuilds it against the live site in minutes — contributing the change back to the shared API is free.
Will this API break when the source site changes?+
Is this an official API from the source site?+
Can I fix or extend this API myself if I need a new endpoint or field?+
What happens if I call an endpoint that has an issue?+
- Aggregate menus from multiple order.store restaurants into a food discovery app using
get_menustore metadata and category data - Display live item availability and pricing on a third-party ordering UI by polling
get_menuforis_sold_outandpricefields - Build a customization configurator for a pizza ordering workflow by walking the nested
customizationstree fromget_menu_item - Generate affiliate or referral deep links to specific menu items using
get_order_linkwith pre-selecteddining_mode - Sync a restaurant's menu into a POS or CMS by extracting
item_id,name,description,price, andimage_urlfromget_menu - Monitor store operating hours and open/orderable state across dining modes by comparing
is_openandhoursfields fromget_menu - Validate that add-on pricing and option availability are consistent across menu updates by diffing
get_menu_itemcustomization responses over time
| Tier | Price | Credits/month | Rate limit |
|---|---|---|---|
| Free | $0/mo | 200 | 5 req/min |
| Hobby | $30/mo | 1,000 | 20 req/min |
| Developer | $100/mo | 5,000 | 100 req/min |
| Team | $300/mo | 20,000 | 300 req/min |
| Company | $1,000/mo | 100,000 | 500 req/min |
Each endpoint has a fixed posted price per successful call — most fall between 1 and 10 credits — shown on this API's page before you run it. Exceeding the rate limit returns a 429 response. Authenticate with the X-API-Key header.
Does order.store have an official developer API?+
What does `get_menu_item` return beyond what `get_menu` already provides?+
get_menu returns a flat item list with basic fields: item_id, name, description, price, and availability. get_menu_item returns the full customization tree — nested groups with min_permitted/max_permitted selection rules, per-option add-on prices, default quantities, sold-out flags at the option level, and child customization groups — which get_menu does not include.Can I retrieve order history, customer reviews, or past transaction data through this API?+
Does `dining_mode` affect the data returned by `get_menu`?+
dining_mode to PICKUP or DELIVERY influences the is_orderable flag, any closed_message text, and delivery_eta where applicable. It does not change the item catalogue, prices, or customization options — those are the same regardless of dining mode.Can this API read menus for stores other than Slice of Fire Pizza?+
store_path parameter in the form <country>/store/<slug>/<store-key>. Pass the path for any store on order.store to retrieve its menu, items, or order links. Omitting store_path defaults to the Slice of Fire Pizza (Markham, ON) store.