DoorDash Restaurant Scraper: Up to 500 Free Results a Month (2026)

Each dataset record carries 16 output fields, including restaurant identity, street address, city, state, cuisine breadcrumbs, FAQ lists, and full menu sections with item prices. Extracting 1,000 results costs $10.00 on Apify's free plan, which offers $5.00 of monthly usage to cover up to 500 results without entering a credit card. Built for retail analysts, pricing teams, and commercial researchers mapping restaurant supply. Not for teams seeking individual user review text, which DoorDash does not display on store pages.

Try it before you read further. Apify's free plan includes $5.00 of usage every month with no credit card, enough for up to 500 results at $0.01 each before platform usage. Open DoorDash Restaurant Scraper on Apify and run the prefilled example.

How reliable is DoorDash Restaurant Scraper in production?

Across the last 30 days of public runs on the Apify platform, DoorDash Restaurant Scraper recorded 95 runs with the following outcomes.

No run failed or timed out in the last 30 days; the 1 that did not finish was stopped by the people who started them. Keep a retry and an alert on scheduled runs all the same: a clean month is a record, not a guarantee.

What does it cost to run DoorDash Restaurant Scraper?

Each result costs $0.01 on Apify's free plan, which is $10.00 per 1,000 results. Starting a run is charged separately at $0.005 per GB of Actor memory. Apify also bills the platform usage each run consumes, at the rates of your Apify plan, on top of these charges.

Worked example: collecting 10,000 results costs $100.00 in result charges before run-start fees and platform usage. No run failed or timed out in the last 30 days, so the list price is a fair budget; keep a retry in place all the same.

The storeUrls array and the maxItems integer control how many items are written to the dataset, making them the main drivers of result charges. To test target store pages without incurring unnecessary costs, execute a initial run with maxItems set to 1. Remember that run-start fees and platform usage charges apply to every execution regardless of how many dataset records are written.

How do you run DoorDash Restaurant Scraper from the API?

None of its 2 controls is strictly required, so the defaults below produce a valid run on their own. The payload below uses the schema's own prefilled values, so it runs as written once you substitute your API token.

Call the synchronous endpoint to start a run and receive dataset items in one request:

curl -X POST "https://api.apify.com/v2/acts/crawlerbros~doordash-restaurant-scraper/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"storeUrls":["https://www.doordash.com/store/15034"],"maxItems":1}'

The same run from Python, using the official client:

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

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

run = client.actor("crawlerbros~doordash-restaurant-scraper").call(run_input=run_input)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

And from Node.js:

import { ApifyClient } from 'apify-client'

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' })

const input = {
  "storeUrls": [
    "https://www.doordash.com/store/15034"
  ],
  "maxItems": 1
}

const run = await client.actor('crawlerbros~doordash-restaurant-scraper').call(input)
const { items } = await client.dataset(run.defaultDatasetId).listItems()
console.log(items)

The synchronous endpoint holds the connection open until the run finishes, which is convenient for small batches and wrong for large ones. For anything long running, start the run asynchronously and poll, or attach a webhook, so a dropped connection does not cost you the results.

Which DoorDash Restaurant Scraper inputs matter, and which can you skip?

The storeUrls array takes DoorDash store URLs such as https://www.doordash.com/store/15034. Set maxItems to cap the total number of restaurants scraped across all input URLs, which defaults to 10 and goes up to 100. Leave maxItems capped at 1 during initial validation runs.

