# Doordash Store Menu Scraper (`stealth_mode/doordash-store-menu-scraper`) Actor

Scrape complete store menus from DoorDash with menu item details, pricing, ratings, dietary info, and images. Perfect for restaurant analytics, menu monitoring, and competitive pricing research across any DoorDash location.

- **URL**: https://apify.com/stealth\_mode/doordash-store-menu-scraper.md
- **Developed by:** [Stealth mode](https://apify.com/stealth_mode) (community)
- **Categories:** Automation, Developer tools, E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use 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

## DoorDash Store Menu Scraper: Extract Restaurant Item Data at Scale

---

### What Is DoorDash?

DoorDash is a leading food delivery platform connecting millions of customers to thousands of restaurants and merchants. Each store page displays a dynamic menu with item descriptions, pricing, photos, dietary tags, ratings, and promotions. Extracting this menu data manually is inefficient — the **DoorDash Store Menu Scraper** automates the process, capturing complete menu inventories in structured, analysis-ready format.

---

### Overview

The **DoorDash Store Menu Scraper** collects detailed menu item records from individual DoorDash restaurant pages, turning rich product catalogs into clean CSV or JSON datasets. It is ideal for:

- **Restaurant chains** tracking competitor menus and pricing strategies
- **Market researchers** analyzing food delivery market trends and offerings
- **Data analysts** building datasets for menu optimization studies
- **Price monitoring services** benchmarking costs across locations
- **Aggregator platforms** syncing DoorDash menus into custom apps

The scraper captures 18+ fields per item, including pricing, images, dietary information, ratings, and promotional callouts. It supports multi-URL batch operations with configurable item limits and graceful error handling.

---

### Input Format

The scraper accepts a JSON configuration object with three key parameters:

```json
{
  "urls": [
    "https://www.doordash.com/store/burger-king-miami-75293/44070358/"
  ],
  "ignore_url_failures": true,
  "max_items_per_url": 200
}
````

| Parameter | Type | Description |
|---|---|---|
| `urls` | Array of strings | Direct links to DoorDash store/restaurant pages. Each URL should point to a specific store location (e.g., Burger King Miami). |
| `ignore_url_failures` | Boolean | If `true`, the scraper continues if some URLs fail. If `false`, the run stops on first error. Default: `true`. |
| `max_items_per_url` | Integer | Maximum menu items to extract per store URL. Set to `200` for large menus; lower values speed up smaller stores. |

> **Pro tip:** Store-specific URLs (with store ID and location code) give more accurate results than generic restaurant pages. Copy the full URL from your browser address bar.

***

### Output Format

**Example output record:**

```json
{
  "id": "19272161236",
  "name": "Original Chicken Sandwich",
  "description": "Lightly breaded chicken topped with crisp lettuce and creamy mayonnaise on a sesame seed bun.",
  "display_price": "$$6.29",
  "display_strikethrough_price": "",
  "logging": {
    "fields_map": [
      [
        "card_position",
        {
          "null_value": 0,
          "number_value": 0,
          "string_value": "",
          "bool_value": false
        }
      ],
      [
        "category_id",
        {
          "null_value": 0,
          "number_value": 0,
          "string_value": "154646305",
          "bool_value": false
        }
      ],
      [
        "container",
        {
          "null_value": 0,
          "number_value": 0,
          "string_value": "popular-items",
          "bool_value": false
        }
      ],
      [
        "container_name",
        {
          "null_value": 0,
          "number_value": 0,
          "string_value": "Most Ordered",
          "bool_value": false
        }
      ],
      [
        "eligible_promo_campaign_ids",
        {
          "null_value": 0,
          "number_value": 0,
          "string_value": "",
          "bool_value": false
        }
      ],
      [
        "entity_type",
        {
          "null_value": 0,
          "number_value": 0,
          "string_value": "item",
          "bool_value": false
        }
      ],
      [
        "has_photo",
        {
          "null_value": 0,
          "number_value": 0,
          "string_value": "",
          "bool_value": true
        }
      ],
      [
        "item_id",
        {
          "null_value": 0,
          "number_value": 0,
          "string_value": "19272161236",
          "bool_value": false
        }
      ],
      [
        "item_name",
        {
          "null_value": 0,
          "number_value": 0,
          "string_value": "Original Chicken Sandwich",
          "bool_value": false
        }
      ],
      [
        "menu_id",
        {
          "null_value": 0,
          "number_value": 0,
          "string_value": "44070358",
          "bool_value": false
        }
      ],
      [
        "menu_item_callout_string",
        {
          "null_value": 0,
          "number_value": 0,
          "string_value": "100+ recent orders",
          "bool_value": false
        }
      ],
      [
        "page",
        {
          "null_value": 0,
          "number_value": 0,
          "string_value": "store",
          "bool_value": false
        }
      ],
      [
        "store_id",
        {
          "null_value": 0,
          "number_value": 0,
          "string_value": "75293",
          "bool_value": false
        }
      ]
    ]
  },
  "image_url": "https://img.cdn4dd.com/cdn-cgi/image/fit=contain,width=1200,height=672,format=auto/https://doordash-static.s3.amazonaws.com/media/photosV2/2ab1814c-fac6-4ea1-b80a-1f6f0ae17e17-retina-large.png",
  "dietary_tags_list": [],
  "dynamic_label_display_string": "",
  "callout_display_string": "100+ recent orders",
  "secondary_callout": {
    "__typename": "MenuPageItemSecondaryCallout",
    "logo": "UNKNOWN",
    "text": null
  },
  "quick_add_context": {
    "__typename": "QuickAddContext",
    "is_eligible": false,
    "price": {
      "__typename": "QuickAddMonetaryFields",
      "currency": "USD",
      "decimal_places": 2,
      "display_string": "$$6.29",
      "sign": true,
      "symbol": "$$",
      "unit_amount": 629
    },
    "nested_options": "[]",
    "special_instructions": null,
    "default_quantity": null
  },
  "rating_display_string": "84% (25)",
  "serving_size_display_string": null,
  "store_id": "75293",
  "override_navigate_url": null,
  "badges": [],
  "min_lead_time": null,
  "category": "Most Ordered",
  "from_url": "https://www.doordash.com/store/burger-king-miami-75293/44070358/"
}
```

Each menu item returns a comprehensive record with the following fields:

#### Core Item Information

| Field | Description |
|---|---|
| `ID` | Unique identifier for this menu item within DoorDash |
| `Name` | Display name of the item (e.g., "Whopper") |
| `Description` | Full text description of the dish, ingredients, and preparation |
| `Category` | Menu category classification (e.g., "Sandwiches", "Breakfast", "Desserts") |

#### Pricing

| Field | Description |
|---|---|
| `Display Price` | Current item price shown to customers |
| `Display Strikethrough Price` | Original or sale price (shows discounts when present) |

#### Visuals & Media

| Field | Description |
|---|---|
| `Image URL` | Direct link to the item's product photo |

#### Dietary & Nutritional Info

| Field | Description |
|---|---|
| `Dietary Tags List` | Array of dietary classifications (e.g., "vegetarian", "vegan", "gluten-free", "contains nuts") |
| `Serving Size Display String` | Portion size information (e.g., "1 sandwich", "150g serving") |

#### Ratings & Social Proof

| Field | Description |
|---|---|
| `Rating Display String` | Customer rating display (e.g., "4.8★ (156 reviews)") |

#### Promotional Elements

| Field | Description |
|---|---|
| `Callout Display String` | Primary promotional badge or highlight (e.g., "Best Seller", "New", "Limited Time") |
| `Secondary Callout` | Secondary promotion or flag (e.g., "Combo Available") |

#### Context & References

| Field | Description |
|---|---|
| `Store ID` | Unique identifier for the restaurant/store this item belongs to |
| `Override Navigate URL` | Custom navigation URL for the item (if applicable) |
| `Logging` | Internal tracking/logging data used by DoorDash |
| `Dynamic Label Display String` | Dynamic labels or special markers (e.g., "Dairy-Free Option Available") |
| `Quick Add Context` | Metadata used for quick-add functionality |
| `Min Lead Time` | Minimum preparation/delivery time for this item in minutes |
| `Badges` | Array of item badges (e.g., "Popular", "Healthy", "Spicy") |

***

### How to Use

1. **Locate store URLs** — Visit DoorDash, find the restaurant(s) you want to monitor, and copy the store page URL from your browser's address bar.
2. **Prepare your input** — Create a JSON config file with `urls`, `ignore_url_failures`, and `max_items_per_url`. Paste multiple store URLs if monitoring a chain across locations.
3. **Configure item limits** — Set `max_items_per_url` based on menu size. A typical restaurant menu has 50–150 items; use `200` for large menus or `50` for quick sampling.
4. **Run the scraper** — Execute the actor and monitor progress. The scraper fetches each store and collects menu data.
5. **Download results** — Export as CSV, JSON, or Excel. Results include all 18+ fields per item.

**Best practices:**

- Use `ignore_url_failures: true` when scraping multiple locations to prevent partial failures from stopping the entire run.
- Lower `max_items_per_url` on test runs to understand menu structure before full extraction.
- Store URLs include location codes (e.g., `44070358`) — use exact URLs for accuracy rather than generic restaurant pages.

***

### Use Cases & Business Applications

- **Competitive monitoring:** Track competitor pricing and menu changes weekly or monthly
- **Menu analytics:** Identify top-rated items, dietary trends, and category performance
- **Price benchmarking:** Compare similar items across restaurant chains in your market
- **Supply chain optimization:** Understand what menu items are most demanded by geography
- **Market research:** Build datasets for studying food delivery trends and consumer preferences

By automating menu extraction, you reduce manual data collection from hours to minutes and maintain fresh, accurate competitive intelligence.

***

### Conclusion

The **DoorDash Store Menu Scraper** provides a fast, reliable way to capture detailed menu and pricing data from any DoorDash restaurant listing. Whether you're monitoring competitors, conducting market research, or building a menu aggregation platform, this scraper delivers structured, analysis-ready data in a single run. Extract menus at scale and unlock insights hidden in plain sight.

# Actor input Schema

## `urls` (type: `array`):

Add the URLs of the store urls you want to scrape. You can paste URLs one by one, or use the Bulk edit section to add a prepared list.

## `ignore_url_failures` (type: `boolean`):

If true, the scraper will continue running even if some URLs fail to be scraped.

## `max_items_per_url` (type: `integer`):

The maximum number of items to scrape per URL.

## Actor input object example

```json
{
  "urls": [
    "https://www.doordash.com/store/burger-king-miami-75293/44070358/"
  ],
  "ignore_url_failures": true,
  "max_items_per_url": 20
}
```

# 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 = {
    "urls": [
        "https://www.doordash.com/store/burger-king-miami-75293/44070358/"
    ],
    "ignore_url_failures": true,
    "max_items_per_url": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("stealth_mode/doordash-store-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 = {
    "urls": ["https://www.doordash.com/store/burger-king-miami-75293/44070358/"],
    "ignore_url_failures": True,
    "max_items_per_url": 20,
}

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

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

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

```

## CLI example

```bash
echo '{
  "urls": [
    "https://www.doordash.com/store/burger-king-miami-75293/44070358/"
  ],
  "ignore_url_failures": true,
  "max_items_per_url": 20
}' |
apify call stealth_mode/doordash-store-menu-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=stealth_mode/doordash-store-menu-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Doordash Store Menu Scraper",
        "description": "Scrape complete store menus from DoorDash with menu item details, pricing, ratings, dietary info, and images. Perfect for restaurant analytics, menu monitoring, and competitive pricing research across any DoorDash location.",
        "version": "0.0",
        "x-build-id": "ru3zb9nbko3q5ejmb"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/stealth_mode~doordash-store-menu-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-stealth_mode-doordash-store-menu-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/stealth_mode~doordash-store-menu-scraper/runs": {
            "post": {
                "operationId": "runs-sync-stealth_mode-doordash-store-menu-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/stealth_mode~doordash-store-menu-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-stealth_mode-doordash-store-menu-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "urls": {
                        "title": "URLs of the store urls to scrape",
                        "type": "array",
                        "description": "Add the URLs of the store urls you want to scrape. You can paste URLs one by one, or use the Bulk edit section to add a prepared list.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "ignore_url_failures": {
                        "title": "Continue running even if some URLs fail to be scraped",
                        "type": "boolean",
                        "description": "If true, the scraper will continue running even if some URLs fail to be scraped."
                    },
                    "max_items_per_url": {
                        "title": "Max items per URL",
                        "type": "integer",
                        "description": "The maximum number of items to scrape per URL."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
