# Burger King Menu Scraper: Prices, Calories & Nutrition (`memo23/burger-king-menu-scraper`) Actor

Burger King menu data at store level. Give it a street address, ZIP code or store number and get roughly 177 products with prices, calories, macros, allergens, size ladders and add-on pricing. Batch any number of locations. Pure HTTP, no browser, no API key. JSON or CSV.

- **URL**: https://apify.com/memo23/burger-king-menu-scraper.md
- **Developed by:** [Muhamed Didovic](https://apify.com/memo23) (community)
- **Categories:** E-commerce, Lead generation
- **Stats:** 1 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.70 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Burger King Menu Scraper

<p align="center"><img src="https://raw.githubusercontent.com/muhamed-didovic/muhamed-didovic.github.io/main/assets/burgerking/logo.png" width="140" alt="Burger King Menu Scraper"></p>

**Paste a street address, get that Burger King's actual menu.** Prices as that restaurant charges them, calories and full macros, allergens, every size, and every customisation option with what it costs. Batch as many locations as you like in one run.

| Input | Rows emitted |
|---|---|
| `801 3rd Ave W, Birmingham, AL 35204` | ~177 products at the restaurant on that street |
| `35209` (ZIP) | ~177 products at the nearest restaurant in that ZIP |
| `Birmingham, AL` (city) | ~177 products at the nearest restaurant in that city |
| Store number `12427` | ~177 products at that exact store, menu only |

> Pure HTTP. No browser, no proxy, no API key, no login.

### How it works

<p align="center"><img src="https://raw.githubusercontent.com/muhamed-didovic/muhamed-didovic.github.io/main/assets/burgerking/how-it-works.png" alt="How the Burger King Menu Scraper works"></p>

Every location you supply is geocoded, matched to the closest Burger King, and that restaurant's own menu file is read directly. Street addresses go through the US Census geocoder, which is exact on house numbers; ZIP codes and city names fall back to Nominatim. Both are free and keyless, which is why this actor needs no credentials of any kind.

The prices you get back are the ones that restaurant charges, not a national menu. Two Burger Kings eight miles apart in Birmingham disagree on Hash Browns ($2.39 vs $2.29), Brewed Coffee ($1.99 vs $2.09) and Iced Coffee ($1.99 vs $2.19). A national menu would hide all of that.

### Input

| Field | Type | Required | Notes |
|---|---|---|---|
| `addresses` | array of strings | one of these two | Street addresses, ZIP codes or city names. Mix them freely. |
| `storeIds` | array of strings | one of these two | Burger King store numbers, e.g. `12427`. Skips geocoding. |
| `maxStoresPerAddress` | integer | no | Restaurants per location, nearest first. Default `1`. |
| `searchRadiusMiles` | integer | no | How far to look around each location. Default `25`. |
| `serviceMode` | string | no | `pickup` or `delivery` — which one fills `price`. Default `pickup`. |
| `includeNutrition` | boolean | no | Calories, macros and allergens. Default `true`. |
| `includeVariants` | boolean | no | Size ladder with per-size prices. Default `true`. |
| `includeModifiers` | boolean | no | Customisation groups and option prices. Default `true`. |
| `includeUnavailable` | boolean | no | Products the restaurant cannot currently sell. Default `false`. |
| `maxItems` | integer | no | Row cap. Default `5000` (about 28 restaurants). |
| `maxConcurrency` | integer | no | Parallel HTTP calls. Default `8`. |
| `proxy` | object | no | Optional. The actor runs direct by default. |

#### Example input

```json
{
  "addresses": [
    "801 3rd Ave W, Birmingham, AL 35204",
    "290 Oxmoor Road, Birmingham, AL 35209",
    "35233"
  ],
  "maxStoresPerAddress": 1,
  "serviceMode": "pickup",
  "includeNutrition": true,
  "maxItems": 5000
}
```

### Output schema

One row per orderable product per restaurant. A product that sits in two menu sections is still one row, carrying both section names.

```jsonc
{
  "type": "menu-item",

  "storeId": "12427",
  "storeName": "801 3rd Avenue W BIRMINGHAM, Alabama 35204-4606 - USA",
  "storeAddress": "801 3rd Avenue W",
  "storeCity": "BIRMINGHAM",
  "storeState": "Alabama",
  "storePostalCode": "35204-4606",
  "storeLatitude": 33.505114,
  "storeLongitude": -86.849528,
  "storePhone": "2052014508",
  "storeStatus": "Open",
  "hasDriveThru": true,
  "searchedAddress": "801 3rd Ave W, Birmingham, AL 35204",  // echoes your input

  "itemId": "picker_5520",
  "itemName": "Whopper",
  "itemType": "PICKER",                    // PICKER | ITEM | COMBO
  "sectionName": "Burgers for Breakfast",
  "sections": ["Burgers for Breakfast", "Flame Grilled Burgers"],
  "dayParts": ["Main Menu"],

  "price": 5.89,                           // the serviceMode you asked for
  "pickupPrice": 5.89,
  "deliveryPrice": 7.09,
  "currency": "USD",
  "isAvailable": true,

  "calories": 710,
  "caloriesMax": 2190,                     // with the largest combo configuration
  "nutrition": {
    "carbohydrates": 57, "cholesterol": 95, "fat": 42, "fiber": 4,
    "proteins": 34, "salt": 2.95, "saturatedFat": 12,
    "sodium": 1250, "sugar": 14, "transFat": 1, "weight": 288.418
  },
  "allergens": { "eggs": "_3", "sesame": "_3", "soy": "_3", "wheat": "_3" },

  "variants": [
    { "name": "Just the Sandwich - Entreé only", "pickupPrice": 5.89, "deliveryPrice": 7.09 },
    { "name": "Small - Side and Drink Included", "pickupPrice": 9.69 }
  ],
  "modifierGroups": [
    {
      "name": "American Cheese", "minChoices": 1, "maxChoices": 1,
      "options": [
        { "name": "No Cheese", "pickupPrice": 0 },
        { "name": "Regular Cheese", "pickupPrice": 0, "calories": 42 }
      ]
    }
  ],
  "comboItems": null,                      // slot names, on COMBO rows

  "imageUrl": "https://use1-prod-bk-menu.rbictg.com/api/v1/menu/image/us/image-1c9f…",
  "scrapedAt": "2026-09-03T04:25:06.337Z"
}
```

#### Field coverage

Measured across 354 rows from two Birmingham restaurants:

| Field | Coverage |
|---|---|
| `price`, `imageUrl`, store columns | 100% |
| `nutrition` (macros) | 98% |
| `calories` | 96% |
| `allergens` | 75% |
| `modifierGroups` | 73% |
| `variants` | 64% |

### Pricing

| Event | When it fires | Rate |
|---|---|---|
| Actor start | Once per run | $0.005 |
| Result | Per product row returned | $0.0007 |

A restaurant returns roughly 177 products, so one location runs about $0.13 and a sweep of 10 restaurants about $1.24. Nutrition, size variants and customisation options ride on each row at no extra charge, and a store that returns nothing costs nothing.

### What makes this richer than the competition

| Capability | Other Burger King actors | This actor |
|---|---|---|
| Search by street address | No — ZIP only | Yes, plus ZIP, city and store number |
| Batch many locations per run | No | Yes, mixed formats in one input |
| Prices specific to the restaurant | Unclear | Yes, proven to differ between stores |
| Macros and allergens | Partial | 98% and 75% of rows |
| Size ladder with per-size prices | No | Yes |
| Customisation options with prices | No | Yes, up to 18 groups per product |
| Pickup and delivery prices side by side | No | Yes |
| Row padding | Same product repeated per section | One row per product |

### Notes & limitations

- **United States only.** The store search and menu CDN this actor reads are the US region. Other Burger King markets sit behind separate endpoints.
- **Store numbers return the menu without the address.** Burger King exposes a restaurant's address only through its coordinate-based location search, so a row that came from `storeIds` has `storeAddress`, `storeCity` and coordinates set to `null`. Search by address when you need those columns.
- **Address matching is nearest-restaurant, not exact-match.** Paste the restaurant's own street address and you get that restaurant. Paste any other address and you get the closest Burger King to it, which is usually what you want but is worth knowing.
- **Spelling and abbreviations don't matter.** The address is turned into map coordinates before anything is matched, so "Road" vs "Rd", "West" vs "W" or "Third" vs "3rd" all resolve to the same restaurant — the actor never compares your text against Burger King's own formatting. `801 3rd Ave W`, `801 3rd Avenue West` and `801 THIRD AVENUE WEST` all return store #12427.
- **`caloriesMax` reflects the largest configuration**, not the default product. The Whopper's 710 default calories rise to 2190 as a large combo.
- **Unavailable products are excluded by default.** Turn on `includeUnavailable` to see products the restaurant has switched off; they come back with no price.

### 🤖 For AI Agents & LLM Apps

**Purpose.** Returns the current menu of a specific Burger King restaurant in the United States: per-store prices, calories, macros, allergens, sizes and customisation options.

**Minimal tested input.**

```json
{ "addresses": ["801 3rd Ave W, Birmingham, AL 35204"], "maxStoresPerAddress": 1 }
```

**Output fields (flat).** `type`, `storeId`, `storeNumber`, `storeName`, `storeAddress`, `storeCity`, `storeState`, `storePostalCode`, `storeCountry`, `storeLatitude`, `storeLongitude`, `storePhone`, `storeStatus`, `hasDriveThru`, `searchedAddress`, `itemId`, `itemName`, `itemType`, `sectionName`, `sections`, `description`, `dayParts`, `price`, `pickupPrice`, `deliveryPrice`, `currency`, `isAvailable`, `calories`, `caloriesMin`, `caloriesMax`, `nutrition`, `allergens`, `variants`, `modifierGroups`, `comboItems`, `imageUrl`, `scrapedAt`.

**Behaviour worth knowing.**

- One row per product per restaurant; roughly 177 rows per restaurant.
- `addresses` accepts street addresses, ZIP codes and city names in the same array.
- `searchedAddress` echoes the input string that produced the row, so batch results stay traceable to their query.
- Rows sourced from `storeIds` have null address columns.
- Prices are US dollars as numbers, never strings.
- No credentials, no proxy and no browser are required.

### ⚠️ Disclaimer

This actor collects publicly available menu information published by Burger King for its United States restaurants. It does not access private, personal or authenticated data, and it does not attempt to bypass any authentication. Menu content, prices, nutrition values and trademarks belong to their respective owners; Burger King® is a registered trademark of Burger King Company LLC, and this actor is not affiliated with, endorsed by or sponsored by Burger King or Restaurant Brands International. Prices and availability change frequently and by location — treat every row as a snapshot taken at `scrapedAt`, and verify anything you rely on for a purchase or a dietary decision against the restaurant directly. Nutrition and allergen values are reproduced as published and must not be treated as medical advice. You are responsible for using the output in line with applicable law and Burger King's terms.

### SEO Keywords

burger king menu scraper, burger king prices api, bk menu data, burger king nutrition scraper, fast food menu scraper, restaurant menu api, burger king calories data, menu price monitoring, fast food price tracking, burger king store locator api, restaurant price intelligence, whopper price by location, burger king allergen data, quick service restaurant data, menu item pricing dataset, food nutrition scraper, store level menu pricing, competitive menu analysis, burger king combo prices, us fast food data

# Actor input Schema

## `addresses` (type: `array`):

One US location per line. An exact street address returns the restaurant at that address; a ZIP code or city returns the nearest ones. Examples: '801 3rd Ave W, Birmingham, AL 35204', '35209', 'Birmingham, AL'.

## `storeIds` (type: `array`):

Store numbers, when you already know them (for example '12427'). These skip geocoding, so they are the fastest way to target a restaurant — but Burger King only exposes a store's address through its location search, so rows from a store number carry the menu without the address columns. Use the address field above when you need those.

## `maxStoresPerAddress` (type: `integer`):

How many restaurants to return for each location, nearest first. Leave at 1 when you paste exact street addresses and want that one restaurant; raise it to survey a whole area.

## `searchRadiusMiles` (type: `integer`):

How far from each location to look for a restaurant. Only used for addresses, not for store numbers.

## `serviceMode` (type: `string`):

Burger King charges different prices for pickup and delivery. This picks which one lands in the 'price' column; both are always returned in 'pickupPrice' and 'deliveryPrice'.

## `includeNutrition` (type: `boolean`):

Adds calories, carbohydrates, fat, protein, sodium, sugar, cholesterol and the allergen map to every row.

## `includeVariants` (type: `boolean`):

Adds the size ladder for products that have one — for example Value, Small, Medium and Large for a drink, each with its own price and calorie count.

## `includeModifiers` (type: `boolean`):

Adds the add-on groups a product accepts (dipping sauces, extra cheese, and so on) with the price of each option.

## `includeUnavailable` (type: `boolean`):

Emits products the restaurant currently cannot sell. These carry no price. Off by default so you are not charged for rows you cannot use.

## `maxItems` (type: `integer`):

Hard cap on dataset rows. A single restaurant yields roughly 300 products, so 5000 covers about 16 restaurants.

## `maxConcurrency` (type: `integer`):

How many HTTP calls run in parallel. The default suits most runs; lower it only if you hit rate limits.

## `proxy` (type: `object`):

Optional. Burger King's API answers from any IP, so this actor runs without a proxy by default. Supply one only if your network needs it.

## Actor input object example

```json
{
  "addresses": [
    "801 3rd Ave W, Birmingham, AL 35204",
    "345 Valley Avenue, Birmingham, AL 35209"
  ],
  "maxStoresPerAddress": 1,
  "searchRadiusMiles": 25,
  "serviceMode": "pickup",
  "includeNutrition": true,
  "includeVariants": true,
  "includeModifiers": true,
  "includeUnavailable": false,
  "maxItems": 5000,
  "maxConcurrency": 8,
  "proxy": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "addresses": [
        "801 3rd Ave W, Birmingham, AL 35204",
        "345 Valley Avenue, Birmingham, AL 35209"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("memo23/burger-king-menu-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "addresses": [
        "801 3rd Ave W, Birmingham, AL 35204",
        "345 Valley Avenue, Birmingham, AL 35209",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("memo23/burger-king-menu-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "addresses": [
    "801 3rd Ave W, Birmingham, AL 35204",
    "345 Valley Avenue, Birmingham, AL 35209"
  ]
}' |
apify call memo23/burger-king-menu-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,memo23/burger-king-menu-scraper"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/hRv3mlIgXkgrcXtDM/builds/p4fwdhK7jhEAqLgSn/openapi.json
