DoorDash Scraper API

Local & Maps · v1.1.0 · doordash_restaurants

$0.001 / restaurant

$1.00 / 1K · pay per delivered restaurant

A DoorDash scraper API that lists the restaurants delivering in a US city: name, rating, the exact review count, cuisine, price band, full address, image and store URL. Pass the city the way you would say it — “Austin, TX” — and optionally a cuisine to reach beyond the first page DoorDash shows.

By Aldo Morese, founder of QuanticData · Published Aug 21, 2026 · Updated Sep 3, 2026

Run in dashboard See the request

$0.001 per delivered restaurant · $2 free every month · Failed runs never billed

What it does

What a DoorDash scraper API does

DoorDash publishes a schema.org list of each city’s restaurants for search engines, and that block is what this collector reads. It is the better source in a way you can measure: the JSON states reviewCount: 684 where the rendered card says only “(600+)”, and it keeps the stores that have no rating yet, where the DOM drops their rating node and leaves you with 46 ratings to zip against 50 cards. Two quirks make a by-the-spec parser return nothing — the block is wrapped in DoorDash’s own envelope and found by its key, not by position, and the rating field is spelled aggregatedRating, against the standard — and both are absorbed here.

One city page is all a plain fetch gets; DoorDash has no pagination on it. So breadth comes from cuisine facets rather than paging: pass cuisine and the run reads that facet’s page instead. The city is turned into DoorDash’s own slug (“Austin, TX” → austin-tx) so you never build a URL.

Inputs

The whole request. Anything you leave out falls back to the default shown in the catalog.

Input	Type	Required	What it does
`location`	string	yes	US city and state, e.g. "Austin, TX".
`cuisine`	string	no	Narrow to one cuisine, e.g. "mexican" or "sushi". Each cuisine is its own full page, so this is how you collect more than one page's worth for a city.
`country`	string	no	ISO 3166-1 alpha-2 code — proxy exit geo and Google locale (gl). Omit for the default pool.
`max_results`	integer	no	How many restaurants to deliver at most (1–50). You pay only for delivered restaurants.

Outputs — 25 fields, one row per restaurant

What one restaurant looks like

Every delivered restaurant carries these fields. Nullable means the source did not publish it — the field stays empty instead of being guessed.

Field	Type	What it holds
`rank`	integer	Position in DoorDash's order for this city.
`id`	string · nullable	DoorDash store id.
`name`	string	Restaurant name.
`rating`	number · nullable	Average rating out of 5. Null on stores with too few ratings.
`reviews`	integer · nullable	Exact review count — the rendered page only shows it rounded.
`cuisine`	string · nullable	Primary cuisine.
`price_range`	string · nullable	Price band ($ to $$$$).
`street`	string · nullable	Street address.
`city`	string · nullable	City.
`state`	string · nullable	State code.
`postal_code`	string · nullable	ZIP code.
`country`	string · nullable	Country.
`image`	string · nullable	Store photo URL.
`url`	string · nullable	Store page URL.
`address`	string · nullable	Full address on one line as DoorDash prints it, ZIP included.
`latitude`	number · nullable	Store latitude.
`longitude`	number · nullable	Store longitude.
`categories`	string[] · nullable	Every cuisine/category tag on the store; `cuisine` is the primary one.
`delivery_fee`	string · nullable	Delivery fee as displayed, e.g. "$0 delivery fee".
`distance`	string · nullable	Distance from the city centre the page is built around, as displayed ("0.5 mi", "800 ft").
`eta_minutes`	integer · nullable	Estimated delivery time in minutes when DoorDash shows one.
`promotions`	string[] · nullable	Promotion and highlight tags on the card, e.g. "$5 off on $35+", "Newly Added".
`popular_items`	object[] · nullable	Up to 8 popular menu items: name, description, price, currency, image.
`offers_pickup`	boolean · nullable	True when the store offers pickup.
`sponsored`	boolean · nullable	True when the card is a sponsored placement.

Integration

One POST, typed rows

Base URL https://api.quanticdata.io/v1, Bearer auth, the same key as every other Data API. Endpoint: POST /v1/scraper/collectors/doordash_restaurants/run.

curl -X POST https://api.quanticdata.io/v1/scraper/collectors/doordash_restaurants/run \
  -H "Authorization: Bearer $QD_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"location":"Austin, TX","max_results":50}'

import requests

r = requests.post(
    "https://api.quanticdata.io/v1/scraper/collectors/doordash_restaurants/run",
    headers={"Authorization": f"Bearer {QD_API_KEY}"},
    json={
        "location": "Austin, TX",
        "max_results": 50
    },
    timeout=120,
)
for row in r.json()["payload"]["results"]:
    print(row)

