# DoorDash Scraper - Stores, Menus, Reviews & Leads (`haketa/doordash-scraper`) Actor
Scrape DoorDash restaurants by US city: store leads (name, rating, cuisines, delivery fee, address, ETA), full menus with item prices, and customer reviews. No login or API key.
- **URL**: https://apify.com/haketa/doordash-scraper.md
- **Developed by:** [Haketa](https://apify.com/haketa) (community)
- **Categories:** E-commerce, Lead generation
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet
## Pricing
from $3.30 / 1,000 results
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/actors/running/actors-in-store.md#pay-per-event
## What's an Apify Actor?
An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.
Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.
## 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.
Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.
For examples already wired to this Actor's own input schema, see the [API](#api) section below.
Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).
# README
## DoorDash Scraper — Restaurants, Menus, Reviews & Restaurant Leads
[](https://www.doordash.com)
[](https://apify.com/haketa/doordash-scraper)
[](https://apify.com/haketa/doordash-scraper)
[](https://apify.com/haketa/doordash-scraper)
[](https://apify.com/haketa/doordash-scraper)
Extract comprehensive restaurant leads, full itemized menus with pricing, customer reviews, and delivery logistics from **DoorDash (doordash.com)**, the #1 food delivery marketplace in the United States. Scrape verified details including **restaurant name**, **average star rating**, **number of reviews**, **cuisine classifications**, **price tier ($-$$$$)**, **delivery fee estimates**, **estimated delivery time (ETA in minutes)**, **full street address**, and precise **GPS coordinates (latitude & longitude)**.
With optional deep enrichment, you can extract every store's full catalog menu — item titles, descriptions, and numeric prices — alongside authentic customer reviews. Designed for food-tech innovators, restaurant supply sales teams, franchise operators, and market analysts, this actor turns complex food-delivery directories into clean, structured datasets in seconds.
***
### ⚡ At a glance
| Feature | Specification |
|---|---|
| **Target Website** | `doordash.com` (DoorDash US Food Delivery) |
| **Data Fields** | Name, rating, review count, cuisines, delivery fee, ETA, address, GPS lat/lng, menu items, reviews |
| **Search Capabilities** | US cities (`City, ST`), direct store URLs, or automatic national city sweeps |
| **Scale & Capacity** | Unlocked deep multi-city extraction (1,000+ stores across metropolitan clusters) |
| **Enrichment Toggles** | Optional itemized menu extraction and customer review harvesting |
| **Typical Speed** | 50 store leads per city in 20–30 seconds |
| **Proxy Requirement** | Apify Proxy enabled (US Residential proxy required for US marketplace compliance) |
| **Export Formats** | JSON, CSV, Excel (XLSX), XML, HTML Table, RSS |
| **Integrations** | Make, Zapier, Webhooks, Google Sheets, Airbyte, Keboola, Python, Node.js API |
***
### 🔎 Why scrape DoorDash?
DoorDash represents over 65% of the United States food delivery market share, featuring hundreds of thousands of active restaurants ranging from national chains to independent local culinary staples.
Scraping DoorDash delivers actionable intelligence across multiple business verticals:
1. **High-Converting Restaurant Leads**: Equips sales teams selling POS hardware, kitchen automation, food packaging, commercial insurance, and culinary supplies with verified restaurant names, exact street addresses, and active operational statuses.
2. **Competitive Menu Pricing Intelligence**: Track pricing elasticity on signature dishes, monitor inflationary menu adjustments across regional markets, and analyze bundle promotions ("2 for $X").
3. **Delivery Economics & Fee Audits**: Benchmark consumer delivery fees and ETA promises across competitor delivery networks (Uber Eats, Grubhub).
4. **Local Market Sizing & Expansion**: Evaluate restaurant density by cuisine type (e.g., Thai, Mexican, Pizza, Vegan) to uncover underserved delivery zones before opening new brick-and-mortar or ghost-kitchen locations.
5. **Customer Sentiment & Reviews**: Extract qualitative feedback from verified delivery patrons to identify service friction points and top-selling dishes.
***
### 📊 Food Delivery Marketplace Comparison
| Dimension | DoorDash Scraper | Grubhub Scraper | Uber Eats Scraper |
|---|---|---|---|
| **US Market Share** | ~66% (National Leader) | ~10–12% (Regional Pockets) | ~23% (Urban Hubs) |
| **Leads Extraction Speed** | ~50 stores / city in ~25s | ~30–40 stores / city | Browser-dependent (~60s) |
| **Address Precision** | Full printable address + Lat/Lng | ZIP code + City | Street + City |
| **Delivery Economics** | Display fee + ETA minutes | Delivery fee + Min order | Fee + ETA range |
| **Menu Depth** | Item name, description, price | Item name + price | Item name + price |
| **Customer Reviews** | Verified customer feedback | Star rating aggregate | Star rating aggregate |
| **Suburban Coverage** | 🟢 Extremely High | 🟡 Moderate | 🟢 High |
***
### 📊 Key Data Fields & Coverage
Every output record represents a single restaurant listing with optional nested menu and review arrays.
#### 🏪 Store Identity & Location
| Field | Type | Description | Coverage |
|---|---|---|---|
| `storeId` | string | Unique persistent DoorDash store identifier | 🟢 High (100%) |
| `name` | string | Official restaurant business name | 🟢 High (100%) |
| `url` | string | Canonical web listing URL | 🟢 High (100%) |
| `address` | string | Full formatted street address with ZIP code | 🟢 High (98%) |
| `city` | string | Municipal city name | 🟢 High (98%) |
| `latitude` | number | Precise geographic latitude coordinate | 🟢 High (98%) |
| `longitude` | number | Precise geographic longitude coordinate | 🟢 High (98%) |
| `logo` | string | High-resolution branding logo image URL | 🟢 High (90%) |
#### 📈 Delivery Economics & Ratings
| Field | Type | Description | Coverage |
|---|---|---|---|
| `averageRating` | number | Customer star rating (1.0 to 5.0) | 🟢 High (95%) |
| `numRatings` | number | Total count of customer ratings received | 🟢 High (95%) |
| `cuisines` | array | Cuisines and food categories (e.g. `["Italian", "Pizza"]`) | 🟢 High (98%) |
| `priceTier` | number | Price category index (1 = $, 2 = $$, 3 = $$$, 4 = $$$$) | 🟢 High (90%) |
| `deliveryFee` | string | Current consumer delivery fee (e.g., `"$1.99"`) | 🟢 High (95%) |
| `etaMinutes` | number | Estimated delivery fulfillment duration in minutes | 🟢 High (90%) |
| `distance` | string | Physical distance from target search center | 🟢 High (85%) |
| `offersPickup` | boolean | Whether in-store pickup is supported | 🟢 High (100%) |
| `isSponsored` | boolean | Whether store is currently running paid placement | 🟢 High (100%) |
| `popularItems` | array | High-velocity featured menu item titles | 🟢 High (85%) |
#### 🍽️ Itemized Menus (Optional `includeMenu`)
| Field | Type | Description | Coverage |
|---|---|---|---|
| `menu` | array | Array of menu item objects | 🟡 Opt-in (100% when enabled) |
| `menu[].name` | string | Title of menu dish or beverage | 🟢 High |
| `menu[].description` | string | Ingredient breakdown or dish description | 🟢 High |
| `menu[].price` | number | Numeric parsed price (e.g., `14.95`) | 🟢 High |
| `menu[].priceDisplay` | string | Exact on-screen pricing string (e.g., `"$$14.95"`) | 🟢 High |
#### ⭐ Customer Reviews (Optional `includeReviews`)
| Field | Type | Description | Coverage |
|---|---|---|---|
| `reviews` | array | Array of recent customer review objects | 🟡 Opt-in (100% when enabled) |
| `reviews[].reviewer` | string | Display name or initials of patron | 🟢 High |
| `reviews[].rating` | number | Individual star rating (1 to 5) | 🟢 High |
| `reviews[].date` | string | ISO publication timestamp of review | 🟢 High |
| `reviews[].text` | string | Full customer commentary text | 🟢 High |
***
### 🎯 Detailed Use Cases & Workflows
#### 1. Restaurant Supply & B2B Sales Prospecting
- **Objective**: Generate qualified outbound prospect lists for restaurant POS terminals, kitchen grease cleaning services, and eco-friendly food containers.
- **Workflow**: Target top metropolitan areas (e.g., `Chicago, IL`, `Dallas, TX`, `Miami, FL`). Extract restaurant records with full addresses and phone coordinates. Filter for independent operators (`priceTier >= 2` and `numRatings < 500`) to deliver high-converting sales leads to your BDRs.
#### 2. Competitive Price Tracking & Menu Analytics
- **Objective**: Monitor menu price inflation and competitive delivery markups across rival burger or sushi chains.
- **Workflow**: Provide direct `storeUrls` for 20 regional locations and toggle `includeMenu: true`. Parse itemized prices weekly to calculate average entrée cost fluctuations.
#### 3. Ghost Kitchen & Virtual Brand Market Feasibility
- **Objective**: Identify market saturation and gaps before launching a virtual chicken wing or smashburger concept.
- **Workflow**: Scrape all restaurants in target expansion cities. Analyze `cuisines` arrays to determine cuisine concentration, average delivery fees, and consumer ratings in each metro.
#### 4. Local Market Expansion Audits
- **Objective**: Map competitive restaurant footprints across major US states.
- **Workflow**: Run a multi-city sweep across 25 major US cities. Ingest `latitude` and `longitude` coordinates into mapping software (Tableau, ArcGIS, or Google Earth) to visualize coverage voids.
***
### ⚙️ Input Configuration & Parameters
Every input parameter is optional. If executed with empty inputs, the scraper automatically sweeps top US cities for a fast lead generation sample.
| Parameter | Type | Default | Description |
|---|---|---|---|
| `location` | array | `["New York, NY"]` | List of US cities formatted as `City, ST` (e.g., `Austin, TX`, `Seattle, WA`). |
| `storeUrls` | array | `[]` | List of specific DoorDash restaurant URLs to scrape directly. |
| `includeMenu` | boolean | `false` | Enable to fetch and parse complete itemized menus with prices for every store. |
| `includeReviews` | boolean | `false` | Enable to fetch and parse recent verified customer reviews. |
| `maxStores` | integer | `0` | Total maximum restaurants to collect across all cities. `0` = auto/unlimited. |
| `proxyConfiguration` | object | `{"useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"], "apifyProxyCountry": "US"}` | Proxy configuration. US Residential proxy is pre-configured. |
***
### 📝 Input Configurations for Common Scenarios
#### Scenario A: Fast Prefill Run (Demo)
```json
{
"location": ["New York, NY"],
"includeMenu": false,
"includeReviews": false,
"maxStores": 50
}
```
#### Scenario B: Multi-Metro Restaurant Lead Generation (500+ Stores)
```json
{
"location": [
"New York, NY",
"Los Angeles, CA",
"Chicago, IL",
"Houston, TX",
"Miami, FL",
"Atlanta, GA",
"Dallas, TX",
"Phoenix, AZ",
"Denver, CO",
"Seattle, WA"
],
"includeMenu": false,
"includeReviews": false,
"maxStores": 500
}
```
#### Scenario C: Deep Menu & Price Audit for Specific Competitors
```json
{
"storeUrls": [
"https://www.doordash.com/store/shake-shack-new-york-24750/",
"https://www.doordash.com/store/sweetgreen-new-york-29381/"
],
"includeMenu": true,
"includeReviews": true,
"maxStores": 50
}
```
***
### 📦 Sample Output Record
```json
{
"storeId": "24750",
"name": "Shake Shack (Madison Square Park)",
"url": "https://www.doordash.com/store/shake-shack-new-york-24750/",
"averageRating": 4.7,
"numRatings": 3410,
"cuisines": ["American", "Burgers", "Fast Food"],
"priceTier": 2,
"deliveryFee": "$1.99",
"etaMinutes": 25,
"distance": "0.8 mi",
"address": "Madison Ave & E 23rd St, New York, NY 10010, USA",
"city": "New York",
"latitude": 40.7415,
"longitude": -73.9881,
"offersPickup": true,
"isSponsored": false,
"popularItems": ["ShackBurger", "Crinkle Cut Fries", "Classic Shake"],
"logo": "https://img.cdn4dd.com/p/software/image/shake-shack-logo.png",
"menu": [
{
"name": "ShackBurger",
"description": "Cheeseburger topped with lettuce, tomato, and ShackSauce on a toasted potato bun.",
"price": 8.49,
"priceDisplay": "$8.49"
},
{
"name": "Crinkle Cut Fries",
"description": "Crispy crinkle cut fries salted to perfection.",
"price": 4.69,
"priceDisplay": "$4.69"
}
],
"reviews": [
{
"reviewer": "Michael R.",
"rating": 5,
"date": "2026-11-04T18:22:00.000Z",
"text": "Fries were still hot and the burger was incredible as always."
}
],
"searchLocation": "New York, NY",
"scrapedAt": "2026-11-10T13:46:00.000Z"
}
```
***
### 💻 Programmatic Usage & API Integration
Trigger runs and retrieve results via the official Apify Client in Python, JavaScript, or direct REST API requests.
#### Python Integration
```python
from apify_client import ApifyClient
## Initialize client with your Apify API token
client = ApifyClient("YOUR_APIFY_TOKEN")
## Prepare actor input
run_input = {
"location": ["Austin, TX", "San Antonio, TX"],
"includeMenu": False,
"includeReviews": False,
"maxStores": 100
}
## Run actor and wait for completion
run = client.actor("haketa/doordash-scraper").call(run_input=run_input)
## Fetch results from default dataset
for store in client.dataset(run["defaultDatasetId"]).iterate_items():
print(f"{store['name']} | Rating: {store['averageRating']} | Address: {store['address']}")
```
#### Node.js / JavaScript Integration
```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({
token: 'YOUR_APIFY_TOKEN',
});
const input = {
location: ["Chicago, IL"],
includeMenu: true,
maxStores: 25
};
const run = await client.actor('haketa/doordash-scraper').call(input);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((store) => {
console.log(`[${store.name}] Menu Items: ${store.menu?.length || 0} (${store.address})`);
});
```
#### Direct REST API Call
```bash
curl -X POST "https://api.apify.com/v2/acts/haketa~doordash-scraper/runs?token=YOUR_APIFY_TOKEN" \
-H "Content-Type: application/json" \
-d '{
"location": ["San Francisco, CA"],
"maxStores": 50
}'
```
***
### 🔗 Integrations & Data Pipelines
Connect your scraped DoorDash dataset directly into your sales CRM or business intelligence suite:
- **Google Sheets**: Pipe fresh restaurant leads directly into shared spreadsheets for immediate sales rep outreach.
- **HubSpot / Salesforce**: Import restaurant business records with addresses, ratings, and price tiers directly into your CRM.
- **Airtable**: Create an interactive regional restaurant database with automated status tracking.
- **Zapier & Make**: Forward newly discovered restaurants matching specific cuisine criteria directly to communication channels.
- **BigQuery & Snowflake**: Maintain longitudinal tables of menu price movements across nationwide restaurant brands.
***
### 🛠️ Step-by-Step Getting Started Guide
1. **Open the Actor**: Navigate to `haketa/doordash-scraper` on the Apify Console.
2. **Enter Cities or Store URLs**: Add target locations (e.g., `Los Angeles, CA`, `Miami, FL`) or paste specific restaurant profile URLs.
3. **Choose Enrichment Level**:
- For fast leads: Leave `includeMenu` and `includeReviews` unchecked (scrapes ~50 stores per city in ~25s).
- For full data: Enable `includeMenu` and/or `includeReviews`.
4. **Set Store Volume**: Set `maxStores` to your desired count (e.g. `50` for quick testing, or `1,000+` for large market sweeps).
5. **Click Start**: Hit the green **Start** button in the Console.
6. **Export Your Records**: Download your results in the **Dataset** tab as CSV, Excel, or JSON.
***
### 💡 Best Practices & Pro Tips
- **Leads First, Menus Second**: For broad market coverage, run leads-only (`includeMenu: false`) to pull hundreds of restaurant leads in under a minute. Then, isolate high-priority target stores and run with `includeMenu: true`.
- **Formatting City Names**: Always use `City, ST` syntax (e.g. `Denver, CO` or `Miami, FL`) rather than informal nicknames to ensure precise marketplace resolution.
- **Keep Residential Proxy Enabled**: DoorDash enforces strict regional geographical boundaries. Operating through US residential proxies ensures uninterrupted access.
- **De-duplication Guarantee**: Overlapping metropolitan regions are automatically deduplicated by unique `storeId`.
***
### ❓ Frequently Asked Questions
##### How many restaurants can I extract in a single run?
There is no hard limitation. Each US city listing returns ~50 active restaurants. By supplying 20+ cities and configuring `maxStores: 1000+`, you can extract thousands of de-duplicated restaurant records in a single execution.
##### Why is a US residential proxy required?
DoorDash is an exclusively US and North American service that restricts non-US or datacenter traffic. The pre-configured US residential proxy ensures maximum reliability and consistent data extraction.
##### Can I extract menus and prices for specific chains?
Yes. Paste individual DoorDash restaurant URLs directly into the `storeUrls` parameter and toggle `includeMenu: true` to extract full itemized menus and prices.
##### Are phone numbers included?
DoorDash does not publish direct telephone numbers on public web consumer pages. However, the scraper provides full formatted street addresses and GPS coordinates, making external phone enrichment straightforward.
##### How frequently is pricing data updated?
The scraper reads live page payloads at the exact time of execution, capturing real-time delivery fees, ETA calculations, and active menu prices.
##### What export formats are supported?
You can export results directly from the Apify Console as JSON, CSV, Excel (XLSX), XML, or HTML Table.
***
### 📋 Changelog
#### v1.2 — 2026-11
- **1,000+ Deep Multi-City Pagination Unlocked**: Removed restrictive 20-store caps on fallback runs and added multi-city automated expansion to support 1,000+ store sweeps seamlessly.
- **Fast Prefill Optimization**: Streamlined default prefill parameters to execute clean 50-store lead runs in under 30 seconds.
- **Enhanced Address Parsing**: Improved extraction of structured street addresses and geographic coordinates.
- **Comprehensive Documentation**: Added multi-platform marketplace comparison tables, visual shields badges, and complete Python and Node.js SDK snippets.
#### v1.1 — 2026-10
- Added itemized menu catalog extraction with numeric price normalization.
- Added verified customer review extraction.
- Optimized hybrid session persistence for accelerated HTTP throughput.
#### v1.0 — 2026-10
- Initial production release.
- Extraction of restaurant name, rating, review count, cuisines, delivery fee, ETA, address, and GPS coordinates.
# Changelog
This Actor's version history is a separate document: https://apify.com/haketa/doordash-scraper/changelog.md
# Actor input Schema
## `location` (type: `array`):
One or more US locations as City, ST — e.g. New York, NY, Los Angeles, CA, Chicago, IL. Each returns up to ~50 restaurants. Leave empty (and no store URLs) to run a small demo for New York, NY.
## `storeUrls` (type: `array`):
Optional. Paste specific DoorDash store URLs (e.g. https://www.doordash.com/store/big-wong-restaurant-new-york-39641643/) to scrape those stores directly. Works with or without the city list.
## `includeMenu` (type: `boolean`):
For each store, open its page and extract the full menu — item names, descriptions and prices. One extra request per store.
## `includeReviews` (type: `boolean`):
For each store, extract its customer reviews (reviewer, star rating, date, text). DoorDash shows a handful of recent reviews per store page. One extra request per store (shared with menus if both are on).
## `maxStores` (type: `integer`):
Maximum number of stores to save across all cities. 0 = auto/unlimited.
## `proxyConfiguration` (type: `object`):
DoorDash is US-only and protected by Cloudflare — a US residential proxy is required (the actor solves the challenge once with a stealth browser, then reuses that US session over fast HTTP).
## Actor input object example
```json
{
"location": [
"New York, NY"
],
"storeUrls": [],
"includeMenu": false,
"includeReviews": false,
"maxStores": 50,
"proxyConfiguration": {
"useApifyProxy": true,
"apifyProxyGroups": [
"RESIDENTIAL"
],
"apifyProxyCountry": "US"
}
}
```
# Actor output Schema
## `datasetItems` (type: `string`):
All extracted DoorDash stores (with menus/reviews when enabled) for this run.
## `overviewTable` (type: `string`):
A clean, human-readable table view of the scraped stores.
# 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 '' with your token
const client = new ApifyClient({
token: '',
});
// Prepare Actor input
const input = {
"location": [
"New York, NY"
],
"maxStores": 50,
"proxyConfiguration": {
"useApifyProxy": true,
"apifyProxyGroups": [
"RESIDENTIAL"
],
"apifyProxyCountry": "US"
}
};
// Run the Actor and wait for it to finish
const run = await client.actor("haketa/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 '' with your token.
client = ApifyClient("")
# Prepare the Actor input
run_input = {
"location": ["New York, NY"],
"maxStores": 50,
"proxyConfiguration": {
"useApifyProxy": True,
"apifyProxyGroups": ["RESIDENTIAL"],
"apifyProxyCountry": "US",
},
}
# Run the Actor and wait for it to finish
run = client.actor("haketa/doordash-scraper").call(run_input=run_input)
# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
print(item)
# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start
```
## CLI example
```bash
echo '{
"location": [
"New York, NY"
],
"maxStores": 50,
"proxyConfiguration": {
"useApifyProxy": true,
"apifyProxyGroups": [
"RESIDENTIAL"
],
"apifyProxyCountry": "US"
}
}' |
apify call haketa/doordash-scraper --silent --output-dataset
```
## MCP server setup
```json
{
"mcpServers": {
"apify": {
"type": "http",
"url": "https://mcp.apify.com/?tools=fetch-actor-details,haketa/doordash-scraper"
}
}
}
```
The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer ` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).
## OpenAPI specification
Download the OpenAPI definition: https://api.apify.com/v2/actors/whZYU8QNQh2V18FMc/builds/Io4gAqgCoU3fks6Kl/openapi.json