• storeUrls (array): DoorDash store URLs (e.g., https://www.doordash.com/store/15034). Each store will be scraped for full menu + restaurant info.
• maxItems (integer): Maximum number of restaurants to scrape across all URLs. Default: 10.

What does DoorDash Restaurant Scraper return?

Output records supply store metadata alongside nested menuItems records containing section labels, item descriptions, and price strings. They are structured for tracking menu changes, local catalog breadth, and location footprints. They do not contain individual user reviews because DoorDash store pages no longer publish them.

Identity

• storeId: String - DoorDash store ID (from URL)
• storeName: String - Restaurant name
• storeUrl: String - Store page URL
• title: String - Page title
• description: String - Meta description

Example Output

• storeId (e.g. 15034)
• storeName (e.g. UBURGER)
• storeUrl (e.g. https://www.doordash.com/store/15034)
• address (e.g. 636 Beacon Street)
• city (e.g. Boston)
• state (e.g. MA)
• breadcrumbs
• menuSectionCount (e.g. 11)
• menuItemCount (e.g. 37)
• menuSections
• menuItems
• faqCount (e.g. 3)
• faq
• scrapedAt (e.g. 2026-04-13T05:55:00+00:00)

Categorization

• breadcrumbs: Array - Page breadcrumb names (e.g., ["Home", "Boston", "Burgers", "UBURGER"]) - last is restaurant, second-to-last is cuisine

Menu

• 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

• faq: Array - List of {question, answer} pairs from the FAQ section
• faqCount: Integer - Number of FAQ entries

Metadata

• scrapedAt: String - ISO 8601 scrape timestamp

These are the documented fields. Optional ones can be empty on a given record, so measure how often each field your deliverable depends on is populated across a real sample before automating the handoff.

How do you build the workflow end to end?

Open DoorDash Restaurant Scraper and work through these in order. Each step ends with something to check, so a bad configuration surfaces on a small run rather than a scheduled one.

1. Input a set of target store links into the storeUrls array control.
2. Set maxItems to 1 on your first run to minimize result fees while testing.
3. Click Start and confirm the run finishes with a SUCCEEDED status.
4. Open the dataset tab to inspect the 16 output fields returned for the store.
5. Check that storeId and storeName contain populated strings.
6. Inspect the menuItems array to confirm items contain name and price fields.
7. Verify whether menuSectionCount is greater than zero for your target store.
8. Add additional URLs to storeUrls and raise maxItems up to 100 for production runs.

How do you apply it? Three worked playbooks

These are DoorDash Restaurant Scraper's own documented use cases, each worked through as an operating pattern rather than a description.

Use case 1: Restaurant menu intelligence

Outcome: Track competitor pricing across markets

Configure: Set storeUrls to ["https://www.doordash.com/store/15034", "https://www.doordash.com/store/6422"] and set maxItems to 10.

Working method: Execute a test run with a single URL to evaluate the returned JSON schema. Examine the menuItems array to inspect section names and price strings. Expand the input list with store URLs across multiple regions and compare the item price strings across market locations.

Deliverable: A dataset containing 16 output fields per restaurant including storeName, address, and flat menuItems.

Stop condition: The dataset contains empty menuItems arrays across all target stores.

Use case 2: Cuisine analysis

Outcome: Group restaurants by breadcrumb cuisine tag

Configure: Set storeUrls to ["https://www.doordash.com/store/15034"] and maxItems to 50.

Working method: Run the collector against a target list of store URLs across cities. Locate the breadcrumbs array field in the output records. Parse the second-to-last item of the breadcrumbs list to classify each restaurant by cuisine type.

Deliverable: A dataset mapping storeName and city to breadcrumb cuisine categories.

Stop condition: The breadcrumbs field returns an empty array across the dataset.

Use case 3: Market research

Outcome: Identify chains operating in specific cities

Configure: Set storeUrls to ["https://www.doordash.com/store/15034", "https://www.doordash.com/store/6422"] and maxItems to 100.

Working method: Supply a target collection of store URLs for regional restaurant chains. Read the city and state fields alongside storeName for each returned item. Aggregate the records by city to chart brand footprint and density.

Deliverable: A dataset of store locations with storeName, address, city, state, and faqCount.

Stop condition: The city or state fields return empty strings for target stores.

What breaks, and how do you design around it?

• Over the last 30 days, 0.0% of public runs failed and 0.0% timed out. Build retries and alerting around those rates rather than assuming every run completes.

About 40% of DoorDash stores don't expose a Menu JSON-LD on their store page, which leaves menuSections and menuItems as empty arrays. In those cases, rely on the populated address, breadcrumbs, and faq fields instead. When scraping grocery or convenience store pages, expect simpler item structures and handle potential missing menu fields in your downstream ingestion.

When should you not use DoorDash Restaurant Scraper?

Do not use this Actor if you need restaurant listings or menus outside the United States or from alternative delivery networks. For platforms in Latin America, use Rappi Restaurant Scraper, or use Foodpanda Restaurant & Menu Scraper for coverage in Asian markets. If your project targets other US delivery services, choose UberEats Menu Scraper or Grubhub Restaurant Scraper. Avoid this Actor if your data pipeline depends on individual user reviews, as DoorDash no longer publishes individual customer review text on store pages.

What should you check before trusting the output?

• Check that storeId matches the numeric ID present in storeUrl.
• Verify that menuItemCount equals the array length of menuItems.
• Flag records where address or city return empty strings.
• Confirm that price strings inside menuItems contain non-empty values.
• Halt execution if menuSectionCount is zero across every item in a multi-store run.

None of this proves a record is correct. It gives a scheduled DoorDash Restaurant Scraper run defined points where it should stop instead of quietly passing bad data downstream.

Frequently asked questions

How much does it cost to extract DoorDash restaurant menus?

Results cost $0.01 per item, which comes to $10.00 per 1,000 results on Apify's free plan. The free plan provides $5.00 in monthly usage, covering up to 500 results before platform usage charges apply.

What is the recent success rate for this DoorDash scraper?

In the last 30 days, 94 of 95 public runs succeeded. That represents a 98.9% success rate with 0 failed runs and 0 timed out runs.

Why are menuItems empty for some DoorDash store URLs?

About 40% of DoorDash stores don't expose a Menu JSON-LD on their store page. For these stores, the scraper still collects store identity, location, FAQ entries, and breadcrumbs, but returns empty arrays for menu items.

Does this scraper collect customer review comments?

No. DoorDash removed individual user reviews from store pages, so no review text is published to scrape. The Actor focuses on restaurant identity, physical address, breadcrumbs, FAQ pairs, and complete menu structures.

How are item prices formatted in the output dataset?

Prices are returned as string values like $8.50 to preserve formatting and potential price ranges. Downstream applications can parse numerics by stripping currency symbols in python or SQL pipelines.

Where to go next

When you are ready to run it, open DoorDash Restaurant Scraper on Apify; the free plan covers up to 500 results a month.

Start with the DoorDash Restaurant Scraper Actor page for the current input schema, pricing tier, and run history.

If you are comparing approaches rather than committing to one Actor, these category pages list every option we publish:

• Product and price scrapers covers 344 Actors in this family.

Other Actors we maintain for related data:

• Grubhub Restaurant Scraper: Scrape Grubhub restaurant listings and menus.
• UberEats Menu Scraper: Scrape full restaurant menus from UberEats.
• Foodpanda Restaurant & Menu Scraper: Scrape Foodpanda restaurants by URL or location.
• Rappi Restaurant Scraper: Scrape Rappi restaurant listings across Latin America.
• Chowdeck Scraper: Search Chowdeck restaurants, pharmacies, supermarkets and convenience stores across Nigeria and Ghana, and fetch full vendor menus with prices, categories, and stock status.
• Wolt Restaurant & Venue Scraper: Scrape restaurants, cafes, grocery stores and other venues from Wolt food delivery platform across 27+ countries including Finland, Sweden, Denmark, Germany, Poland, Japan, Israel and more.
• Michelin Guide Scraper: Scrape Michelin-starred restaurants from guide.michelin.com.
• LA County Restaurant Inspection Scraper: Scrape restaurant and food-facility health inspection records for Los Angeles County, CA - facility name, address, placard grade, score, violations, and geolocation.

Related guides:

• Google Maps Menu Scraper: 11 Data Fields per Record (2026)
• How to Scrape eBay Item, Store, and Category Data Safely

Resources

• Actor documentation, input schema, and pricing: verified against the published Actor on 2026-09-25.

• Actor last updated by its maintainers on 2026-04-25.

• Run outcome figures cover the 30 day public window ending 2026-09-25.

• DoorDash Restaurant Scraper on Apify