# Yelp Business Reviews Scraper (`automation-lab/yelp-business-reviews-scraper`) Actor

Extract public Yelp review text, ratings, dates, reviewer details, photos, and owner responses from supplied business URLs.

- **URL**: https://apify.com/automation-lab/yelp-business-reviews-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Marketing
- **Stats:** 2 total users, 1 monthly users, 80.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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/platform/actors/running/actors-in-store#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

## Yelp Business Reviews Scraper

Extract public **Yelp business reviews** from supplied business URLs into a clean dataset for reputation monitoring, customer-feedback analysis, spreadsheets, and data pipelines.

Each review record includes the review text, star rating, publication date, reviewer profile metadata, attached photo URLs, the business context, and a displayed owner response when available.

The Actor accepts real `yelp.com/biz/...` pages. It does not require a Yelp login, Yelp API key, or user-provided proxy configuration.

### What does Yelp Business Reviews Scraper do?

The Actor turns public Yelp review pages into structured records.

It can:

- process one or many Yelp business URLs;
- return newest reviews for recurring monitoring;
- use Yelp's relevance ordering for one-time analysis;
- paginate beyond the first review page;
- filter reviews by publication date;
- filter reviews by star rating;
- capture reviewer name, location, avatar, public ID, and Elite badges;
- capture attached public photo or video-thumbnail URLs;
- capture owner-response text when Yelp displays it;
- deduplicate records by Yelp's stable review identifier;
- stop at per-business and overall limits.

Results go to the run's default dataset, ready for JSON, CSV, Excel, XML, RSS, API, or webhook integrations.

### Who is it for?

**Reputation teams** can schedule newest-first runs and compare stable `reviewId` values with an earlier export.

**Restaurant and local-business operators** can isolate low-star reviews and investigate repeated service or product complaints.

**Agencies** can process several client business pages in one run while keeping each record tied to its canonical `businessUrl`.

**Analysts and researchers** can collect review text, ratings, dates, and reviewer context for a bounded public-data study.

**Data engineers** can feed normalized rows into a warehouse, spreadsheet, BI tool, or sentiment-analysis pipeline.

### Why use this Actor?

Yelp pages are designed for interactive browsing rather than repeatable exports.

This Actor provides:

- URL-first input with strict validation;
- typed, stable field names;
- pagination and filtering in one run;
- useful failure messages instead of silently returning an empty dataset;
- no automatic residential proxy cost;
- resource-blocked browser loading to avoid downloading review media;
- pay-per-event billing only for the run start and useful saved reviews.

It intentionally focuses on reviews from supplied business pages. It does not claim to search Yelp for businesses or scrape private Yelp account data.

### What data can you extract?

| Field | Meaning |
| --- | --- |
| `reviewId` | Stable public Yelp review identifier |
| `reviewUrl` | Canonical URL targeting the review |
| `businessName` | Business name displayed on Yelp |
| `businessAlias` | Alias from the Yelp `/biz/` URL |
| `businessUrl` | Canonical Yelp business URL |
| `businessRating` | Current aggregate business rating |
| `businessReviewCount` | Current displayed business review count |
| `rating` | Review's one-to-five-star rating |
| `text` | Public review text |
| `publishedDate` | Date normalized to `YYYY-MM-DD` |
| `publishedDateRaw` | Date as Yelp displayed it |
| `reviewerId` | Public Yelp reviewer identifier |
| `reviewerName` | Public reviewer display name |
| `reviewerUrl` | Public Yelp profile URL |
| `reviewerLocation` | Displayed reviewer location |
| `reviewerAvatarUrl` | Public avatar image URL |
| `reviewerEliteStatus` | Displayed Yelp Elite badges |
| `photoUrls` | Attached public photo or video-thumbnail URLs |
| `ownerResponse` | Displayed business-owner response, or `null` |
| `ownerResponseDateRaw` | Displayed response date, or `null` |
| `sourceUrl` | Normalized source URL |
| `scrapedAt` | Extraction timestamp |

