# Yelp Scraper — Leads, Reviews & Contacts (`sleek_waveform/yelp-scraper`) Actor

Extract Yelp business listings: phone, website, address, reviews, ratings, hours, categories. Build B2B lead lists and monitor competitors.

- **URL**: https://apify.com/sleek\_waveform/yelp-scraper.md
- **Developed by:** [Daniel Dimitrov](https://apify.com/sleek_waveform) (community)
- **Categories:** Lead generation
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 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.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

The **Yelp Scraper** extracts business listings, contact info, reviews, ratings, and operating hours from [Yelp](https://www.yelp.com) — no Yelp Fusion API key, no coding, no subscriptions. Enter search terms and locations (or paste direct business URLs) and the Yelp Scraper returns a clean, deduplicated dataset of every matching business in JSON, CSV, or Excel. Built for B2B lead generation, local-SEO research, competitor analysis, and review monitoring.

This Apify Actor scrapes Yelp pages using a fast HTTP-only crawler with residential proxy support, automatic retries, and global result deduplication so the same business is never billed twice.

### Features of the Yelp Scraper

- **Search Yelp by keyword + location** — any city, state, or ZIP code
- **Direct Yelp business URL scraping** — paste URLs and skip search
- **Full business details** — name, phone, website, address, rating, review count, categories, price range, hours, amenities, "About the Business"
- **Extract Yelp reviews** — rating, date, text, author, friend count, photo count, useful/funny/cool votes
- **Sort reviews** — newest, oldest, highest rating, lowest rating, or Yelp Elite only
- **Pagination handled automatically** — respects your `maxResults` cap across pages
- **Business deduplication** — the same Yelp business is never returned twice across searches
- **Residential proxy rotation** — Yelp blocks datacenter IPs; residential is the default
- **Webhook notifications** — optional POST to your endpoint when the run completes
- **Export** — JSON, CSV, Excel, HTML, or XML via Apify datasets

### Why use this Yelp Scraper

Yelp has no free public API for bulk data. The official [Yelp Fusion API](https://fusion.yelp.com/) costs from $229/month, caps you at 500 calls/day on the lowest paid tier, and returns truncated review text. This Yelp Scraper solves all four problems:

| Yelp data problem | How the Yelp Scraper handles it |
|---|---|
| No free Yelp API | Pay-per-result — no subscription, no minimum |
| Fusion API returns 3-review snippets | Extract up to 50 full reviews per business |
| Yelp blocks datacenter IPs | Residential proxy group enabled by default |
| Duplicate results across search terms | Global deduplication keyed by canonical URL |
| Geographic limits on Fusion API | Scrape any Yelp domain: `.com`, `.ie`, `.co.uk`, `.ca`, more |

### How to use the Yelp Scraper (tutorial)

#### Step 1 — Open the Actor

Click **Try for free** on this page to open the Yelp Scraper in the [Apify Console](https://console.apify.com/).

#### Step 2 — Enter search terms

Type what you're looking for in **Search Terms** — for example `restaurants`, `plumbers`, `dentists`, `hair salons`. Add one or more.

#### Step 3 — Enter locations

Add cities, states, or ZIPs in **Locations** — for example `San Francisco, CA`, `94105`, `Manhattan NY`, `Austin, TX`.

#### Step 4 — (Optional) Paste direct URLs

If you already have Yelp business URLs, paste them into **Start URLs** to skip the search step entirely.

#### Step 5 — Set limits and start

Set **Max Results per Search** (default 50), **Max Reviews per Business** (default 5), and click **Start**. Results stream into the dataset as they scrape. Export from the **Dataset** tab in the format you need.

#### Call the Yelp Scraper from code

JavaScript:

```javascript
const { ApifyClient } = require('apify-client');
const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });

const run = await client.actor('YOUR_USERNAME/yelp-scraper').call({
  searchTerms: ['restaurants'],
  locations: ['San Francisco, CA'],
  maxResults: 50,
  maxReviewsPerBusiness: 5,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
````

Python:

```python
from apify_client import ApifyClient
client = ApifyClient('YOUR_APIFY_TOKEN')

run = client.actor('YOUR_USERNAME/yelp-scraper').call(run_input={
    'searchTerms': ['plumbers'],
    'locations': ['Austin, TX'],
    'maxResults': 100,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
```

CLI:

```bash
apify call YOUR_USERNAME/yelp-scraper -i '{"searchTerms":["coffee"],"locations":["Seattle, WA"]}'
```

### Pricing — how much does the Yelp Scraper cost

The Yelp Scraper is priced per result (pay-per-event). You pay only for each business returned — reviews on each business are free.

| Tier | Price | Best for |
|---|---|---|
| Free trial | First results free | Quality check |
| Pay-per-result | ~$4.00 / 1,000 businesses | Ongoing scraping, any volume |

Residential proxy bandwidth and Apify platform compute are included. No monthly fee, no setup cost, no per-seat pricing.

#### Rough volume examples (at $4.00 / 1,000 businesses)

| Job | Businesses | Estimated cost |
|---|---|---|
| 50 restaurants in one city | 50 | ~$0.20 |
| 500 plumbers across Texas | 500 | ~$2.00 |
| 5,000 dentists across a state | 5,000 | ~$20 |
| 50,000 nationwide leads | 50,000 | ~$200 |

### Input

Open the **Input** tab on the Actor page for the interactive form. Main fields:

| Field | Type | Default | Description |
|---|---|---|---|
| `searchTerms` | string\[] | — | What to search for (`restaurants`, `plumbers`, `dentists`) |
| `locations` | string\[] | — | Cities, states, or ZIPs (`San Francisco, CA`, `94105`) |
| `startUrls` | string\[] | — | Direct Yelp business URLs — skips search |
| `maxResults` | integer | `50` | Max businesses per search term/location pair |
| `maxReviewsPerBusiness` | integer | `5` | Max reviews per business (0 to skip reviews) |
| `reviewSortBy` | string | `newest` | `newest`, `oldest`, `highest_rating`, `lowest_rating`, `elites` |
| `proxyConfiguration` | object | Residential | Proxy config — residential strongly recommended |
| `webhookUrl` | string | — | Optional POST on run completion |

### Output example

The Yelp Scraper returns one record per business. Reviews are nested inside each business record.

```json
{
  "businessName": "Desnudo Coffee",
  "phone": "(424) 400-1857",
  "address": "2505 Webberville Rd, Austin, TX, 78702",
  "website": "http://www.desnudocoffee.com",
  "rating": 4.7,
  "reviewCount": 331,
  "categories": ["Coffee Roasteries"],
  "priceRange": "$$",
  "hours": {
    "Monday": "7:00 AM - 2:00 PM",
    "Tuesday": "7:00 AM - 2:00 PM",
    "Wednesday": "7:00 AM - 2:00 PM",
    "Thursday": "7:00 AM - 2:00 PM",
    "Friday": "7:00 AM - 2:00 PM",
    "Saturday": "7:30 AM - 2:30 PM",
    "Sunday": "7:30 AM - 2:30 PM"
  },
  "mapUrl": "https://www.google.com/maps/search/?api=1&query=30.263001,-97.713647",
  "amenities": [
    "Offers delivery",
    "Offers take-out",
    "Wheelchair accessible",
    "Accepts credit cards",
    "Good for working",
    "Street parking",
    "Covered outdoor seating",
    "Bike parking"
  ],
  "about": "Charming coffee trailer in East Austin with farm-to-trailer brews and vibrant music.",
  "url": "https://www.yelp.com/biz/desnudo-coffee-austin",
  "reviews": [
    {
      "rating": 5,
      "date": "2026-04-14",
      "text": "Wonderful coffee shop run by the sweetest brothers...",
      "author": "Shannon S.",
      "authorFriendCount": 0,
      "authorPhotoCount": 4,
      "usefulCount": 0,
      "funnyCount": 0,
      "coolCount": 0
    }
  ],
  "scrapedAt": "2026-04-24T04:14:34.238Z"
}
```

#### Output preview (CSV)

| businessName | phone | address | website | rating | reviewCount | categories | priceRange |
|---|---|---|---|---|---|---|---|
| Desnudo Coffee | (424) 400-1857 | 2505 Webberville Rd, Austin, TX | desnudocoffee.com | 4.7 | 331 | Coffee Roasteries | $$ |

### Use cases for the Yelp Scraper

- **B2B lead generation** — pull prospect lists with verified phone numbers, websites, and addresses for any industry in any city
- **Competitor analysis** — monitor rival businesses' Yelp ratings, review counts, and category tags over time
- **Review monitoring** — track customer sentiment; sort by `lowest_rating` for reputation management alerts
- **Local SEO research** — analyze category saturation, average ratings, and price ranges in a given market
- **Sales outreach** — power cold email and cold call lists with enriched business data
- **Market research** — segment local markets by category density, review volume, or rating distribution

### Integrations

The Yelp Scraper dataset connects to:

- **Zapier, Make, n8n** — trigger workflows when a run finishes (use `webhookUrl`)
- **Google Sheets, Airtable, HubSpot, Salesforce** — through official [Apify integrations](https://docs.apify.com/platform/integrations)
- **Webhooks, REST API, JS/Python clients** — programmatic control via the [Apify API](https://docs.apify.com/api/v2)

### Schedule Yelp Scraper runs

Open the Actor page, click **Schedule**, and pick a cron interval. Use scheduled runs to refresh lead lists weekly, alert on new negative reviews daily, or run monthly competitor scans. See the [Apify Schedules docs](https://docs.apify.com/platform/schedules).

```javascript
const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });
await client.schedules().create({
  actions: [{
    type: 'RUN_ACTOR',
    actorId: 'YOUR_USERNAME/yelp-scraper',
    runInput: { body: JSON.stringify({ searchTerms: ['restaurants'], locations: ['San Francisco, CA'] }) },
  }],
  cronExpression: '0 9 * * 1',
});
```

### Other Apify Actors you may like

- **Threads Scraper — Posts, Profiles & Metrics** — scrape Meta Threads profiles, posts, hashtags, and search with engagement metrics
- **Google Maps Scraper** — extract business leads straight from Google Maps
- **Yellow Pages Scraper** — alternative local-business data source
- **Instagram Scraper** — pull profiles and posts for social-lead enrichment
- **LinkedIn People Scraper** — decision-maker contact data for B2B outreach

### FAQ

#### Is scraping Yelp legal?

The Yelp Scraper only extracts **publicly available data** from business listing pages — the same data a visitor sees without logging in. It does not access private messages, Yelp-for-Business dashboards, or data behind authentication. Always comply with [Yelp's Terms of Service](https://terms.yelp.com/tos/en_us/) and applicable data-protection laws.

#### Yelp Fusion API vs Yelp Scraper — which should I use?

The [Yelp Fusion API](https://fusion.yelp.com/) starts at **$229/month**, limits you to 500 requests/day on the lowest paid tier, and returns only 3 truncated review snippets per business. The Yelp Scraper is pay-per-result (no monthly fee), has no daily cap, and extracts **full review text** up to 50 reviews per business. For anything beyond a light hobby project, the scraper is cheaper and more complete.

#### Do I need a Yelp account or API key?

No. The Yelp Scraper works without any Yelp account, developer key, or sign-up. Just enter search terms or URLs and run.

#### Can I scrape all reviews for a Yelp business?

Yes. Set `maxReviewsPerBusiness` up to 50 per business. Use `reviewSortBy: "lowest_rating"` to surface negative reviews first for reputation monitoring.

#### How do I avoid getting blocked by Yelp?

Yelp has aggressive bot detection. The Yelp Scraper enables **residential proxy rotation** by default, which is the only reliable way to scrape Yelp at scale. Datacenter proxies will produce 403 errors.

#### How do I scrape Yelp reviews without coding?

Open the Yelp Scraper in the Apify Console, enter search terms and locations, set `maxReviewsPerBusiness` to the number of reviews you want, and click **Start**. No code required.

#### Can the Yelp Scraper scrape non-US Yelp sites?

Yes. The scraper handles any Yelp domain — `.com`, `.ca`, `.co.uk`, `.ie`, `.fr`, and more. Just paste URLs from the target country into `startUrls`, or use location terms recognized by that country's Yelp.

#### How do I export Yelp results as CSV or Excel?

After the run finishes, open the **Dataset** tab and click **Export**. Choose JSON, CSV, Excel, HTML, or XML. The dataset includes preset views (Business Overview, B2B Leads Export, Full Details + Reviews).

#### Can I schedule the Yelp Scraper to run automatically?

Yes. Use **Schedules** in the Apify Console to run the Yelp Scraper on any cron expression — daily, weekly, monthly, or custom. See the code example above.

#### How much does it cost to scrape 10,000 Yelp businesses?

At $4.00 per 1,000 businesses, scraping 10,000 Yelp listings costs **~$40**. Reviews extracted for those businesses are included in the per-business price.

### Troubleshooting

#### 403 Forbidden errors

- Confirm `proxyConfiguration` is set to the `RESIDENTIAL` group (default)
- Datacenter proxies will not work against Yelp

#### Empty review arrays

- Yelp occasionally A/B-tests review layouts; lower `maxReviewsPerBusiness` to 5–10 and retry
- Some businesses genuinely have 0 reviews

#### Wrong country results

- Yelp may redirect US searches to a country version. Use `startUrls` with the exact Yelp URL to pin the result to one country

### Support

- Review the **Troubleshooting** section above
- Read the [Apify Actor development docs](https://docs.apify.com/platform/actors/development)
- Open an issue on GitHub or contact the developer through the Actor page

### License

MIT

# Actor input Schema

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

What to search for (e.g. restaurants, plumbers, dentists)

## `locations` (type: `array`):

Cities, states, or zip codes to search (e.g. San Francisco CA, 94105, Manhattan NY)

## `startUrls` (type: `array`):

Direct Yelp business page URLs to scrape (skips search). Add one URL per line.

## `maxResults` (type: `integer`):

Maximum number of business results to extract per search term/location combination

## `maxReviewsPerBusiness` (type: `integer`):

Maximum number of reviews to extract per business (0 to skip reviews)

## `reviewSortBy` (type: `string`):

How to sort reviews when extracting

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

Residential proxies recommended for Yelp to avoid blocks. Datacenter proxies will get 403 errors.

## `webhookUrl` (type: `string`):

Optional URL to receive a POST notification when the run completes

## Actor input object example

```json
{
  "searchTerms": [
    "restaurants"
  ],
  "locations": [
    "San Francisco, CA"
  ],
  "startUrls": [],
  "maxResults": 50,
  "maxReviewsPerBusiness": 5,
  "reviewSortBy": "newest",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `datasetUrl` (type: `string`):

Download the full dataset in JSON, CSV, or Excel.

## `consoleUrl` (type: `string`):

View the run results in the Apify Console.

# 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 = {
    "searchTerms": [
        "restaurants"
    ],
    "locations": [
        "San Francisco, CA"
    ],
    "startUrls": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("sleek_waveform/yelp-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 = {
    "searchTerms": ["restaurants"],
    "locations": ["San Francisco, CA"],
    "startUrls": [],
}

# Run the Actor and wait for it to finish
run = client.actor("sleek_waveform/yelp-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 '{
  "searchTerms": [
    "restaurants"
  ],
  "locations": [
    "San Francisco, CA"
  ],
  "startUrls": []
}' |
apify call sleek_waveform/yelp-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Yelp Scraper — Leads, Reviews & Contacts",
        "description": "Extract Yelp business listings: phone, website, address, reviews, ratings, hours, categories. Build B2B lead lists and monitor competitors.",
        "version": "1.0",
        "x-build-id": "Wt2AFzlxNn7CDPhK0"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/sleek_waveform~yelp-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-sleek_waveform-yelp-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/sleek_waveform~yelp-scraper/runs": {
            "post": {
                "operationId": "runs-sync-sleek_waveform-yelp-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/sleek_waveform~yelp-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-sleek_waveform-yelp-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "searchTerms": {
                        "title": "Search Terms",
                        "minItems": 0,
                        "maxItems": 20,
                        "type": "array",
                        "description": "What to search for (e.g. restaurants, plumbers, dentists)",
                        "items": {
                            "type": "string"
                        }
                    },
                    "locations": {
                        "title": "Locations",
                        "minItems": 0,
                        "maxItems": 20,
                        "type": "array",
                        "description": "Cities, states, or zip codes to search (e.g. San Francisco CA, 94105, Manhattan NY)",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Start URLs",
                        "minItems": 0,
                        "maxItems": 100,
                        "type": "array",
                        "description": "Direct Yelp business page URLs to scrape (skips search). Add one URL per line.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "Max Results per Search",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of business results to extract per search term/location combination",
                        "default": 50
                    },
                    "maxReviewsPerBusiness": {
                        "title": "Max Reviews per Business",
                        "minimum": 0,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Maximum number of reviews to extract per business (0 to skip reviews)",
                        "default": 5
                    },
                    "reviewSortBy": {
                        "title": "Review Sort Order",
                        "enum": [
                            "newest",
                            "oldest",
                            "highest_rating",
                            "lowest_rating",
                            "elites"
                        ],
                        "type": "string",
                        "description": "How to sort reviews when extracting",
                        "default": "newest"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Residential proxies recommended for Yelp to avoid blocks. Datacenter proxies will get 403 errors.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    },
                    "webhookUrl": {
                        "title": "Webhook URL",
                        "type": "string",
                        "description": "Optional URL to receive a POST notification when the run completes"
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
