Givex APIbarburrito.givex.com ↗
Access BarBurrito Canada store locations, full online-ordering menus with prices in CAD, option groups, and delivery/pickup order quotes via 4 API endpoints.
What is the Givex API?
The BarBurrito API exposes 4 endpoints covering every Canadian BarBurrito location and its online-ordering data: store coordinates, hours, and service availability via list_locations; complete category-to-item menus with option groups via get_menu; per-item detail via get_item; and a full checkout-equivalent order quote — including taxes, delivery fee, and estimated ready time — via quote_order.
curl -X GET 'https://api.parse.bot/scraper/1f7429ce-7494-44af-aad5-ff746a295fcc/list_locations?order_type=pickup' \ -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 barburrito-givex-com-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: BarBurrito SDK — list stores, browse a menu, get item details, price an order."""
from parse_apis.barburrito_givex_com_api import BarBurrito, OrderType, QuoteOrderType, InputNotFound
client = BarBurrito()
# List pickup-enabled locations, capped at 5.
for loc in client.locations.list(order_type=OrderType.PICKUP, limit=5):
print(loc.name, loc.store_id, loc.city, loc.province)
# Drill into the first location's menu.
location = client.locations.list(order_type=OrderType.PICKUP, limit=1).first()
if location is not None:
print(f"\nStore: {location.name} ({location.store_id})")
print(f"Hours Mon: {location.hours.monday}")
# Fetch the pickup menu for this store.
menu = location.menu(order_type=OrderType.PICKUP)
print(f"Menu currency: {menu.currency}, total items: {menu.total_items}")
# Walk categories → subcategories → items to find the first priced item.
target_item = None
for cat in menu.categories:
for sub in cat.subcategories:
for item in sub.items:
if item.price > 0:
target_item = item
break
if target_item is not None:
break
if target_item is not None:
break
if target_item is not None:
print(f"\nItem: {target_item.name} — ${target_item.price:.2f} ({target_item.item_id})")
# Fetch full item details using the derived item_id.
store_item = location.get_item(item_id=target_item.item_id)
print(f"Detail: {store_item.item.name}, active={store_item.item.active}")
print(f"Order URL: {store_item.order_url}")
# Quote the item for pickup pricing.
try:
quote = location.quote(item_id=target_item.item_id, order_type=QuoteOrderType.PICKUP)
except InputNotFound:
print("Item not found for quoting.")
else:
print(f"Subtotal: ${quote.subtotal:.2f}, tax: ${quote.tax_total:.2f}, total: ${quote.total:.2f}")
for opt in quote.selected_options:
print(f" Option: {opt.name} (+${opt.price:.2f})")
print("\nexercised: locations.list / location.menu / location.get_item / location.quote")
Lists every BarBurrito location available for online ordering, one record per store, with address, coordinates, phone, weekly opening hours (as 'HH:MM - HH:MM' strings, null when closed), three booleans stating whether the store accepts pickup, delivery and dine-in orders, and direct_urls: for each order type the store supports, a one-click link into the ordering site that selects that store and order type for the visitor (pickup and dine-in land on the store's menu; delivery lands on the delivery-address step); null for order types the store does not offer. The ordering site keeps its cart only in the visitor's browser and has no link that adds an item to the cart; after opening a direct link, an item's order_url from get_menu opens that item's customize page where one further click adds it. Always fetches all stores in three fixed round trips (one per order type) and merges them; order_type only filters the merged list to stores supporting that type. Result ordering is alphabetical by store name. The list includes the operator's test location. Pagination is optional and applied locally over the full merged list: when neither page nor page_size is given the whole list is returned (page and page_size are null, has_more false); when either is given the list is sliced into pages (page defaults to 1, page_size to 50, values above 200 are clamped to 200) and has_more tells whether a later page exists. total_count is always the number of stores after the order_type filter; count is the number of records in this response. fields optionally restricts each record to a comma-separated subset of its keys (an unknown key returns stale_input listing the valid keys); omitted = full records.
| Param | Type | Description |
|---|---|---|
| page | integer | 1-based page number. Supplying page or page_size switches the response to paginated mode; omitting both returns the whole list. Defaults to 1 when only page_size is given. |
| fields | string | Comma-separated subset of record keys to return, e.g. store_id,name,address. Valid keys: store_id, name, address, city, province, country, postal_code, phone, latitude, longitude, hours, hours_comment, amenities, pickup_available, delivery_available, dinein_available, direct_urls. Omitted = all keys. |
| page_size | integer | Stores per page in paginated mode, 1 to 200 (larger values are clamped to 200). Defaults to 50 when only page is given. |
| order_type | string | Keep only stores that accept this order type. Omitted = all stores. |
{
"type": "object",
"fields": {
"page": "page number returned, null when not paginated",
"count": "integer number of store records in this response",
"has_more": "boolean, true when a later page exists (always false when not paginated)",
"locations": "array of store records (store_id, name, address, city, province, country, postal_code, phone, latitude, longitude, hours per weekday, hours_comment, amenities, pickup_available, delivery_available, dinein_available, direct_urls); restricted to the requested keys when fields is given",
"page_size": "page size applied, null when not paginated",
"order_type": "the filter applied, or null when none",
"total_count": "integer number of stores after the order_type filter, before pagination",
"locations[].direct_urls": "object keyed pickup/delivery/dinein -> one-click ordering-site link that pre-selects this store and order type, or null when the store does not offer that type"
},
"sample": {
"data": {
"page": null,
"count": 388,
"has_more": false,
"locations": [
{
"city": "Airdrie",
"name": "AB - Airdrie",
"hours": {
"friday": "10:00 - 22:00",
"monday": "10:00 - 22:00",
"sunday": "10:00 - 21:00",
"tuesday": "10:00 - 22:00",
"saturday": "10:00 - 22:00",
"thursday": "10:00 - 22:00",
"wednesday": "10:00 - 22:00"
},
"phone": "+1 (555) 012-3456",
"address": "331 Veterans Blvd NE",
"country": "CA",
"latitude": 51.29991,
"province": "AB",
"store_id": "166861",
"amenities": null,
"longitude": -114.00833,
"direct_urls": {
"dinein": null,
"pickup": "https://barburrito.givex.com/cws5/barburrito/#/direct?outlet_id=166861&order_type=pickup",
"delivery": "https://barburrito.givex.com/cws5/barburrito/#/direct?outlet_id=166861&order_type=delivery"
},
"postal_code": "T4B 3P3",
"hours_comment": null,
"dinein_available": false,
"pickup_available": true,
"delivery_available": true
}
],
"page_size": null,
"order_type": null,
"total_count": 388
},
"status": "success"
}
}About the Givex API
Location and Service Coverage
list_locations returns every BarBurrito store available for online ordering. Each record includes store_id, full address fields (address, city, province, postal_code), latitude/longitude, phone, and a full week of opening hours as HH:MM - HH:MM strings (or null when closed). Three booleans — pickup, delivery, dinein — indicate which order modes each store supports. The optional order_type parameter filters results to only stores that accept that mode. Each location also carries a direct_urls object with one-click ordering-site links pre-selecting that store and service type.
Menu Structure
get_menu returns the complete menu for a given store_id and order_type in one response. The categories array nests subcategories, and each subcategory holds items with item_id, name, sku, description, price in CAD, calories (when published), image_url, and option_groups. Option groups carry minimum and maximum selection counts, a required flag, and individual options each with their own option_id and price. total_items gives an integer count across the whole menu. menu_updated_at provides the site's menu revision timestamp.
Item Detail and Order Quoting
get_item fetches a single item by item_id and store_id, returning the same shape as menu items plus combo child items and both store_menu_url and order_url deep links for directing users straight to the ordering site. quote_order prices one item as a pickup or delivery order using the same calculation applied at checkout: subtotal, per-tax-code breakdown in taxes, tax_total, delivery_fee (null for pickup), total, and ready_time as a store-local timestamp. For delivery quotes, pass the optional address, city, province, and postal_code parameters; the is_delivery boolean in the response confirms the mode applied.
The Givex API is a managed, monitored endpoint for barburrito.givex.com — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when barburrito.givex.com 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 barburrito.givex.com 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?+
- Build a store finder that maps all BarBurrito locations with coordinates and filters by pickup or delivery availability.
- Display a full digital menu for any BarBurrito location, including option groups, prices in CAD, and calorie counts.
- Generate an accurate delivery cost estimate before redirecting a user to the ordering site, using the
quote_orderdelivery fee and tax breakdown. - Surface estimated ready times for pickup orders by calling
quote_orderwithorder_type=pickupand readingready_time. - Deep-link users directly to a specific item's customization page on the BarBurrito ordering site using
order_urlfromget_item. - Check which stores near a user are open for dine-in on a given day by reading the
dineinboolean and weekly hours fromlist_locations. - Sync a third-party delivery or loyalty app with current BarBurrito menu SKUs, prices, and option group structures using
get_menu.
| 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 BarBurrito have an official public developer API?+
What does `quote_order` actually return, and how does it differ from just reading the item price in `get_menu`?+
get_menu and get_item return the base item price in CAD. quote_order performs the full checkout calculation: it returns a subtotal, a taxes object broken down by tax code, a tax_total, delivery_fee (null for pickup orders), and the total payable. It also returns ready_time as a store-local estimated completion timestamp, which the menu endpoints do not include.Does the API cover historical order data or user account information?+
Are menus the same across all stores, or can they differ by location?+
get_menu takes a required store_id parameter, and the response includes a store_id field confirming which store the menu belongs to. Menus are fetched per store and may differ. menu_updated_at shows when that store's menu was last revised on the ordering site.