# DoorDash Scraper — Store Reviews & Ratings (`solidcode/doordash-scraper`) Actor

\[💰 $3.5 / 1K] Extract every public customer review from any DoorDash store page. Get star ratings, full review text, verified-order flags, review photos, reviewer profiles and the menu items each review names. Export to JSON, CSV or Excel.

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

## Pricing

from $3.50 / 1,000 reviews

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 Scraper — Store Reviews & Ratings

Pull every public customer review from any DoorDash store — star ratings, full review text, verified-order flags, customer photos, reviewer profiles and the exact menu items each review names. Built for restaurant groups, delivery-market analysts, and brand and reputation teams who need the whole review history of a store in one table, instead of the five reviews the store page is willing to show and a copy-paste job for the rest.

### Why This Scraper?

- **Every public review, not the preview** — a DoorDash store page shows 5 reviews. This returns the store's complete public list: 107 of 107 on one store, 95 of 95 on another, 18 of 18 on a third.
- **17 fields on every review row** — rating, label, full text, review date, verified-order flag, helpful votes, mentioned menu items, reviewer identity, reviewer badge, photos and source, all flat and ready for a spreadsheet.
- **DoorDash's own sentiment label** — `ratingLabel` ships as `Loved`, `Liked` or `Didn't like`, a closed three-value set that is an exact function of the 1–5 star count. Group by it without writing your own rating buckets.
- **The dishes each review actually names** — `mentionedItems` carries the menu items a reviewer called out (`Whopper`, `French Fries`, `Chopped Salad`), so you can rank sentiment per item instead of per store.
- **Verified orders are flagged** — `verified` separates reviews written after a confirmed DoorDash order from the rest, so you can weight or filter on real purchase evidence.
- **Reviewer context on every row** — display name, profile URL and DoorDash's own contributor note (`Local Expert - 42 contributions`), which tells a one-off complaint apart from a 200-review regular.
- **Customer photos, at full CDN resolution** — `photoUrls` returns every image attached to a review, the same shots buyers see under the ratings tab.
- **Coverage you can check, not coverage we claim** — `id`, `url` and `storeId` on 100% of rows, and `rating`, `ratingLabel`, `reviewText`, `reviewedAt` and `verified` on at least 98% — measured over 462 reviews spanning 6 cities, 6 US states plus a Canadian province, and 6 cuisine categories.

### Use Cases

#### Restaurant & Brand Operations

- Track complaint themes store by store — cold food, missing items, long waits — and see which locations they cluster in.
- Rank individual menu items by sentiment using `mentionedItems` plus the star rating on the same row.
- Measure whether a menu change, a new packaging supplier or a kitchen retrain moved the rating, by comparing `reviewedAt` windows before and after.
- Pull the full review history of a location before an audit or a franchise review, instead of the five most recent.

#### Competitive & Market Research

- Benchmark your locations against nearby competitors on the same delivery platform, using the same rating scale.
- Study how a cuisine category performs in a metro area — the sample here spans burgers, breakfast, sushi, burritos, sweets and dinner.
- Spot which competitors are winning on food quality versus delivery experience by reading what reviewers actually mention.
- Track a new market entrant's review volume and rating trajectory week over week.

#### Reputation Management

- Alert on new 1- and 2-star reviews as they appear, routed to Slack or email through Apify's integrations.
- Prioritise responses by reviewer weight — a `Local Expert` with 200 contributions carries more reach than a first-time reviewer.
- Separate verified-order complaints from unverified ones before escalating to an operations team.
- Build a monthly reputation report per location, with photo evidence attached.

#### Data Science & AI

- Train or evaluate sentiment and aspect-extraction models on labelled restaurant reviews — the star rating and DoorDash's own `Loved` / `Liked` / `Didn't like` label ship as ground truth on the same row.
- Build retrieval corpora for a restaurant or food-delivery assistant, with reviews spanning 2021 to 2026.
- Mine review photos for food-presentation and packaging computer-vision datasets.

#### Data Enrichment & Integration

- Enrich an internal store master with live review counts and ratings, joined on `storeId`.
- Feed reviews into a BI dashboard or warehouse on a schedule, straight from the dataset.
- Push new reviews into a CRM or ticketing system as they land, using webhooks.

### Getting Started

#### One store, capped at 100 reviews

```json
{
  "searchUrls": [
    "https://www.doordash.com/store/11611/"
  ],
  "maxItems": 100
}
```

#### Paste a store URL straight from your address bar