const res = await fetch(
  "https://api.quanticdata.io/v1/scraper/collectors/doordash_restaurants/run",
  {
    method: "POST",
    headers: {
      Authorization: `Bearer ${process.env.QD_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({"location":"Austin, TX","max_results":50}),
  },
);
const { payload } = await res.json();
console.table(payload.results);

claude mcp add quanticdata \
  -e QUANTICDATA_API_KEY=qd_live_your_key_here \
  -- npx -y quanticdata-mcp

# then, in the chat:
> run the doordash_restaurants collector with location="Austin, TX" and max_results=50

Example response

POST /v1/scraper/collectors/doordash_restaurants/run

$ curl $QD/doordash_restaurants/run \
    -H "Authorization: Bearer $QD_API_KEY" \
    -d '{"location": "Austin,  TX", "max_results": 50}'
{ "status": "done", "count": 50,
  "results": [
    {
      "id": "…",
      "name": "…",
      "rating": …,
      "reviews": … } ],
  "cost": 0.05 }
# 50 restaurants × $0.001 · nothing delivered, nothing charged

Try it

DoorDash restaurants, running now

Change the input and run it against the live collector — nothing to install, no sign-up.

Run it from your own code, on your own inputs

Same collector, same rows — $2 of free API credit every month, no card.

Get my free API key

DoorDash Scraper API: from location, QuanticData reads the DoorDash listings and returns one row per restaurant with name, rating and reviews, at $0.001 per delivered restaurant. — You send location and cuisine; the run goes out through a residential exit and comes back as restaurants with rank, id and name — 25 fields on every row — and you are billed $0.001 for each restaurant actually delivered, nothing for a run that delivers none.

$0.001 / restaurant2,000 restaurants on the free $2 every month

Semantic inputlocation, cuisine, country — no URL lists

Up to 50restaurants per run, pagination handled for you

No browserread over HTTP/TLS — cheaper and faster than rendering

Pricing

DoorDash Scraper API pricing

$0.001 per delivered restaurant. A run that delivers nothing costs nothing: blocked pages, challenges and retries are on us, and the $2 monthly allowance covers about 2,000 restaurants before you spend anything.

$0.001per delivered restaurant$1 per 1,000 delivered restaurants

2,000 restaurantson the free allowance$2 every month, no card

Zero rowszero chargeblocks, captchas and retries are on us

−30%on volume tiersthe catalog returns your key's price

Pay as you go

$0/mo

$2 free credit / month
60 requests / min
List unit prices

Starter

$19/mo

$15 free credit / month
300 requests / min
10% off unit prices

Growth

$79/mo

$50 free credit / month
600 requests / min
20% off unit prices

Scale

$299/mo

$250 free credit / month
1,200 requests / min
30% off unit prices

Same wallet, same key and same $2 monthly allowance as every other Data API. Prices are launch pricing read live from the billing config — GET /v1/scraper/collectors returns the price your key actually pays.

What people build with the DoorDash scraper API

Three shapes of work this endpoint was designed around.

Delivery-market mapping

Every listed restaurant in a city with cuisine, price band and address — the base layer for a food-delivery or ghost-kitchen study.

Rating and review-count tracking

Exact review counts rather than “600+”, so a monthly diff shows real movement per store.

Local restaurant leads

Name, address and store URL per restaurant, joinable with Google Maps and Tripadvisor rows on the same venues.

DoorDash Scraper API versus rolling your own

The differences that actually cost time when you build this in-house.

	DIY scraper	This collector
Review counts	The rounded “600+” from the card	The exact number from the structured block
Unrated stores	Dropped, and every later row shifts	Kept, with `rating` null
Reading the block	Spec-correct `aggregateRating` finds nothing	DoorDash’s envelope and misspelling handled
Breadth	One page, no pagination	Per-cuisine facets on request

What people search for

Live autocomplete demand around DoorDash restaurants, pulled with our own Keyword ideas collector.

DoorDash Scraper API: the POST to the doordash_restaurants collector, 50 restaurants delivered and the bill, 50 × $0.001 = $0.05 in usage.cost_usd; zero restaurants would cost $0. — The same call you would paste into a terminal: a Bearer key, location, cuisine and country in the body, and back the envelope every QuanticData endpoint returns — type, message, payload — where count is how many restaurants arrived and usage.cost_usd is $0.05, which is 50 × $0.001. A run that delivers nothing costs nothing. The key is good for 60 req/min on the free tier.

Sources and standards

The platform documentation and standards this collector is built against — check any claim on this page against the primary source:

FAQ

Questions we get about the DoorDash scraper API.

Something else? Ask us

Does it read menus or prices per dish?

No. It reads the city listing — the restaurants themselves, with rating, review count, cuisine and price band. Menus are on each store page, which this collector does not open.

Why only 50 per run?

A city page lists what DoorDash chose to show it, and there is no next page on the TLS tier. To reach more restaurants, run the same city with different cuisine values: each facet is its own list.

Is the review count exact?

Yes — it comes from the structured block, which states the integer. The visible card rounds it to a threshold like “600+”.

Which cities work?

US cities DoorDash has a page for, passed as “City, ST”. The run converts that to DoorDash’s slug; a city it does not serve returns an error rather than an empty result.

Is there a free DoorDash scraper API?

Every account gets $2 of credit every month with no card, which is about 2,000 delivered restaurants on this endpoint at $0.001 each. It renews monthly, and a run that delivers nothing is never billed — so a failed or blocked attempt does not eat the allowance.

How much does one run cost?

Multiply the rows you actually receive by $0.001. A run capped at 50 restaurants — the maximum for this collector — costs $0.05 if every row comes back, and less when the source has fewer. Volume tiers take up to 30% off, and GET /v1/scraper/collectors returns the price your key actually pays.

Run the DoorDash scraper API now

$2 of free credit every month, no card. Your key returns its own prices from GET /v1/scraper/collectors.

Run in dashboard