Nullable fields remain `null` when Yelp does not display that information.

### How to scrape Yelp business reviews

1. Open the Actor input page.
2. Add one or more public Yelp URLs containing `/biz/<business-alias>`.
3. Choose `Newest first` for monitoring or `Yelp relevance` for representative reviews.
4. Set overall and per-business limits.
5. Optionally set date and star-rating filters.
6. Click **Start**.
7. Open the **Yelp reviews** dataset view.
8. Export the data or connect the dataset API to your workflow.

Start with a small limit to confirm the target pages and output before scheduling a larger recurring run.

### Input parameters

#### `startUrls`

Required array of Yelp business URLs.

Accepted shape:

```json
[{ "url": "https://www.yelp.com/biz/gary-danko-san-francisco" }]
```

Other Yelp pages, non-Yelp hosts, and malformed URLs fail closed.

#### `maxItems`

Maximum matching reviews saved across all businesses. Default: `100`; maximum: `10000`.

#### `maxReviewsPerBusiness`

Maximum matching reviews saved for each business. Default: `100`; maximum: `5000`.

#### `sortBy`

- `date`: newest reviews first; recommended for monitoring.
- `relevance`: Yelp relevance order; useful for one-time analysis.

#### `dateFrom` and `dateTo`

Optional inclusive `YYYY-MM-DD` boundaries.

When `sortBy` is `date`, the Actor stops paging after it passes `dateFrom`.

#### `minRating` and `maxRating`

Inclusive integer star boundaries from `1` to `5`.

For complaint triage, set `minRating: 1` and `maxRating: 3`.

### Example input

```json
{
  "startUrls": [
    { "url": "https://www.yelp.com/biz/gary-danko-san-francisco" }
  ],
  "maxItems": 10,
  "maxReviewsPerBusiness": 10,
  "sortBy": "date",
  "dateFrom": "2026-07-01",
  "minRating": 1,
  "maxRating": 5
}
```

This input is suitable for a scheduled newest-review monitoring task.

### Example output

```json
{
  "reviewId": "sampleReviewId123",
  "reviewUrl": "https://www.yelp.com/biz/sample-cafe?hrid=sampleReviewId123",
  "businessName": "Sample Cafe",
  "businessAlias": "sample-cafe",
  "businessUrl": "https://www.yelp.com/biz/sample-cafe",
  "businessRating": 4.5,
  "businessReviewCount": 248,
  "rating": 5,
  "text": "Friendly service and a thoughtful menu.",
  "publishedDate": "2026-07-15",
  "publishedDateRaw": "Jul 15, 2026",
  "reviewerId": "sampleReviewerId",
  "reviewerName": "Sample R.",
  "reviewerUrl": "https://www.yelp.com/user_details?userid=sampleReviewerId",
  "reviewerLocation": "San Francisco, CA",
  "reviewerAvatarUrl": "https://s3-media0.fl.yelpcdn.com/photo/sample/60s.jpg",
  "reviewerEliteStatus": ["Elite 26"],
  "photoUrls": ["https://s3-media0.fl.yelpcdn.com/bphoto/sample/348s.jpg"],
  "ownerResponse": "Thank you for visiting us.",
  "ownerResponseDateRaw": "Jul 16, 2026",
  "sourceUrl": "https://www.yelp.com/biz/sample-cafe",
  "scrapedAt": "2026-08-08T06:30:00.000Z"
}
```

The example is anonymized. Actual runs contain public source values.

### How much does it cost to extract Yelp business reviews?

The Actor uses pay-per-event pricing:

- one `start` event per run;
- one `item` event for each useful review saved.

The start price is **$0.001 per run**. The BRONZE item price is **$0.00078431 per saved review**, with lower per-review rates on higher pricing tiers.

At the BRONZE rate:

- 10 reviews cost about **$0.0088** including the start event;
- 100 reviews cost about **$0.0804** including the start event;
- 1,000 reviews cost about **$0.7853** including the start event.

Filtered-out, duplicate, empty, or failed records do not emit an item charge. Apify shows the active tier and maximum charge before a run starts.

### Recurring reputation monitoring workflow

1. Set `sortBy` to `date`.
2. Set `dateFrom` to the beginning of the monitoring window.
3. Schedule the Actor daily or weekly.
4. Store `reviewId` in your destination system.
5. Upsert on `reviewId` to avoid duplicate alerts.
6. Route one-to-three-star rows to a support or operations queue.
7. Track `businessRating` and `businessReviewCount` as contextual snapshots.

The Actor extracts current public data. It does not maintain historical state or send alerts by itself.

### Spreadsheet, webhook, and data-pipeline integrations

Use an Apify integration to send the dataset to Google Sheets, Make, Zapier, Slack, a webhook, or cloud storage.

For a warehouse pipeline:

- use `reviewId` as the source key;
- parse `publishedDate` as a date;
- parse `scrapedAt` as the observation timestamp;
- retain `businessUrl` for entity grouping;
- treat reviewer and response fields as nullable;
- avoid downloading media unless your use case requires it.

For sentiment analysis, analyze `text` while preserving `rating` as a source-provided label.

### Use the Yelp reviews API

Replace `YOUR_TOKEN` with an Apify API token.

#### cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~yelp-business-reviews-scraper/runs?token=YOUR_TOKEN&waitForFinish=120" \
  -H "Content-Type: application/json" \
  -d '{"startUrls":[{"url":"https://www.yelp.com/biz/gary-danko-san-francisco"}],"maxItems":10,"sortBy":"date"}'
```

#### JavaScript

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/yelp-business-reviews-scraper').call({
  startUrls: [{ url: 'https://www.yelp.com/biz/gary-danko-san-francisco' }],
  maxItems: 10,
  sortBy: 'date',
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")
run = client.actor("automation-lab/yelp-business-reviews-scraper").call(run_input={
    "startUrls": [{"url": "https://www.yelp.com/biz/gary-danko-san-francisco"}],
    "maxItems": 10,
    "sortBy": "date",
})
items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)
```

### Use with Apify MCP

Add the Actor to Claude Code:

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/yelp-business-reviews-scraper"
```

#### Claude Desktop

Add this server to Claude Desktop's MCP configuration:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/yelp-business-reviews-scraper"
    }
  }
}
```

#### Cursor

Use the same `mcpServers.apify.url` value in Cursor's MCP settings.

#### VS Code

Add the same HTTP MCP URL to your VS Code MCP server configuration, then select the Yelp Business Reviews Scraper tool.

Example prompts:

- "Extract the five newest reviews from this Yelp business URL."
- "Collect recent one-to-three-star reviews and summarize recurring complaints."
- "Run the Yelp review monitor input and return only review IDs not in this list."

### Limits and reliability

Yelp is a dynamic third-party source and can change markup, availability, or anti-automation behavior without notice.

The Actor uses a public translated Yelp surface because direct Yelp delivery is frequently challenged. A source change may temporarily cause retries or a non-zero failure.

Other limitations:

- only public `/biz/` URLs are supported;
- no Yelp business search is provided;
- no login-only or private account data is accessed;
- Yelp may display different review order or counts by locale and time;
- photo arrays can be empty when a review has no displayed photos;
- owner-response fields are `null` when no response is displayed;
- deleted or hidden reviews cannot be recovered;
- very large businesses require more pages and runtime.

The Actor retries failed pages three times with fresh browser pages, then fails visibly rather than returning a misleading empty success.

### Responsible use and legality

This Actor extracts publicly displayed information. You are responsible for ensuring that your use complies with applicable law, Yelp's terms, privacy obligations, and your organization's policies.

Use only the data you need. Avoid using reviewer data for harassment, discrimination, identity resolution, or unsolicited contact. Apply appropriate retention, access-control, and deletion policies to exported personal data.