Open the store on doordash.com and copy the URL. Both the long form with the
restaurant name in it and the short numeric form address the same store.

```json
{
  "searchUrls": [
    "https://www.doordash.com/store/panda-express-46386/"
  ],
  "maxItems": 100
}
```

#### Several stores, every review each one has

`maxItems: 0` removes the per-store cap and collects the store's whole public list.

```json
{
  "searchUrls": [
    "https://www.doordash.com/store/11611/",
    "https://www.doordash.com/store/25126830/",
    "https://www.doordash.com/store/13937/"
  ],
  "maxItems": 0,
  "proxyConfiguration": { "useApifyProxy": true }
}
```

### Input Reference

#### What to Scrape

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `searchUrls` | array | example store | DoorDash store page URLs, one per store you want reviews for. Copy them from doordash.com — `https://www.doordash.com/store/panda-express-46386/` and `https://www.doordash.com/store/46386/` both work. |
| `maxItems` | integer | `100` | Maximum reviews **per store URL** (`0` = collect every review the store has). The opening status message states the run total. |

#### Options

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `concurrency` | integer | `8` | How many requests to run in parallel, 1–10. Lower this if you see failures. |
| `proxyConfiguration` | object | Apify Proxy | Proxy settings for the run. |

### Output

Every review is one dataset row. There is a single record type — no second table to join.

The example below is a real captured review. The reviewer's name and profile identifiers have been replaced with placeholders; your dataset contains the actual published values.

```json
{
  "id": "d59941b4-c012-4981-a62d-e3058e4c354c",
  "url": "https://www.doordash.com/store/11611/",
  "storeId": "11611",
  "rating": 5,
  "ratingLabel": "Loved",
  "reviewText": "Everything is delicious and consistently good here! The BLT and chopped Chopped Salad were awesome. The drip Coffee was strong. Their soups are great whether it's the tomato soup or the daily special. We love this place. Especially the quiche. They even have quality Napkins and Utensils.",
  "reviewedAt": "2024-04-07T18:17:03.736+00:00",
  "verified": true,
  "helpfulCount": 0,
  "mentionedItems": [
    "Chopped Salad",
    "Napkins and Utensils"
  ],
  "reviewerName": "REVIEWER NAME",
  "reviewerId": "000000000",
  "reviewerProfileUrl": "https://www.doordash.com/consumer/profile/000000000",
  "reviewerProfileNote": "109 contributions",
  "photoUrls": [
    "https://img.cdn4dd.com/u/media/46d6a230-f0a1-4da6-8037-a6370c7adef9.png"
  ],
  "reviewerAvatarUrl": "https://doordash-cx-profile.cdn4dd.com/media/2ab7b694-df7b-46ee-acd7-3687293d9892.png",
  "reviewSource": "DoorDash"
}
```

#### The Review

