# DoorDash Restaurant Scraper (`crawlerbros/doordash-restaurant-scraper`) Actor

Extract restaurant info + complete menus from DoorDash store pages like name, address, cuisine, breadcrumbs, FAQ, and full menu sections with item names, descriptions, and prices.

- **URL**: https://apify.com/crawlerbros/doordash-restaurant-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Automation, Developer tools, E-commerce
- **Stats:** 4 total users, 1 monthly users, 100.0% runs succeeded, 20 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $5.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.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/platform/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 Restaurant Scraper

Extract restaurant info + complete menus from **DoorDash** store pages — restaurant name, address, city, cuisine breadcrumbs, FAQ, and full menu sections with item names, descriptions, and prices.

### Features

- **16 output fields** per restaurant — flat schema with typed defaults (zero nulls)
- **Complete menu extraction** — every section + item with name, description, and price
- **FAQ extraction** — questions and answers about the restaurant
- **Breadcrumb extraction** — cuisine type and neighborhood
- **Cloudflare bypass** via Patchright Chromium + RESIDENTIAL US proxy (typically clears in 2–15 seconds)
- **Hardcoded RESIDENTIAL US proxy** — required, applied automatically

### Input

| Field | Type | Description |
|---|---|---|
| `storeUrls` | Array | DoorDash store URLs (e.g., `https://www.doordash.com/store/15034`) |
| `maxItems` | Integer | Maximum restaurants to scrape (default 10, max 100) |

#### Example Input

```json
{
    "storeUrls": [
        "https://www.doordash.com/store/15034",
        "https://www.doordash.com/store/6422"
    ],
    "maxItems": 10
}
````

### Output

Each restaurant has **16 fields**. All fields are always present — empty strings, zero, or empty array as typed defaults, never `null`.

#### Identity

| Field | Type | Description |
|---|---|---|
| `storeId` | String | DoorDash store ID (from URL) |
| `storeName` | String | Restaurant name |
| `storeUrl` | String | Store page URL |
| `title` | String | Page title |
| `description` | String | Meta description |

#### Location

| Field | Type | Description |
|---|---|---|
| `address` | String | Street address |
| `city` | String | City |
| `state` | String | State / region code |

#### Categorization

| Field | Type | Description |
|---|---|---|
| `breadcrumbs` | Array | Page breadcrumb names (e.g., `["Home", "Boston", "Burgers", "UBURGER"]`) — last is restaurant, second-to-last is cuisine |

#### Menu

| Field | Type | Description |
|---|---|---|
| `menuSections` | Array | Section names (e.g., `["Salads", "Burgers", "Drinks"]`) |
| `menuSectionCount` | Integer | Number of menu sections |
| `menuItems` | Array | Flat list of items: `[{section, name, description, price}, ...]` |
| `menuItemCount` | Integer | Total items across all sections |

#### FAQ

| Field | Type | Description |
|---|---|---|
| `faq` | Array | List of `{question, answer}` pairs from the FAQ section |
| `faqCount` | Integer | Number of FAQ entries |

#### Metadata

| Field | Type | Description |
|---|---|---|
| `scrapedAt` | String | ISO 8601 scrape timestamp |

#### Example Output

```json
{
    "storeId": "15034",
    "storeName": "UBURGER",
    "storeUrl": "https://www.doordash.com/store/15034",
    "address": "636 Beacon Street",
    "city": "Boston",
    "state": "MA",
    "breadcrumbs": ["Home", "Boston", "Burgers", "UBURGER"],
    "menuSectionCount": 11,
    "menuItemCount": 37,
    "menuSections": ["Usalads", "Burgers", "Sandwiches", "Sides"],
    "menuItems": [
        {"section": "Usalads", "name": "Greek Salad", "description": "Romaine lettuce, cherry tomatoes, ...", "price": "$8.50"}
    ],
    "faqCount": 3,
    "faq": [
        {"question": "How can I order from UBURGER on DoorDash?", "answer": "..."}
    ],
    "scrapedAt": "2026-04-13T05:55:00+00:00"
}
```

### FAQ

**Q: Why doesn't this scrape user reviews?**
DoorDash removed user-facing reviews from store pages and now only shows aggregate ratings via menu items. The reference actor labeled "DoorDash Reviews Scraper" is misleading — there are no individual reviews to extract. This actor instead extracts everything DoorDash actually exposes: menu, address, FAQ, and breadcrumbs.

**Q: Why is a RESIDENTIAL proxy required?**
DoorDash's `www.doordash.com/store/*` paths are protected by Cloudflare which blocks Apify datacenter IPs with `403 Just a moment...`. A real Chrome browser (Patchright) on a US residential IP solves the Cloudflare challenge automatically in 2–15 seconds. The proxy is hardcoded and applied automatically — no configuration needed.

**Q: How long does each restaurant take?**
Roughly 15–25 seconds per restaurant (Cloudflare solve + page load + JSON-LD parse). Limited by the browser session, not by network throughput.

**Q: Can I get prices in dollars (not strings)?**
Prices are kept as strings (`"$8.50"`) because DoorDash sometimes uses ranges or currency symbols. Cast to float in your downstream pipeline if you need numerics: `float(price.replace("$", "").split("-")[0])`.

**Q: Will this work for all DoorDash stores?**
Yes for restaurants with a published menu schema. About 40% of DoorDash stores don't expose a Menu JSON-LD on their store page (closed restaurants, brand aggregators like ezCater, certain catering platforms). For those stores the scraper still returns full restaurant info, FAQ, breadcrumbs and address — but `menuSections` and `menuItems` come back as empty arrays. Convenience-store / grocery URLs (e.g., `/store/cvs`, `/store/walgreens`) have a different page structure and may return fewer fields.

### Use Cases

- **Restaurant menu intelligence** — track competitor pricing across markets
- **Cuisine analysis** — group restaurants by breadcrumb cuisine tag
- **Market research** — identify chains operating in specific cities
- **Menu engineering** — see which items / sections are common across restaurants
- **Lead generation** — find independent restaurants by city + cuisine

# Actor input Schema

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

DoorDash store URLs (e.g., https://www.doordash.com/store/15034). Each store will be scraped for full menu + restaurant info.

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

Maximum number of restaurants to scrape across all URLs.

## Actor input object example

```json
{
  "storeUrls": [
    "https://www.doordash.com/store/15034"
  ],
  "maxItems": 1
}
```

# Actor output Schema

## `reviews` (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/15034"
    ],
    "maxItems": 1
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/doordash-restaurant-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/15034"],
    "maxItems": 1,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/doordash-restaurant-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 '{
  "storeUrls": [
    "https://www.doordash.com/store/15034"
  ],
  "maxItems": 1
}' |
apify call crawlerbros/doordash-restaurant-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "DoorDash Restaurant Scraper",
        "description": "Extract restaurant info + complete menus from DoorDash store pages like name, address, cuisine, breadcrumbs, FAQ, and full menu sections with item names, descriptions, and prices.",
        "version": "1.0",
        "x-build-id": "yAVhIsquG6DayltB5"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~doordash-restaurant-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-doordash-restaurant-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/crawlerbros~doordash-restaurant-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-doordash-restaurant-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/crawlerbros~doordash-restaurant-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-doordash-restaurant-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": {
                    "storeUrls": {
                        "title": "Store URLs",
                        "type": "array",
                        "description": "DoorDash store URLs (e.g., https://www.doordash.com/store/15034). Each store will be scraped for full menu + restaurant info.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum number of restaurants to scrape across all URLs.",
                        "default": 10
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```