# DoorDash Scraper - Restaurants, Menus & Prices (`scrapesage/doordash-scraper`) Actor

Scrape DoorDash restaurants & menus by city: name, full address, cuisine, price tier, menu items with prices, rating, reviews and geo. Optional full menu & review enrichment and monitoring. No login or API key.

- **URL**: https://apify.com/scrapesage/doordash-scraper.md
- **Developed by:** [Scrape Sage](https://apify.com/scrapesage) (community)
- **Categories:** E-commerce, Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 restaurant scrapeds

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/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 Scraper — Restaurants, Menus, Prices & Reviews

Scrape **[DoorDash](https://www.doordash.com)** — the #1 US food-delivery marketplace — into clean, structured data. Pull every restaurant in a city with **name, full street address, cuisine, price tier, logo, and a menu preview with prices**. Turn on store details for the **complete menu (every section, item & price), star rating, review count, customer reviews and geo coordinates**. Built-in **monitor mode** returns only new restaurants between runs.

No API key, no login, no browser automation — fast HTTP straight to the source, with a **0–100 quality score** on every restaurant.

### Why this DoorDash scraper?

Most food-delivery scrapers give you a list of names, then break or stop at the listing card. This actor reads DoorDash's own structured (JSON-LD) data and ships the **full record** — including the data that powers menu-pricing and competitive-intelligence use cases:

| Data | Typical scrapers | This actor |
|---|---|---|
| Restaurant name + store URL | ✅ | ✅ |
| **Full street address** + city/state | partial | ✅ |
| Cuisine(s) + price tier ($–$$$$) | partial | ✅ |
| Logo / cover image | ❌ | ✅ |
| **Menu preview** (popular items + prices) | ❌ | ✅ |
| **Full menu** — every section, item, description & price *(store details)* | ❌ | ✅ |
| **Star rating + review count** *(store details)* | ❌ | ✅ |
| **Customer reviews** (author, stars, text) *(store details)* | ❌ | ✅ |
| **Geo** (lat/long) *(store details)* | ❌ | ✅ |
| Filter by city, cuisine, price, rating | partial | ✅ |
| **Monitor mode** — only new restaurants | ❌ | ✅ |
| Quality score (0–100) | ❌ | ✅ |

### Who uses DoorDash data?

- **Restaurant-tech, POS, online-ordering & delivery SaaS** — build prospect lists of restaurants by city and cuisine, with address and menu.
- **Food brands, distributors & suppliers** — find and segment restaurants that could carry your products.
- **Menu & price intelligence** — benchmark competitor menus, item pricing and price tiers across a market.
- **Ghost kitchens & virtual brands** — map the competitive landscape and white space by cuisine.
- **Market researchers & analysts** — restaurant density, cuisine mix, ratings and pricing trends by city.
- **Investors & real-estate teams** — gauge food-service supply and demand in a trade area.

### How to use

1. [Sign up for Apify](https://console.apify.com/sign-up) — the free plan is enough to try this actor.
2. Open the **DoorDash Scraper**, enter one or more **cities** ("Austin, TX"), optionally add **cuisines**, and click **Start**.
3. Watch results stream into the dataset table.
4. **Export** as JSON, CSV, Excel, XML, or RSS — or pull results programmatically via the [Apify API](https://docs.apify.com/api/v2).

### Input

```json
{
    "cities": ["Austin, TX", "New York, NY"],
    "cuisines": ["pizza", "mexican"],
    "includeStoreDetails": true,
    "includeReviews": true,
    "maxReviewsPerStore": 10,
    "priceTiers": ["1", "2"],
    "maxResults": 100
}
```

| Field | Type | Description |
|---|---|---|
| `cities` | array | Cities to scrape, as "City, ST" (e.g. "Austin, TX"). |
| `cuisines` | array | Optional cuisine filters — each is scraped separately per city (~50 restaurants each) to expand coverage. |
| `startUrls` | array | DoorDash city pages **or** single `/store/<id>/` URLs (auto-routed; store URLs always pull full details). |
| `maxResults` | integer | Cap on restaurant records (default 100). |
| `includeStoreDetails` | boolean | Open each store page for the full menu, rating, reviews and geo. |
| `includeReviews` | boolean | Include customer reviews when store details are on. |
| `maxReviewsPerStore` | integer | Max reviews per restaurant. |
| `cuisineFilter` | array | Output filter: keep only matching cuisines. |
| `priceTiers` | array | Output filter: 1 = $, 2 = $$, 3 = $$$, 4 = $$$$. |
| `minRating` / `minReviews` | integer | Output filters (require store details). |
| `withMenuOnly` | boolean | Only restaurants that have menu items. |
| `monitorMode` | boolean | Emit only restaurants not seen in previous runs. |
| `proxyConfiguration` | object | Defaults to Apify **Residential, US** (recommended). |

### Output

Each restaurant is one row tagged `type: "restaurant"`:

```json
{
  "type": "restaurant",
  "storeId": "62014",
  "name": "The Cheesecake Factory",
  "url": "https://www.doordash.com/store/the-cheesecake-factory-austin-62014/",
  "cuisines": ["American", "Dessert"],
  "primaryCuisine": "American",
  "priceRange": "$$",
  "priceTier": 2,
  "street": "10000 Research Boulevard",
  "city": "Austin",
  "state": "TX",
  "rating": 4.5,
  "reviewCount": 50,
  "latitude": 30.39098,
  "longitude": -97.747569,
  "menu": [
    { "section": "Most Ordered", "items": [
      { "name": "Whole Wheat Loaf", "price": 3.5, "priceText": "$3.50" }
    ] }
  ],
  "menuSectionCount": 9,
  "menuItemCount": 91,
  "reviews": [
    { "author": "Miguel R", "rating": 5, "body": "...delicious!" }
  ],
  "leadScore": 88,
  "scrapedAt": "2026-06-24T01:00:00.000Z"
}
```

Without store details, each row carries the city-feed data: `name`, `street`/`city`/`state`, `cuisines`, `priceRange`, `imageUrl`, and a `menuPreview` (popular items with prices).

### Monitor mode

Turn on **`monitorMode`** to remember every restaurant (`storeId`) across runs and emit **only restaurants not seen before** — perfect for tracking new restaurant openings in a market. State lives in a named key-value store (`monitorStoreName`, default `doordash-scraper-monitor`); use a different name per tracked market. This is **orthogonal to [Apify Schedules](https://docs.apify.com/platform/schedules)** — the schedule decides *when* to run, monitor mode decides *what's new*.

### Automate & schedule

- **[Apify API](https://docs.apify.com/api/v2)** — start runs, fetch datasets, manage schedules over REST.
- **[apify-client for JavaScript](https://docs.apify.com/api/client/js/)** and **[apify-client for Python](https://docs.apify.com/api/client/python/)** — official SDKs.
- **[Schedules](https://docs.apify.com/platform/schedules)** — run it daily/weekly to track new restaurants and menu/price changes in a market.
- **[Webhooks](https://docs.apify.com/platform/integrations/webhooks)** — trigger downstream actions (CRM import, Slack alert, price-monitoring job) when a run finishes.

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

const client = new ApifyClient({ token: 'MY_APIFY_TOKEN' });

const run = await client.actor('scrapesage/doordash-scraper').call({
    cities: ['Austin, TX'],
    includeStoreDetails: true,
    maxResults: 100,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Integrate with any app

Connect the dataset to 5,000+ apps — no code required:

- **[Make](https://docs.apify.com/platform/integrations/make)** — multi-step automation scenarios.
- **[Zapier](https://docs.apify.com/platform/integrations/zapier)** — push new restaurant leads straight into your CRM.
- **[Slack](https://docs.apify.com/platform/integrations/slack)** — get notified when a monitored city has new restaurants.
- **[Google Drive / Sheets](https://docs.apify.com/platform/integrations/drive)** — auto-export every run to a spreadsheet.
- **[Airbyte](https://docs.apify.com/platform/integrations/airbyte)** — pipe results into your data warehouse.
- **[GitHub](https://docs.apify.com/platform/integrations/github)** — trigger runs from commits or releases.

### Use with AI assistants (MCP)

The output is clean, LLM-ready JSON. Call this actor from Claude, ChatGPT, or any agent framework through the **[Apify MCP server](https://docs.apify.com/platform/integrations/mcp)** — ask your assistant to "list the top-rated pizza restaurants in Austin with their menu prices" and let it run this scraper for you.

### Agent-ready: autonomous payments (x402 & Skyfire)

This actor is **agent-ready** — AI agents can discover it, run it, and **pay for it autonomously**, with no Apify account and no human in the loop. It uses [pay-per-event](https://docs.apify.com/platform/actors/publishing/monetize/pay-per-event) pricing and [limited permissions](https://docs.apify.com/platform/actors/development/permissions), so it qualifies for Apify's agentic-payment standards:

- **[x402](https://docs.apify.com/platform/integrations/x402)** — an open, HTTP-native payment protocol. Agents pay per run in USDC on the Base network directly through the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp) — no account, no API key.
- **[Skyfire](https://docs.apify.com/platform/integrations/skyfire)** — agent-to-service payments for fully autonomous AI-agent workflows.

Building an AI agent, MCP tool, or autonomous data pipeline? This scraper is ready to plug in and pay as it goes.

### More scrapers from scrapesage

- **[UberEats Scraper](https://apify.com/scrapesage/ubereats-scraper)** — restaurants, menus and prices from Uber Eats.
- **[Wolt Scraper](https://apify.com/scrapesage/wolt-scraper)** — restaurant and store data from Wolt.
- **[Zomato Scraper](https://apify.com/scrapesage/zomato-scraper)** — restaurant listings, menus and reviews.
- **[Just Eat Scraper](https://apify.com/scrapesage/just-eat-scraper)** — European food-delivery restaurant data.
- **[Talabat Scraper](https://apify.com/scrapesage/talabat-scraper)** — MENA food-delivery restaurants and menus.
- **[US Restaurant Inspection Scraper](https://apify.com/scrapesage/us-restaurant-inspection-scraper)** — health-inspection scores and violations.
- **[Google Maps Scraper](https://apify.com/scrapesage/google-maps-scraper)** — local business leads, emails, phones and reviews.
- **[Website Contact Scraper](https://apify.com/scrapesage/website-contact-scraper)** — emails, phones and socials from any website.

### Tips

- **Wider coverage per city**: add several `cuisines` (pizza, mexican, sushi, burgers…) — each pulls ~50 more restaurants for the same city.
- **Cheapest runs**: leave `includeStoreDetails` off — the city feed already gives name, address, cuisine, price tier and a menu preview.
- **Menu/price benchmarking**: turn on `includeStoreDetails` to capture every menu item and price across a market.
- **Track new openings**: combine [Schedules](https://docs.apify.com/platform/schedules) with `monitorMode`.

### FAQ

**Do I need a DoorDash API key or login?** No. This actor reads the public city and store pages — no key, no login, no browser.

**Can I target a specific city?** Yes — the city is set by the URL, so results are reliably localized to the city you enter (unlike IP-based scrapers).

**Does it get restaurant phone numbers?** DoorDash routes contact through its platform and does not publish restaurant phone numbers, so phone is not available. You get the full street address, which pairs well with the [Google Maps Scraper](https://apify.com/scrapesage/google-maps-scraper) for phone/email enrichment.

**Why Residential proxy?** DoorDash serves clean pages over US residential IPs but challenges datacenter IPs. The default is Apify Residential (US); blocked requests retry automatically on a fresh IP.

**Can I export to Google Sheets, CSV, or Excel?** Yes — one click in the dataset view, or automatically on every run via the [Google Drive integration](https://docs.apify.com/platform/integrations/drive).

***

*Not affiliated with or endorsed by DoorDash. Use responsibly and in accordance with applicable laws and terms. Scrapes only publicly available data.*

# Actor input Schema

## `cities` (type: `array`):

Cities to scrape restaurants in, as "City, ST" — e.g. "Austin, TX", "New York, NY", "Los Angeles, CA". One per row.

## `cuisines` (type: `array`):

Optional cuisine filters to expand coverage per city — e.g. pizza, mexican, chinese, sushi, burgers, thai, indian, vegan. Each cuisine is scraped separately per city (~50 restaurants each). Leave empty for the general restaurant list.

## `startUrls` (type: `array`):

DoorDash URLs to scrape directly: city pages (https://www.doordash.com/food-delivery/<city>-<st>-restaurants/) or single restaurant pages (https://www.doordash.com/store/<slug>-<id>/). Store URLs always pull the full menu, rating and reviews. One per row.

## `maxResults` (type: `integer`):

Cap on restaurant records across the whole run.

## `includeStoreDetails` (type: `boolean`):

Open each restaurant's store page for the complete menu (every section, item & price), star rating, review count, customer reviews and geo coordinates. One extra request per restaurant. Off = a fast, cheap run with the city-feed data (name, address, cuisine, price tier, logo and a popular-items menu preview).

## `includeReviews` (type: `boolean`):

When store details are on, also include individual customer reviews (author, star rating, text).

## `maxReviewsPerStore` (type: `integer`):

Maximum customer reviews to keep per restaurant (DoorDash exposes a handful of recent reviews).

## `cuisineFilter` (type: `array`):

Keep only restaurants whose cuisine matches one of these (case-insensitive substring, e.g. "pizza", "mexican"). Leave empty for all.

## `priceTiers` (type: `array`):

Keep only restaurants in these price tiers: 1 = $, 2 = $$, 3 = $$$, 4 = $$$$. Leave empty for all.

## `minRating` (type: `integer`):

Keep only restaurants with a star rating at or above this value (1–5). Requires store details on. 0 = no filter.

## `minReviews` (type: `integer`):

Keep only restaurants with at least this many reviews. Requires store details on. 0 = no filter.

## `withMenuOnly` (type: `boolean`):

Output only restaurants that have menu items.

## `deduplicateStores` (type: `boolean`):

Skip a restaurant already emitted earlier in the same run (common when scraping a city across multiple cuisines).

## `monitorMode` (type: `boolean`):

Remember which restaurants were already returned and emit ONLY restaurants not seen in previous runs. Pairs with Apify Schedules to track new restaurant openings in a market over time.

## `monitorStoreName` (type: `string`):

Named key-value store that holds the 'already seen' store ids for monitoring mode. Use a different name per tracked market to keep histories separate.

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

Maximum parallel requests. Lower it for very large runs if you see transient blocks; raise it for speed.

## `proxyConfiguration` (type: `object`):

Proxy settings. DoorDash serves clean pages over US residential IPs but challenges datacenter IPs, so US Residential is the default and recommended setting. Blocked requests retry automatically on a fresh IP.

## Actor input object example

```json
{
  "cities": [
    "Austin, TX"
  ],
  "maxResults": 100,
  "includeStoreDetails": false,
  "includeReviews": true,
  "maxReviewsPerStore": 10,
  "priceTiers": [],
  "minRating": 0,
  "minReviews": 0,
  "withMenuOnly": false,
  "deduplicateStores": true,
  "monitorMode": false,
  "monitorStoreName": "doordash-scraper-monitor",
  "maxConcurrency": 8,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "countryCode": "US"
  }
}
```

# Actor output Schema

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

All scraped restaurant records in the default dataset — name, address, cuisine, price tier, menu (preview or full), rating, reviews and geo.

# 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 = {
    "cities": [
        "Austin, TX"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapesage/doordash-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 = { "cities": ["Austin, TX"] }

# Run the Actor and wait for it to finish
run = client.actor("scrapesage/doordash-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 '{
  "cities": [
    "Austin, TX"
  ]
}' |
apify call scrapesage/doordash-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

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