| Field | Type | Description |
|-------|------|-------------|
| `id` | string | Unique review ID. Stable across runs, so it doubles as your de-duplication key. |
| `url` | string | The store page the review is published on. |
| `storeId` | string | Numeric DoorDash store ID — the join key back to your own store list. |
| `rating` | number | Star rating, 1–5. |
| `ratingLabel` | string | DoorDash's own label: `Loved` (5 stars), `Liked` (4 stars) or `Didn't like` (1–3 stars). |
| `reviewText` | string | The full written review. |
| `reviewedAt` | string | When the review was written, ISO 8601 in UTC. |
| `verified` | boolean | `true` when the review follows a confirmed DoorDash order. |
| `helpfulCount` | number | How many people marked the review helpful. |
| `mentionedItems` | array | Menu items the review names, e.g. `["Whopper", "French Fries"]`. |

#### The Reviewer

| Field | Type | Description |
|-------|------|-------------|
| `reviewerName` | string | Public display name as shown on DoorDash. |
| `reviewerId` | string | DoorDash's reviewer ID — group a person's reviews across stores. |
| `reviewerProfileUrl` | string | Absolute link to the public reviewer profile. |
| `reviewerProfileNote` | string | DoorDash's contributor line, e.g. `Local Expert - 42 contributions` or `9 contributions`. |

#### Media & Source

| Field | Type | Description |
|-------|------|-------------|
| `photoUrls` | array | Full-resolution URLs of every photo attached to the review. |
| `reviewerAvatarUrl` | string | The reviewer's profile picture. |
| `reviewSource` | string | Which DoorDash surface the review came from. |

### Tips for Best Results

- **`maxItems` is per store, not per run.** Ten store URLs at `maxItems: 100` is up to 1,000 rows. The opening status message quotes the run total before anything is collected, so read it once when you scale a run up.
- **Set `maxItems: 0` for a complete history.** Stores here carry roughly 18–110 public reviews each, so an uncapped run on a handful of stores is small and predictable.
- **Written reviews are far rarer than star ratings.** One sampled store had 7,711 ratings but only 58 written reviews — this actor returns the written ones, which is the text you can actually analyse. Size your volume estimates on the written count, not the headline rating count.
- **Sort on `reviewedAt` yourself if you need chronological output.** Reviews arrive in DoorDash's own display order, which is roughly newest-first but not strictly ordered. The values are ISO 8601 in UTC (`2024-04-07T18:17:03.736+00:00`), so a plain string sort is correct.
- **Absent means absent.** `photoUrls`, `reviewerAvatarUrl` and `mentionedItems` depend entirely on what the reviewer attached — most reviews carry no photo. A review without one carries no key at all rather than an empty list, so `if "photoUrls" in row` is a reliable filter and never a false positive.
- **Rows identify the store by ID and URL, not by name.** You get `storeId` and the store page URL, never the restaurant's name, address or overall rating. One store's URL produces one set of rows, so keep your own store list beside the run and join on `storeId`.
- **Re-run a store to catch new reviews, then de-duplicate on `id`.** IDs are stable, so a nightly run with a low `maxItems` gives you fresh reviews cheaply without re-collecting the archive.

### Pricing

**From $3.50 per 1,000 results.**

| Results | Price |
|---------|-------|
| 100 | $0.35 |
| 1,000 | $3.50 |
| 10,000 | $35.00 |
| 100,000 | $350.00 |

Those are the rates on Gold and above. Higher-volume plans pay less per result:

| Your Apify plan | Price |
|-----------------|-------|
| No discount | $4.20 |
| Bronze | $3.95 |
| Silver | $3.70 |
| **Gold and above** | **$3.50** |

Per 1,000 results.

A "result" is any review row in the output dataset. If the same review appears twice in one run — say you list a store under both its long and its short URL — it is de-duplicated before it reaches the dataset, so you are never charged twice for it. Platform fees (compute, storage) are additional and depend on your Apify plan.

### Integrations

Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via:

- **Zapier** / **Make** / **n8n** — Workflow automation
- **Google Sheets** — Direct spreadsheet export
- **Slack** / **Email** — Notifications on new results
- **Webhooks** — Trigger custom APIs on run completion
- **Apify API** — Full programmatic access

### Legal & Ethical Use

**This is an unofficial scraper. It is not affiliated with, endorsed by, or connected to DoorDash, DoorDash, Inc., or any of its brands in any way.** All trademarks belong to their respective owners.

This actor is intended for legitimate market research, restaurant analytics, and reputation management. You are responsible for complying with applicable laws and with DoorDash's Terms of Service.

Reviews include personal data — display names, profile links, profile pictures and the photos people chose to publish. Treat them accordingly: do not use them for spam, harassment, profiling of individuals, or any unlawful purpose, and follow applicable privacy rules when storing or processing them.

# Actor input Schema

## `searchUrls` (type: `array`):

DoorDash store page URLs — one per store you want reviews for. Open the store on doordash.com and paste the address bar URL, e.g. https://www.doordash.com/store/panda-express-46386/ or https://www.doordash.com/store/11611/. Leave empty to use the example store.

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

Maximum reviews per store URL (0 = collect every review each store has). With several store URLs the run collects up to this many from each — the opening status message states the run total.

## `concurrency` (type: `integer`):

How many requests to run in parallel. Lower this if you see failures.

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

Proxy settings for the run.

## Actor input object example

```json
{
  "searchUrls": [
    "https://www.doordash.com/store/11611/"
  ],
  "maxItems": 100,
  "concurrency": 8,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `core` (type: `string`):

Core Fields for each review.

## `contact` (type: `string`):

Contacts for each review.

## `media` (type: `string`):

Media for each review.

## `meta` (type: `string`):

Details & Timestamps for each review.

# 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 = {
    "searchUrls": [
        "https://www.doordash.com/store/11611/"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/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 = {
    "searchUrls": ["https://www.doordash.com/store/11611/"],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/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 '{
  "searchUrls": [
    "https://www.doordash.com/store/11611/"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call solidcode/doordash-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/wuFEyeegXMSmqWPfN/builds/zwWwTDwjMBwuXSesb/openapi.json