# Yelp Reviews Scraper — Extract Yelp Business Reviews (`khadinakbar/yelp-reviews-scraper`) Actor

Scrape Yelp business reviews — rating, full text, author, date, photos, owner replies. HTTP-only, MCP-ready.

- **URL**: https://apify.com/khadinakbar/yelp-reviews-scraper.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** Lead generation, MCP servers
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.50 / 1,000 review scrapeds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## Yelp Reviews Scraper

**Scrape Yelp business reviews** — full review text, rating, author, date, photos, owner replies, and business context — for any [Yelp](https://www.yelp.com/) business URL. HTTP-only, MCP-ready, no login required.

### What does Yelp Reviews Scraper do?

Yelp Reviews Scraper extracts **every public review** from one or more [Yelp](https://www.yelp.com/) business pages. Drop in a Yelp business URL (e.g. `https://www.yelp.com/biz/molinari-delicatessen-san-francisco`) or a plain slug; the actor resolves the business, paginates the reviews via Yelp's GraphQL endpoint behind Apify Residential proxies, and pushes one structured JSON record per review to your dataset. You also get one optional business-summary record per URL with the aggregate name, rating, review count, address, and categories.

The actor returns 30+ fields per review: rating, full text, language, ISO date, author name, location, photo, elite status, useful/funny/cool counts, review photos with captions, and the business owner's reply when present. Results are exportable as JSON, CSV, Excel, or via the Apify API. Schedule it daily, plug it into Zapier or Make, or call it from Claude / GPT through the Apify MCP server.

### Why use Yelp Reviews Scraper?

- **Reputation monitoring** — track new 1- and 2-star reviews across all your locations daily and trigger alerts.
- **Competitive intelligence** — pull every review of a rival restaurant, hotel, dentist, or contractor and run sentiment analysis on the corpus.
- **Market research** — see what real customers love or complain about across an entire category (delis, vets, plumbers, etc.).
- **Owner-response auditing** — see which businesses reply to reviews and how fast, with full reply text.
- **AI training data** — collect structured review datasets for fine-tuning, RAG, or LLM evaluation.
- **MCP-ready** — call it directly from Claude or GPT to fetch reviews on demand without a custom backend.

### How to use Yelp Reviews Scraper

1. Find a [Yelp](https://www.yelp.com/) business you want reviews for and copy its URL (e.g., `https://www.yelp.com/biz/the-shake-shack-new-york`).
2. Open this actor's Input tab and paste it into **Yelp business URLs or slugs**. Add more URLs to scrape multiple businesses in one run.
3. Set **Max reviews per business** (default 100). Optionally choose **Sort** (newest first by default), **Language** filter (English only by default), and a **Date from / Date to** window.
4. Click **Start**. The actor charges $0.005 once per business resolved + $0.0005 per review returned.
5. When the run finishes, open the **Output / Dataset** tab to view, download, or export the reviews.

### Input

```json
{
  "startUrls": [
    { "url": "https://www.yelp.com/biz/molinari-delicatessen-san-francisco" },
    { "url": "https://www.yelp.com/biz/the-shake-shack-new-york" }
  ],
  "maxReviewsPerBusiness": 100,
  "sortBy": "date_desc",
  "language": "en",
  "dateFrom": "2025-01-01",
  "dateTo": "2026-06-18",
  "includeBusinessSummary": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"],
    "apifyProxyCountry": "US"
  }
}
````

See the **Input** tab for the full schema with descriptions, defaults, and validation rules.

### Output

Each review record looks like this (simplified):

```json
{
  "recordType": "review",
  "reviewId": "Z5lH1...",
  "businessSlug": "molinari-delicatessen-san-francisco",
  "businessName": "Molinari Delicatessen",
  "businessUrl": "https://www.yelp.com/biz/molinari-delicatessen-san-francisco",
  "businessAvgRating": 4.4,
  "businessReviewCount": 2841,
  "businessCategories": ["Delis", "Sandwiches", "Italian"],
  "businessCity": "San Francisco",
  "businessState": "CA",
  "rating": 5,
  "text": "Best Italian deli in San Francisco — Renato sandwich is unreal …",
  "language": "en",
  "createdAt": "2026-06-15T00:00:00.000Z",
  "createdAtDisplay": "Jun 15, 2026",
  "authorName": "Sarah K.",
  "authorLocation": "Oakland, CA",
  "authorIsElite": true,
  "usefulCount": 12,
  "funnyCount": 0,
  "coolCount": 4,
  "photoUrls": ["https://s3-media0.fl.yelpcdn.com/bphoto/abc/o.jpg"],
  "ownerReply": "Thanks Sarah — see you next visit!",
  "scrapedAt": "2026-06-18T02:50:00.000Z"
}
```

You can download the dataset in various formats such as **JSON, CSV, Excel, HTML, RSS, or XML**, or stream it from the [Apify API](https://docs.apify.com/api/v2).

### Data table

| Field | Type | Description |
|---|---|---|
| `recordType` | string | `review` or `business` |
| `reviewId` | string | Yelp encrypted review id |
| `businessSlug` | string | Business slug from URL |
| `businessName` | string | Display name |
| `businessUrl` | string | Canonical Yelp URL |
| `businessAvgRating` | number | Overall 0–5 rating |
| `businessReviewCount` | integer | Total reviews on the business |
| `businessCategories` | array | Yelp categories |
| `businessAddress` | string | Street address |
| `businessCity` / `businessState` | string | Location |
| `businessPhone` | string | Phone |
| `rating` | number | Review rating 1–5 |
| `text` | string | Full review text |
| `language` | string | ISO language code |
| `createdAt` | string | Review date (ISO 8601) |
| `createdAtDisplay` | string | Yelp display date string |
| `authorName` / `authorLocation` | string | Reviewer name + city |
| `authorIsElite` | boolean | Yelp Elite badge |
| `authorReviewCount` / `authorFriendCount` | integer | Author profile stats |
| `usefulCount` / `funnyCount` / `coolCount` | integer | Review reactions |
| `photoUrls` / `photoCaptions` | array | Review photos |
| `ownerReply` / `ownerReplyAt` | string | Business owner response |
| `previousRatings` | array | Author's prior ratings if updated |
| `tags` | array | Yelp tags |
| `reviewUrl` | string | Deep link to the review |
| `scrapedAt` | string | ISO 8601 scrape timestamp |

### How much does it cost to scrape Yelp reviews?

This actor uses **Pay-Per-Event** pricing — you pay only for what comes back, nothing for failed pages or proxy retries.

| Event | Price |
|---|---|
| Actor start | $0.00005 (one-time per run, scaled by RAM) |
| Business resolved | $0.005 per business URL successfully resolved |
| Review scraped | **$0.0005 per review** ($0.50 per 1,000) |

**Examples:**

- 1 business, 50 reviews → **$0.030**
- 5 businesses, 100 reviews each (500 total) → **$0.275**
- 10 businesses, 500 reviews each (5,000 total) → **$2.55**

All Apify Free plan users get **$5 free credit per month** — that's about 10,000 Yelp reviews on this actor for free. Paid Apify tiers scale the same way.

### Tips and advanced options

- **Cap reviews tightly.** Set `maxReviewsPerBusiness` to what you actually need. Yelp shows newest first by default; for monitoring, 25–50 daily is plenty.
- **Filter by date range** to skip reviews you've already collected — `dateFrom: "2026-06-01"` only returns June reviews and beyond.
- **Use `sortBy: "rating_asc"`** to surface 1-star complaints first when running a triage workflow.
- **Batch up to 50 URLs per run.** This actor handles each business with its own sticky residential proxy session for maximum reliability.
- **Schedule daily** via Apify Schedules and pipe the dataset into Google Sheets, Slack, or your CRM through Zapier / Make.
- **MCP / Claude / GPT** — this actor is exposed via [Apify MCP](https://mcp.apify.com/) as `apify--yelp-reviews-scraper`. Pass it a URL, get back JSON.

### FAQ and disclaimers

**Is scraping Yelp legal?** Public Yelp reviews are publicly accessible. Web scraping of public data is generally legal in most jurisdictions, but you are responsible for ensuring your use of the scraped data complies with Yelp's [Terms of Service](https://www.yelp.com/tos/en_us_b2b), GDPR, CCPA, and any other applicable laws. Do not scrape personal data of EU residents for marketing without a legal basis. This actor is for legitimate research, monitoring, and analytics — not spam or harassment.

**What if a business is blocked?** Yelp uses DataDome anti-bot protection. This actor uses Apify Residential US proxies with sticky sessions and full browser fingerprints to bypass it, but very rare runs may fail. Re-run the actor or contact us via the Issues tab.

**Can you get reviews from a private / hidden listing?** No — only public reviews on a public Yelp business page.

**Need a custom solution?** Open an issue on the Issues tab or reach out — we build custom Yelp pipelines for monitoring, alerting, and review analytics.

### See also

- [Yelp Scraper – Extract Business Data, Contacts & Reviews](https://apify.com/khadinakbar/yelp-scraper-all-in-one) — for scraping Yelp business listings (categories, search, etc.) instead of reviews.
- [Google Maps Leads Scraper](https://apify.com/khadinakbar/google-maps-leads-scraper) — combine with Google Maps data for full local-business intelligence.
- [B2B Lead Finder + Enrichment](https://apify.com/khadinakbar/b2b-lead-finder-enrichment) — for verified email + phone enrichment of business contacts.

# Actor input Schema

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

List of Yelp business pages to scrape reviews from. Each entry is a full Yelp URL (e.g., `https://www.yelp.com/biz/molinari-delicatessen-san-francisco`). Up to 50 entries per run. NOT a search URL or category URL — this actor scrapes reviews of a SPECIFIC business, not lists of businesses (for that use yelp-scraper-all-in-one). For bare slugs, use the businessSlugs field instead.

## `businessSlugs` (type: `array`):

Alternative to startUrls: pass bare Yelp business slugs (e.g., `molinari-delicatessen-san-francisco`) — one per line. Combined with startUrls if both provided. Useful when integrating from spreadsheets or databases that store slugs only.

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

Hard cap on reviews returned per business. Yelp displays up to thousands of reviews on popular businesses; 100 is a good default for monitoring. Range 1-5000. Affects PPE cost: each review = $0.0005, so 100 reviews = $0.05 per business.

## `sortBy` (type: `string`):

How Yelp orders the returned reviews. `relevance_desc` (Yelp default) surfaces highest-engagement reviews first. `date_desc` returns newest first — best for monitoring fresh feedback. `rating_asc` surfaces 1-star complaints, `rating_desc` surfaces 5-star praise.

## `language` (type: `string`):

Two-letter ISO code (e.g., `en`, `es`, `fr`, `de`, `it`, `pt`, `nl`, `ja`) to filter reviews by language. Leave as `en` for English-only. Set to `all` for every language. Yelp does its own language detection — non-matching reviews may still slip through.

## `dateFrom` (type: `string`):

Earliest review date to include (inclusive). Format YYYY-MM-DD, e.g., `2025-01-01`. Leave empty for no lower bound. Filtered client-side after fetch — applies AFTER Yelp's sort.

## `dateTo` (type: `string`):

Latest review date to include (inclusive). Format YYYY-MM-DD, e.g., `2026-06-18`. Leave empty for no upper bound.

## `includeBusinessSummary` (type: `boolean`):

When true, push one extra dataset item per business with aggregate metadata (name, url, total review count, average rating, address, categories). Useful for joining reviews to business context. Does NOT add a charge — business resolution is already billed once per URL.

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

Apify proxy settings. Defaults to the actor owner's USA proxy pool. If you have access to Apify RESIDENTIAL, switch to it for higher reliability against Yelp's DataDome protection.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.yelp.com/biz/molinari-delicatessen-san-francisco"
    }
  ],
  "businessSlugs": [],
  "maxReviewsPerBusiness": 50,
  "sortBy": "date_desc",
  "language": "en",
  "dateFrom": "2025-01-01",
  "dateTo": "2026-06-18",
  "includeBusinessSummary": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "BUYPROXIES94952"
    ]
  }
}
```

# Actor output Schema

## `reviews` (type: `string`):

Default dataset with one record per review (and optional business summary record).

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

End-of-run summary stored in OUTPUT key of the default KV store.

# 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 = {
    "startUrls": [
        {
            "url": "https://www.yelp.com/biz/molinari-delicatessen-san-francisco"
        }
    ],
    "maxReviewsPerBusiness": 50,
    "sortBy": "date_desc",
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "BUYPROXIES94952"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/yelp-reviews-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 = {
    "startUrls": [{ "url": "https://www.yelp.com/biz/molinari-delicatessen-san-francisco" }],
    "maxReviewsPerBusiness": 50,
    "sortBy": "date_desc",
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["BUYPROXIES94952"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/yelp-reviews-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 '{
  "startUrls": [
    {
      "url": "https://www.yelp.com/biz/molinari-delicatessen-san-francisco"
    }
  ],
  "maxReviewsPerBusiness": 50,
  "sortBy": "date_desc",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "BUYPROXIES94952"
    ]
  }
}' |
apify call khadinakbar/yelp-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Yelp Reviews Scraper — Extract Yelp Business Reviews",
        "description": "Scrape Yelp business reviews — rating, full text, author, date, photos, owner replies. HTTP-only, MCP-ready.",
        "version": "0.1",
        "x-build-id": "pgxzhq8pLJAbOOY7C"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/khadinakbar~yelp-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-khadinakbar-yelp-reviews-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/khadinakbar~yelp-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-khadinakbar-yelp-reviews-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/khadinakbar~yelp-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-khadinakbar-yelp-reviews-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": {
                    "startUrls": {
                        "title": "Yelp business URLs",
                        "type": "array",
                        "description": "List of Yelp business pages to scrape reviews from. Each entry is a full Yelp URL (e.g., `https://www.yelp.com/biz/molinari-delicatessen-san-francisco`). Up to 50 entries per run. NOT a search URL or category URL — this actor scrapes reviews of a SPECIFIC business, not lists of businesses (for that use yelp-scraper-all-in-one). For bare slugs, use the businessSlugs field instead.",
                        "default": [
                            {
                                "url": "https://www.yelp.com/biz/molinari-delicatessen-san-francisco"
                            }
                        ],
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "businessSlugs": {
                        "title": "Yelp business slugs (alternative input)",
                        "type": "array",
                        "description": "Alternative to startUrls: pass bare Yelp business slugs (e.g., `molinari-delicatessen-san-francisco`) — one per line. Combined with startUrls if both provided. Useful when integrating from spreadsheets or databases that store slugs only.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxReviewsPerBusiness": {
                        "title": "Max reviews per business",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Hard cap on reviews returned per business. Yelp displays up to thousands of reviews on popular businesses; 100 is a good default for monitoring. Range 1-5000. Affects PPE cost: each review = $0.0005, so 100 reviews = $0.05 per business.",
                        "default": 100
                    },
                    "sortBy": {
                        "title": "Sort reviews by",
                        "enum": [
                            "relevance_desc",
                            "date_desc",
                            "date_asc",
                            "rating_asc",
                            "rating_desc",
                            "elites_desc"
                        ],
                        "type": "string",
                        "description": "How Yelp orders the returned reviews. `relevance_desc` (Yelp default) surfaces highest-engagement reviews first. `date_desc` returns newest first — best for monitoring fresh feedback. `rating_asc` surfaces 1-star complaints, `rating_desc` surfaces 5-star praise.",
                        "default": "date_desc"
                    },
                    "language": {
                        "title": "Review language filter",
                        "enum": [
                            "en",
                            "es",
                            "fr",
                            "de",
                            "it",
                            "pt",
                            "nl",
                            "ja",
                            "tr",
                            "ar",
                            "pl",
                            "ru",
                            "zh",
                            "ko",
                            "all"
                        ],
                        "type": "string",
                        "description": "Two-letter ISO code (e.g., `en`, `es`, `fr`, `de`, `it`, `pt`, `nl`, `ja`) to filter reviews by language. Leave as `en` for English-only. Set to `all` for every language. Yelp does its own language detection — non-matching reviews may still slip through.",
                        "default": "en"
                    },
                    "dateFrom": {
                        "title": "Date from (YYYY-MM-DD)",
                        "type": "string",
                        "description": "Earliest review date to include (inclusive). Format YYYY-MM-DD, e.g., `2025-01-01`. Leave empty for no lower bound. Filtered client-side after fetch — applies AFTER Yelp's sort."
                    },
                    "dateTo": {
                        "title": "Date to (YYYY-MM-DD)",
                        "type": "string",
                        "description": "Latest review date to include (inclusive). Format YYYY-MM-DD, e.g., `2026-06-18`. Leave empty for no upper bound."
                    },
                    "includeBusinessSummary": {
                        "title": "Push a business summary record",
                        "type": "boolean",
                        "description": "When true, push one extra dataset item per business with aggregate metadata (name, url, total review count, average rating, address, categories). Useful for joining reviews to business context. Does NOT add a charge — business resolution is already billed once per URL.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify proxy settings. Defaults to the actor owner's USA proxy pool. If you have access to Apify RESIDENTIAL, switch to it for higher reliability against Yelp's DataDome protection.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "BUYPROXIES94952"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