This Actor is not affiliated with or endorsed by Yelp.

### Troubleshooting

#### Why does the run reject my URL?

Use a full public Yelp business URL containing `/biz/<alias>`. Search pages, user pages, shortened links, and non-Yelp hosts are intentionally rejected.

#### Why are there no matching rows?

Check the date and rating boundaries. A valid business may have no reviews matching a narrow filter. Increase `maxReviewsPerBusiness` so the Actor can page far enough to find matches.

#### Why did the run fail after retries?

Open the run log and check the upstream status. Retry later if Yelp's public surface is temporarily unavailable. Do not add a proxy: this Actor owns its delivery strategy and does not expose an unmeasured residential fallback.

#### Why is `ownerResponse` null?

Yelp does not display an owner response for every review. Null means no response was found on the rendered card.

#### How do I avoid duplicate alerts?

Use `reviewId` as the stable source key and upsert or compare against prior IDs in your destination.

### FAQ

#### Can I scrape multiple Yelp businesses?

Yes. Add multiple business URLs to `startUrls`; the Actor deduplicates identical canonical URLs.

#### Can I get only the newest reviews?

Yes. Use `sortBy: "date"`, a recent `dateFrom`, and an appropriate limit.

#### Can I get only negative reviews?

Yes. Set `minRating: 1` and `maxRating: 3`.

#### Does it download review photos?

No. It returns displayed public media URLs while blocking image downloads during extraction to reduce transfer and runtime cost.

#### Does it use the official Yelp API?

No. The official API does not provide the complete supplied-business review workflow implemented here.

#### Does it require a Yelp login or API key?

No.

#### Is every Yelp review guaranteed?

No. Output reflects reviews Yelp publicly displays through the source surface at run time. Yelp can reorder, hide, translate, or remove content.

### Related Automation Lab Actors

Use [Google Maps Reviews Scraper](https://apify.com/automation-lab/google-maps-reviews-scraper) when your workflow starts from Google Maps rather than Yelp.

Use [Trustpilot Reviews Scraper](https://apify.com/automation-lab/trustpilot) for public Trustpilot company-review monitoring.

Use [Social Media Sentiment](https://apify.com/automation-lab/social-media-sentiment) as a downstream text-analysis step when its supported input contract matches your workflow.

These are separate sources and products; their records should not be treated as equivalent Yelp reviews.

# Actor input Schema

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

One or more public Yelp /biz/ URLs. Duplicate business URLs are processed once.

## `maxItems` (type: `integer`):

Maximum number of matching review records saved across all businesses.

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

Maximum matching reviews saved for each supplied business.

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

Newest first is best for monitoring; Yelp relevance is useful for representative analysis.

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

Keep reviews published on or after this date (YYYY-MM-DD).

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

Keep reviews published on or before this date (YYYY-MM-DD).

## `minRating` (type: `integer`):

Keep reviews at or above this star rating.

## `maxRating` (type: `integer`):

Keep reviews at or below this star rating.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.yelp.com/biz/gary-danko-san-francisco"
    }
  ],
  "maxItems": 20,
  "maxReviewsPerBusiness": 100,
  "sortBy": "date",
  "minRating": 1,
  "maxRating": 5
}
```

# Actor output Schema

## `dataset` (type: `string`):

Review text, ratings, dates, reviewer metadata, photos, and owner responses.

# 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/gary-danko-san-francisco"
        }
    ],
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/yelp-business-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/gary-danko-san-francisco" }],
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/yelp-business-reviews-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "startUrls": [
    {
      "url": "https://www.yelp.com/biz/gary-danko-san-francisco"
    }
  ],
  "maxItems": 20
}' |
apify call automation-lab/yelp-business-reviews-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/yelp-business-reviews-scraper"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <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/SlZgrrGksSTp7lIxw/builds/wYc51oSfb4yPDn0Z4/openapi.json