# DoorDash Restaurant Menu & Prices Scraper (`scrapers_lat/doordash-menu-scraper`) Actor

Scrape DoorDash restaurants by store URL or city: name, address, geo, cuisines, price range, rating and the full menu with item names, descriptions and prices. Export to JSON, CSV or Excel.

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

## Pricing

from $10.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 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

[![DoorDash Restaurant Menu & Prices Scraper](https://scrapers.lat/banners/doordash-menu-scraper.png)](https://console.apify.com/actors/zfddPFi4iYeM8u6f4/input)

## DoorDash Restaurant Menu & Prices Scraper

Here is one real result, with every field the actor returns:

```json
{
  "storeName": "Balthazar Restaurant",
  "storeUrl": "https://www.doordash.com/store/balthazar-restaurant-new-york-45822/",
  "storeId": "45822",
  "cuisines": ["French", "Burgers", "Steak", "Chicken", "Dinner", "Lunch", "Sandwich", "Salads", "Appetizers", "Opens daily"],
  "priceRange": "$$$",
  "ratingValue": 4.6,
  "ratingCount": 50,
  "reviewCount": 50,
  "streetAddress": "80 Spring Street",
  "city": "New York",
  "region": "NY",
  "country": "US",
  "latitude": 40.722693,
  "longitude": -73.998285,
  "imageUrls": ["https://img.cdn4dd.com/cdn-cgi/image/fit=contain,width=1200,height=672,format=auto/https://doordash-static.s3.amazonaws.com/media/restaurant/cover/BalthazarRestaurant.png"],
  "reviewsSample": [
    { "author": "Katherine K", "rating": 4, "body": "I loved the Beef Stroganoff but was expecting a lot more meat especially one large piece was just cartilage. The quality was great and flavor was excellent but would not order again because of the portion size" }
  ],
  "menuSectionCount": 8,
  "menuItemCount": 91,
  "menu": [
    {
      "section": "Most Ordered",
      "items": [
        { "name": "Balthazar Cheeseburger", "description": "Classic bistro cheeseburger, cooked to your liking, with your choice of Cheddar or Gruyere cheese. Served with lettuce, tomato, and red onion on a sesame bun. Comes with a side of our pommes frites, which are fried in peanut oil.", "price": "$32.00", "priceUsd": 32 },
        { "name": "Steak Frites", "description": "10 oz Ribeye grilled to your liking and served with Maitre D' butter and pommes frites.", "price": "$49.00", "priceUsd": 49 },
        { "name": "NY Strip Steak \"Au Poivre\"", "description": "12 oz Striploin, cooked to your liking, coated in freshly crushed black pepper, sauteed and flamed with cognac and finished with a touch of cream. Served with pommes frites and sauteed spinach.", "price": "$63.00", "priceUsd": 63 }
      ]
    },
    {
      "section": "Amuse Bouche",
      "items": [
        { "name": "Croquette (5 ea)", "description": null, "price": "$16.00", "priceUsd": 16 },
        { "name": "Gougeres (6 ea)", "description": null, "price": "$16.00", "priceUsd": 16 }
      ]
    }
  ],
  "aiMenuSummary": null,
  "aiCuisineTags": null,
  "aiPopularDishes": null,
  "aiPriceTier": null,
  "aiDietaryTags": null,
  "searchLocation": null,
  "source": "DoorDash",
  "observedAt": "2026-08-15T03:30:55.956Z",
  "error": null
}
```

The most complete DoorDash menu scraper available. It returns every field a DoorDash store page exposes (name, address, geo, cuisines, price range, rating, review sample) plus the full menu with each item's name, description and price, and gives you six filters to target exactly the restaurants and dishes you need.

**📥 [Input](https://console.apify.com/actors/zfddPFi4iYeM8u6f4/input-schema) · 📤 [Output](https://console.apify.com/actors/zfddPFi4iYeM8u6f4/output-schema) · 💰 [Pricing](https://console.apify.com/actors/zfddPFi4iYeM8u6f4/information/latest/pricing) · ▶️ [Examples](https://console.apify.com/actors/zfddPFi4iYeM8u6f4/runs)**

![Platform](https://img.shields.io/badge/platform-Apify-2296F3) ![Coverage](https://img.shields.io/badge/coverage-DoorDash%20US-EB1700) ![Output](https://img.shields.io/badge/output-JSON%20%7C%20CSV%20%7C%20Excel-brightgreen) ![Billing](https://img.shields.io/badge/billing-pay%20per%20result-blue)

### Table of contents

- [What it does](#what-it-does)
- [Quickstart](#quickstart)
- [Input reference](#input-reference)
- [Output reference](#output-reference)
- [Example output record](#example-output-record)
- [Run via API and CLI](#run-via-api-and-cli)
- [Fetch results](#fetch-results)
- [Billing and limits](#billing-and-limits)
- [FAQ and troubleshooting](#faq-and-troubleshooting)
- [More scrapers at scrapers.lat](#more-scrapers-at-scraperslat)

### What it does

Give it DoorDash store URLs or a list of cities, and it returns each restaurant with its full menu and prices. For every store you get the name, street address, latitude and longitude, cuisines and categories, price range, star rating, a sample of customer reviews, and the complete menu broken into sections with every item's name, description and price (both the raw string and a numeric `priceUsd`).

Filters let you narrow by cuisine, by keyword (across store names and menu items), and by item price range. Optional AI add-ons write a short menu summary and classify the menu into cuisine tags, likely signature dishes, a price tier and dietary tags.

### Quickstart

Scrape specific restaurants, plus discover more from a city:

```json
{
  "storeUrls": ["https://www.doordash.com/store/balthazar-restaurant-new-york-45822/"],
  "locations": ["Austin, TX"],
  "maxStores": 10,
  "withMenu": true
}
```

### Input reference

| Name | Type | Required | Description | Example |
|------|------|----------|-------------|---------|
| `storeUrls` | array | one of storeUrls/locations | DoorDash store page URLs to scrape directly | `["https://www.doordash.com/store/balthazar-restaurant-new-york-45822/"]` |
| `locations` | array | one of storeUrls/locations | Cities to discover restaurants in | `["New York, NY", "Austin, TX"]` |
| `maxStores` | integer | no | Max restaurants per run (free accounts capped at 10) | `10` |
| `cuisine` | string | no | Keep only restaurants whose cuisine list contains this term | `"Pizza"` |
| `keyword` | string | no | Keep only restaurants whose name or any menu item matches | `"burger"` |
| `minItemPrice` | integer | no | Drop menu items priced below this amount (USD) | `10` |
| `maxItemPrice` | integer | no | Drop menu items priced above this amount (USD) | `40` |
| `withMenu` | boolean | no | Attach the full menu to each record (default true) | `true` |
| `withAiMenuSummary` | boolean | no | AI menu summary add-on (paid plans only, default false) | `false` |
| `withAiCategorize` | boolean | no | AI cuisine/dish/dietary tagging add-on (paid plans only, default false) | `false` |

### Output reference

| Name | Type | Description |
|------|------|-------------|
| `storeName` | string | Restaurant name |
| `storeUrl` | string | DoorDash store page URL |
| `storeId` | string | DoorDash numeric store identifier |
| `cuisines` | array | Cuisine and category tags served |
| `priceRange` | string | Price range indicator, e.g. `$$` or `$$$` |
| `ratingValue` | number | Average rating out of 5 |
| `ratingCount` | number | Number of ratings |
| `reviewCount` | number | Number of reviews |
| `streetAddress` | string | Street address |
| `city` | string | City / locality |
| `region` | string | State / region |
| `country` | string | Country code |
| `latitude` | number | Latitude |
| `longitude` | number | Longitude |
| `imageUrls` | array | Cover / header image URLs |
| `reviewsSample` | array | Sample reviews: `author`, `rating`, `body` |
| `menuSectionCount` | integer | Number of menu sections |
| `menuItemCount` | integer | Total number of menu items |
| `menu` | array | Sections, each with `items` (`name`, `description`, `price`, `priceUsd`) |
| `aiMenuSummary` | string | AI summary of the restaurant and menu (paid add-on) |
| `aiCuisineTags` | array | AI cuisine / style tags (paid add-on) |
| `aiPopularDishes` | array | AI likely signature dishes (paid add-on) |
| `aiPriceTier` | string | AI price tier: budget / mid / premium (paid add-on) |
| `aiDietaryTags` | array | AI dietary tags present on the menu (paid add-on) |
| `searchLocation` | string | City input this store was discovered from, if any |
| `source` | string | Data source (DoorDash) |
| `observedAt` | string | ISO timestamp when scraped |
| `error` | string | Error message for a failed record, if any |

### Example output record

See the hero record at the top of this page for a complete, real record with every field populated.

### Run via API and CLI

Start a run with the API:

```bash
curl -X POST "https://api.apify.com/v2/acts/scrapers_lat~doordash-menu-scraper/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{ "locations": ["Austin, TX"], "maxStores": 10 }'
```

Or with the Apify CLI:

```bash
apify call scrapers_lat/doordash-menu-scraper \
  --input '{ "storeUrls": ["https://www.doordash.com/store/balthazar-restaurant-new-york-45822/"] }'
```

### Fetch results

```bash
curl "https://api.apify.com/v2/datasets/DATASET_ID/items?token=YOUR_TOKEN&format=json"
```

Replace `DATASET_ID` with the `defaultDatasetId` from the run. Add `&format=csv` or `&format=xlsx` for other formats.

### Billing and limits

This actor uses pay per result. You are charged per event:

| Event | Price (USD) | When |
|-------|-------------|------|
| `result` | 0.010 | Per restaurant record returned |
| `menu` | 0.012 | When a full menu is captured for that restaurant |
| `ai_menu_summary` | 0.012 | Only when the AI summary add-on returns usable output |
| `ai_categorize` | 0.012 | Only when the AI categorization add-on returns usable output |

- Free Apify accounts are capped at 10 restaurants per run; AI add-ons are disabled on free accounts.
- No charge on failure: records that error out are never billed.
- The spend cap you set as `maxTotalChargeUsd` is respected; the actor stops emitting billable results once it is reached.

### FAQ and troubleshooting

**Do I need a DoorDash account or API key?** No. Provide store URLs or cities and run.

**How do I get a store URL?** Open the restaurant on doordash.com and copy the `/store/...` URL, or just pass a city and let the actor discover restaurants for it.

**Why do some restaurants show 91 items?** DoorDash renders a large sample of the menu per store page; very large menus can be truncated by DoorDash to their most relevant items.

**Are live delivery fees and per-item modifiers included?** No. Those are loaded dynamically per user session and are not part of the stable public store data. This actor focuses on the complete, reliable menu with item names, descriptions and prices.

**Which countries?** DoorDash US store pages and city listings.

### More scrapers at scrapers.lat

Browse the full catalog of company, e-commerce, real estate and marketplace scrapers at [scrapers.lat](https://scrapers.lat).

# Actor input Schema

## `storeUrls` (type: `array`):

DoorDash store page URLs to scrape directly, e.g. https://www.doordash.com/store/balthazar-restaurant-new-york-45822/ . Use this to target exact restaurants.

## `locations` (type: `array`):

Cities to discover restaurants in, e.g. "New York, NY", "Austin, TX", "Chicago, IL". Each city page is read to find its restaurant store URLs.

## `maxStores` (type: `integer`):

Maximum number of restaurants to collect across the whole run. Free Apify accounts are capped at 10.

## `cuisine` (type: `string`):

Optional. Only keep restaurants whose cuisine list contains this term, e.g. Pizza, Sushi, Mexican, Vegan.

## `keyword` (type: `string`):

Optional. Only keep restaurants whose name or any menu item name/description contains this keyword, e.g. burger, ramen, gluten free.

## `minItemPrice` (type: `integer`):

Optional. Drop menu items priced below this amount.

## `maxItemPrice` (type: `integer`):

Optional. Drop menu items priced above this amount.

## `withMenu` (type: `boolean`):

Attach the full menu (sections plus every item with name, description and price) to each restaurant. On by default.

## `withAiMenuSummary` (type: `boolean`):

Optional paid add-on, off by default and disabled for free accounts. Adds a short AI-written summary of the restaurant and its menu. Billed only when the AI returns usable output.

## `withAiCategorize` (type: `boolean`):

Optional paid add-on, off by default and disabled for free accounts. Adds AI cuisine tags, likely signature dishes, a price tier and dietary tags. Billed only when the AI returns usable output.

## Actor input object example

```json
{
  "storeUrls": [
    "https://www.doordash.com/store/balthazar-restaurant-new-york-45822/"
  ],
  "locations": [],
  "maxStores": 10,
  "withMenu": true,
  "withAiMenuSummary": false,
  "withAiCategorize": 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 = {
    "storeUrls": [
        "https://www.doordash.com/store/balthazar-restaurant-new-york-45822/"
    ],
    "locations": [],
    "maxStores": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapers_lat/doordash-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 = {
    "storeUrls": ["https://www.doordash.com/store/balthazar-restaurant-new-york-45822/"],
    "locations": [],
    "maxStores": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("scrapers_lat/doordash-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 '{
  "storeUrls": [
    "https://www.doordash.com/store/balthazar-restaurant-new-york-45822/"
  ],
  "locations": [],
  "maxStores": 10
}' |
apify call scrapers_lat/doordash-menu-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,scrapers_lat/doordash-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/zfddPFi4iYeM8u6f4/builds/DYO825BO6Sg7BtFLl/openapi.json