# Restaurant Leads Scraper — Emails & Rank (`pequod-labs/restaurant-leads`) Actor

Restaurant lead scraper for agencies and SaaS that sell to restaurants. Google Maps listing with booking platforms, website emails, optional local-pack rank and review velocity. City, postal codes or country sweep. No review text, photos or menus. Pay per restaurant delivered.

- **URL**: https://apify.com/pequod-labs/restaurant-leads.md
- **Developed by:** [Pequod](https://apify.com/pequod-labs) (community)
- **Categories:** Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.87 / 1,000 restaurant delivereds

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?

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

## Restaurant Leads Scraper — Emails & Rank

**Apify slug:** [pequod-labs/restaurant-leads](https://apify.com/pequod-labs/restaurant-leads)

A **restaurant email list** tool for teams that **sell to restaurants**: review software, reservation platforms, websites, POS, photography. It searches **Google Maps** by city, postal code or country sweep (`countryCode` is required), then delivers structured restaurant leads — phone, address, rating, **booking platforms**, **delivery platforms**, website kind — with optional **website emails**, **Instagram**, **local-pack rank** and **review velocity**. You pay per restaurant delivered on Apify. **No review text, no photos, no menus.** No Google Maps API key and no proxies on your side.

Click **Start** in the Apify Console with the prefilled country (Italy) to try a capital-city demo. On the **Apify free plan** that demo is the whole allowance: **20 restaurants per run and 20 per UTC day** (website emails, Instagram, delivery). Country sweep, local-pack rank, review velocity and Facebook stay off until you are on a paid Apify plan. Paid plans have no actor-side cap — you still pay per event.

| | |
|---|---|
| **Input** | `countryCode` plus a city (`locationQuery`), postal codes, coordinates, or country sweep |
| **Output** | One restaurant lead per row: listing, emails, booking/delivery ids, optional rank and owner |
| **Pricing** | Pay per event — `place-scraped` plus add-ons only when data is delivered. Free-plan demo: 20 restaurants / UTC day |
| **API keys** | None required from you (operator-side Maps access) |
| **Best for** | Outbound to restaurants: email list, no-website prospects, owner name, booking/delivery stack |
| **Not for** | Menu scrape, review-text dump, POS detection, or a bought 700k-row US file |

### Use this actor when

- You need a **restaurant email list from Google Maps** for a city, CAP/ZIP list, or country
- You sell **to restaurants** (reviews, reservations, websites, operations) and want ICP filters before billing
- You want **restaurants without a website** (`websiteKind: none`) for web-agency prospecting
- You want a **restaurant owner email list** grounded on the site or Instagram bio (`findOwner`)
- You need **TheFork / OpenTable / Deliveroo / Just Eat / Uber Eats / DoorDash** as fields, not as a second crawl of menus

### Do not use this actor when

- You want **restaurant menus** or dish prices — not in this actor (and that query has no useful Google volume)
- You want a **full Google Maps review / photo archive** — use a category Maps crawler; we store **counts only**
- You want **POS / Toast / Square** detection — we do not invent a tech stack
- You want a **static restaurant database** bought by US state — this is an on-demand scrape, not a mailing-list file
- You need **any local business** (plumbers, dentists) — use [Google Maps Local Leads](https://apify.com/pequod-labs/google-maps-local-leads)

### How it works

1. **Map search** — `countryCode` is required (no silent Italy default on the API). Leave `searchTerms` empty to use local keywords (`ristorante`/`pizzeria` in Italy, `restaurante` in Spain, `restaurant`/`pizzeria` elsewhere). Set a city, postal codes, coordinates, or country sweep. If you only pick a country in Console, the actor searches that country's capital so Start does not fail.
2. **ICP filter** — `tableServiceOnly` (default on) drops hotels and takeaway **before billing**. `websiteKind` keeps owned sites, aggregator pins, or no-website listings.
3. **Listing parse** — name, category, address, postal code, phone, rating, review count, Maps URL, `bookingLinks`, `reservationPlatforms`, `deliveryPlatforms`, `mapsWebsiteKind`.
4. **Export** — Apify dataset (JSON/CSV/API). Add-ons (website emails, Instagram, delivery search, rank **per cell**, review velocity, owner) bill only when delivered.

### Get a restaurant email list from Google Maps

Enable **Extract website contacts** (default on). Emails come from the restaurant’s **official website** on the Maps pin — not invented `nome.cognome@` patterns and not a purchased list. A 20-restaurant city run is the intended first try (`maxPlaces` default 20). On the Apify free plan that is also the daily cap.

This is the on-demand alternative to a **restaurant database** or **restaurant mailing list**: you choose the city, you get current Maps rows, you pay per restaurant delivered.

### Find restaurants without a website

Set `websiteKind` to **No website**. Hotels and shops stay out when `tableServiceOnly` is on. Use this for agencies that sell sites to restaurants that only have a Maps pin or a Facebook page.

### Restaurant owner email list

Set `findOwner` to find a named owner or chef-patron on the website or Instagram bio (Italian `titolare`/`gestito da`, German Impressum, French `gérant`, English `owned by`). If the page has no patron copy, a **mailbox already on the site** can still name them: `roberto.ammendola@` or `marco@` (first name alone is enough). Brand/franchise inboxes are skipped (`michele@` on Da Michele, `ducciopizza@`). The lookup is `recover_restaurant_owner` — on-domain only. Email is attached only if that person’s address already appears on the page. Not LinkedIn, not SMTP-guessed. Charged as `decision-maker` when a person name is grounded.

### Booking platforms (TheFork, Quandoo, CoverManager, Google Reserve)

Maps already exposes reservation URLs on the pin. This actor **keeps them** and normalizes `reservationPlatforms`. A homepage crawl is the wrong primary detector — widget-only sites would look like they have no booking.

### Delivery (Deliveroo, Just Eat, Uber Eats, Glovo, DoorDash)

Delivery hosts on the pin go to `deliveryPlatforms`, not `reservationPlatforms`. With `enrichDeliverySearch` (default on) the actor runs **one** country-scoped `site:` search per restaurant and keeps an id only when the URL is a **venue page** that names this restaurant in this city or postal code. Neighbourhood indexes, dish pages, DoorDash `/business/` hubs and namesakes in another city are dropped. **No menus.** Billed as `delivery-platforms` only when search adds an id missing from the pin. US search includes DoorDash `/store/{slug}`.

### Local-pack rank (add-on, per cell)

Rank is a property of a **query** such as `pizzeria 00153`, not of the restaurant forever. The actor runs **one Maps query per cell**, then joins `position` by `placeId`. Honest for “are they visible in this neighbourhood?” — not a national ranking and not one paid query per TAM row.

### Review velocity (add-on, counts only)

Newest-first review timestamps → reviews in the last 7 and 30 days, owner reply rate in that sample, plus the gap vs the pack leader when rank ran. **No review text, no photos, no snippets in the dataset.**

### How it compares

| Approach | Typical focus | This actor |
|----------|---------------|------------|
| Full Maps crawlers | Reviews, photos, menus | Lead-first: emails, booking/delivery ids, rank **per cell** |
| Static restaurant email lists | Buy a US-state file | On-demand Google Maps scrape for the city you choose |
| Generic Maps email extractors | Any category | Restaurant ICP, table-service filter, delivery/booking stack |

### How much does it cost?

Pay-per-event on Apify (configure list prices in Console). The Apify **free plan** is $5 of platform credits per month with **no daily reset** — without an actor-side cap that would be a full-day scrape on our Maps / Instagram / website-fetch costs. Free-plan users therefore get an honest city demo: **20 restaurants per run and 20 per UTC day**. Paid Apify plans (including an Apify trial) are not clamped.

| Event | When charged |
|-------|----------------|
| `apify-actor-start` | Once at run start (platform) |
| `place-scraped` | Each restaurant delivered |
| `website-contacts` | Email or phone found on the site |
| `instagram-profile` | Instagram profile delivered |
| `facebook-page` | Facebook page delivered (opt-in) |
| `delivery-platforms` | Search added a delivery id missing from the Maps pin |
| `local-rank` | Once per ranked cell (restaurants in that cell join free) |
| `review-velocity` | Velocity computed for that restaurant |
| `decision-maker` | Named owner/chef-patron grounded on the site or Instagram bio |

Your **spending limit** caps how many `place-scraped` events can fire. Filtered hotels/takeaway never bill.

### Country sweep and postal codes

- **City run:** `locationQuery` + `radiusKm`. Empty location + `countryCode` → capital city.
- **CAP / ZIP list:** `postalCodes` — each code is its own cell.
- **Country sweep:** locality-by-locality with resumable state. Do not mix sweep with CAP list or city query. **Paid Apify plan only** — free-plan runs are rejected with an upgrade link. Do not treat a sweep as a completed national TAM until you have a regional `RUN_SUMMARY`.

### Example output

```json
{
  "name": "Trattoria Da Mario",
  "placeId": "ChIJ…",
  "postalCode": "00153",
  "mapsWebsiteKind": "owned",
  "reservationPlatforms": ["thefork"],
  "deliveryPlatforms": ["deliveroo"],
  "emails": ["info@trattoriadamario.it"],
  "rank": { "query": "ristorante 00153", "position": 4, "packSize": 20, "reviewGapVsLeader": 210 },
  "reviewVelocityMonth": 11,
  "ownerReplyRate": 0.5,
  "sameBrandInRun": 1,
  "whatsapp": { "link": "https://wa.me/39333…", "evidence": "wa.me" }
}
```

### Cost estimate

A 20-restaurant city run with contacts + Instagram is listing events plus contact/IG hits. Rank on a handful of CAP cells is a few `local-rank` events, not one Maps query per row. Delivery search is one query per restaurant when enabled.

### FAQ

**How do I generate restaurant leads using Google Maps?** Set `countryCode`, a city or postal codes, and Start. Default search terms follow the country. ICP filters drop hotels before you are billed.

**How do I extract emails from Google Maps restaurants?** Enable website contacts (default on). Emails come from the official website on the pin, not from a purchased restaurant email list.

**Is it legal to buy an email list?** Buying a stale file and scraping public Maps listings are different products and different legal analyses. You are the data controller for anything you export — get counsel before outbound.

**Is it legal to scrape data from Google Maps?** This actor collects public listing fields and, when enabled, contacts published on linked websites. Laws vary (GDPR, anti-spam). Do not treat this README as legal advice.

**Is there a free restaurant scraper on Apify?** Yes as a demo, not as a database. Apify free-plan users get **20 restaurants per run and 20 per UTC day** (contacts, Instagram, delivery). Country sweep, rank, review velocity and Facebook are paid-plan only. There is no unlimited free restaurant list.

**How do I find restaurants without a website on Google Maps?** Set `websiteKind` to `none`.

**Can I scrape restaurants for an entire country?** On a **paid Apify plan**, yes — `countrySweep` with a supported `countryCode`, or pass `postalCodes`. Resume from the saved cursor. Free-plan users cannot start a country sweep (at most 3 postal codes, 20 restaurants / day).

**Do I need a Google Maps API key or proxies?** No.

**Do you scrape Google Maps reviews or photos?** No. Velocity is a **count** from timestamps. Owner replies are a **rate**. Rank is pack position for a cell query. **No review text.**

**Where do emails come from?** The restaurant’s official website linked on Maps.

**How is the owner found?** On-domain current-operator language plus Instagram bio. A person mailbox already on the page (`roberto.ammendola@`, `marco@`) counts; a brand/franchise inbox (`michele@` on Da Michele) does not. No name on the page or in a person mailbox → no `decision-maker` charge.

**How do I get WhatsApp?** `wa.me` on the site or Maps links, or WhatsApp mentioned in the Instagram bio.

**Come estrarre email e contatti dai ristoranti su Google Maps?** Imposta `countryCode` (es. `IT`), una città o i CAP, lascia attivi i contatti dal sito. Le email arrivano dal sito ufficiale sul pin, non da una lista comprata.

### Pequod ecommerce pipeline

| Step | Actor | When |
|------|-------|------|
| 1. Discover restaurants | **Restaurant Leads** (this actor) | Sell to restaurants by area / CAP / country |
| 1. Discover local businesses | [Google Maps Local Leads](https://apify.com/pequod-labs/google-maps-local-leads) | Horizontal local leads (any category) |
| 1. Discover | [Lookalike Discovery](https://apify.com/pequod-labs/ecommerce-lookalike-discovery) | Domain/niche-based ecommerce stores |
| 1. Discover | [Instagram TikTok Shop Leads](https://apify.com/pequod-labs/instagram-tiktok-shop-leads) | Hashtag-driven social sellers |
| 2. Enrich contact | [Decision Maker Finder](https://apify.com/pequod-labs/company-decision-maker-finder) | Named decision makers on a company domain |
| 3. Enrich shipping | [Shipping Intelligence](https://apify.com/pequod-labs/ecommerce-shipping-intelligence) | Carriers and policies for ecommerce sites |

# Actor input Schema

## `searchTerms` (type: `array`):

Maps keywords. Defaults follow the country: <code>ristorante</code>/<code>pizzeria</code> in Italy, <code>restaurante</code> in Spain/LatAm, <code>restaurant</code>/<code>pizzeria</code> elsewhere. Override for sushi, trattoria, steakhouse, etc. Up to 20 terms.

## `locationQuery` (type: `string`):

Human-readable area — e.g. <code>Rome, Italy</code> or <code>Trastevere Roma</code>. Use this <b>or</b> coordinates <b>or</b> postalCodes <b>or</b> countrySweep.

## `postalCodes` (type: `array`):

Postal codes for the selected <code>countryCode</code>. Each code is its own Maps cell. IT/FR/ES/DE must be 5 digits; US is ZIP or ZIP+4; GB is outward+inward (e.g. <code>SW1A 1AA</code>). Cannot combine with locationQuery, coordinates, or countrySweep. Apify free-plan users keep the first 3 codes.

## `latitude` (type: `number`):

Center latitude when you already have coordinates. Requires <code>longitude</code>.

## `longitude` (type: `number`):

Center longitude when you already have coordinates. Requires <code>latitude</code>.

## `radiusKm` (type: `number`):

Radius around the center point. Capped at 50 km.

## `countryCode` (type: `string`):

Required. ISO country for Maps results, search-term defaults, and owner legal pages. Not inferred from coordinates. If you leave location empty, the actor searches the capital of this country.

## `languageCode` (type: `string`):

Two-letter interface language for Maps. Defaults from country when omitted.

## `maxPlaces` (type: `integer`):

Upper bound on billable restaurants pushed to the dataset. Apify free-plan users are capped at 20 per run and 20 per UTC day.

## `queryBudgetMultiplier` (type: `integer`):

Raises the upstream Maps query cap for a given maxPlaces. Does NOT change place-scraped billing. If RUN\_SUMMARY.queryBudgetExhausted is true, rerun with queryBudgetMultiplier = RUN\_SUMMARY.suggestedQueryBudgetMultiplier.

## `tableServiceOnly` (type: `boolean`):

Drop hotels, shops, takeaway-only and off-target Maps categories <b>before billing</b>. Default on — this actor sells restaurant leads, not every food pin.

## `minRating` (type: `number`):

Skip restaurants below this Google rating (0–5). Leave empty for no filter.

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

Skip listings below this Google review count. Filtered before billing.

## `websiteKind` (type: `string`):

<b>any</b>: all. <b>owned</b>: only restaurants with their own site on Maps (not Facebook/Quandoo). <b>none</b>: no website on the pin — web agencies. <b>aggregator</b>: Quandoo/TheFork as the Maps website.

## `websiteFilter` (type: `string`):

<b>any</b> / <b>has</b> / <b>none</b> — whether Maps shows a website URL, regardless of kind. Prefer <code>websiteKind</code> for owned vs social vs aggregator.

## `enrichWebsiteContacts` (type: `boolean`):

Visit each owned website for public emails, phones and social links. Billed as <code>website-contacts</code> only when an email or phone is found. Social links alone are free.

## `enrichInstagram` (type: `boolean`):

When an Instagram handle is on the Maps pin or the website, fetch followers, last post date, posts in the last 90 days, reel share, WhatsApp-in-bio and external URL. Billed as <code>instagram-profile</code> only when a profile is delivered. Does not dump posts or captions.

## `enrichFacebook` (type: `boolean`):

Fetch Facebook page followers and public contact fields. Off by default — more expensive than Instagram for weaker WhatsApp signal. Billed as <code>facebook-page</code> only when a page is delivered. Paid Apify plan only; ignored on the free plan.

## `enrichRanking` (type: `boolean`):

One Maps query per postal code / city cell (<code>pizzeria 00153</code>), then join rank by placeId. Not one query per restaurant. Billed as <code>local-rank</code> once per cell ranked. Use this for 'how visible is this restaurant nearby', not a national ranking. Paid Apify plan only; ignored on the free plan.

## `enrichReviewVelocity` (type: `boolean`):

Count Google reviews in the last 7 and 30 days from newest-first timestamps, plus how often the owner replied in that sample. No review text, no photos. Billed as <code>review-velocity</code> when velocity is computed. Combine with rank to see the gap vs the local pack leader. Paid Apify plan only; ignored on the free plan.

## `enrichReviewThemes` (type: `boolean`):

Off by default. From the same review fetch as velocity, count in-flight mentions of wait / food / service / price, then discard the snippet. Dataset never contains review text. Uses the <code>review-velocity</code> event (no extra PPE). Leave off if the classifier is too noisy for your market.

## `enrichDeliverySearch` (type: `boolean`):

One web search per restaurant against the country aggregators (Deliveroo, Just Eat, Uber Eats, Glovo, and DoorDash in the US). A platform id is kept only when the result URL is a venue page that names this restaurant in this city or postal code — not a neighbourhood index, dish page, chain hub or a namesake in another city. Billed as <code>delivery-platforms</code> only when search adds at least one id that was missing from the Maps pin. Does not fetch menus.

## `findOwner` (type: `boolean`):

Named owner or chef-patron grounded on the restaurant website or Instagram bio (up to <code>maxDecisionMakers</code>). On-domain current-operator language: Italian patron/gestito da/SAS di/titolare, German Impressum Geschäftsführer/Inhaber, French gérant, English owned by/chef-owner, Spanish propietario, Dutch eigenaar. A person mailbox already on the page counts (first name alone is enough); brand/franchise inboxes are skipped. Not a LinkedIn CEO search. Charged as <code>decision-maker</code> when a person name is found. Email is attached only if it already appears on the page and names that person — never invented, never SMTP-guessed.

## `maxDecisionMakers` (type: `integer`):

Cap on how many restaurants with a website receive an owner lookup this run.

## `countrySweep` (type: `boolean`):

Scrape an entire supported country locality-by-locality. Do not set locationQuery, coordinates, or postalCodes. Progress is saved so the next run resumes without double-charging. Paid Apify plan only — free-plan runs are rejected.

## `sweepRegions` (type: `array`):

Optional region names (e.g. <code>\["Lazio", "Lombardy"]</code>). Requires countrySweep=true.

## `sweepProvinces` (type: `array`):

Optional province names (e.g. <code>\["Roma"]</code>). Requires countrySweep=true.

## `sweepLocalities` (type: `array`):

Optional town names. Requires countrySweep=true.

## `startFromLocality` (type: `string`):

Jump the sweep cursor to this locality name (always overrides the saved cursor for this run).

## `sweepStateName` (type: `string`):

Optional label (1–20 chars) appended to the named key-value store. Use to start a sweep from scratch. Requires countrySweep=true.

## `sweepMinPopulation` (type: `integer`):

Skip localities below this population during country sweep.

## Actor input object example

```json
{
  "locationQuery": "Rome, Italy",
  "radiusKm": 5,
  "countryCode": "IT",
  "maxPlaces": 20,
  "queryBudgetMultiplier": 3,
  "tableServiceOnly": true,
  "websiteKind": "any",
  "websiteFilter": "any",
  "enrichWebsiteContacts": true,
  "enrichInstagram": true,
  "enrichFacebook": false,
  "enrichRanking": false,
  "enrichReviewVelocity": false,
  "enrichReviewThemes": false,
  "enrichDeliverySearch": true,
  "findOwner": false,
  "maxDecisionMakers": 50,
  "countrySweep": false,
  "sweepMinPopulation": 1000
}
```

# Actor output Schema

## `leads` (type: `string`):

No description

## `runSummary` (type: `string`):

No description

# 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 = {
    "locationQuery": "Rome, Italy",
    "countryCode": "IT"
};

// Run the Actor and wait for it to finish
const run = await client.actor("pequod-labs/restaurant-leads").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 = {
    "locationQuery": "Rome, Italy",
    "countryCode": "IT",
}

# Run the Actor and wait for it to finish
run = client.actor("pequod-labs/restaurant-leads").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 '{
  "locationQuery": "Rome, Italy",
  "countryCode": "IT"
}' |
apify call pequod-labs/restaurant-leads --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,pequod-labs/restaurant-leads"
        }
    }
}

```

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 <APIFY_API_TOKEN>` 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/72SzTC0OawZXzC08C/builds/i0zoOdewAT9aDw27P/openapi.json