# Yelp Reviews Scraper: All Languages, Owner Replies (`arcadium/yelp-reviews`) Actor

Yelp reviews for any business in every language with owner replies, $0.30 per 1,000: 85% under tri_angle's $2. Rating, text, date, useful/funny/cool votes, read to the end. web_wanderer and tri_angle input works. Only-new mode for review monitoring, free error rows, no reviewer names or photos.

- **URL**: https://apify.com/arcadium/yelp-reviews.md
- **Developed by:** [Arcadium Data](https://apify.com/arcadium) (community)
- **Categories:** Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.23 / 1,000 reviews

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Yelp Reviews Scraper: All Languages, Owner Replies

Monitor what customers say about your locations or a competitor's, check whether owners answer complaints, or feed review text into sentiment analysis. Give it Yelp business pages (or business IDs) and it returns one JSON row per review: star rating, the full text in its original language, date, useful/funny/cool votes, reactions, the owner's public reply with its date, and the business's overall rating and review count. $0.30 per 1,000 reviews; you pay only for rows you get.

**Why this actor**

- **Drop-in input.** Input written for `web_wanderer/yelp-reviews-scraper` (`biz_urls`, `biz_ids`, `reviews_limit`, `reviews_sort`, `reviews_language`, `date_from`...) or `tri_angle/yelp-review-scraper` (`startUrls`, `maxReviewsPerUrl`, `language`, `dateFrom`) works as it is, and business URLs from `tri_angle/yelp-scraper` (`directUrls`) too.
- **The leader's price, with every language and owner replies.** $0.30 per 1,000 reviews, the same as web_wanderer and 85% under tri_angle/yelp-review-scraper's $2 (plus its $0.003 start fee). Ratings on the Apify Store on 2026-10-31: tri_angle's Yelp actors 2.23 stars (3 reviews) and 2.70 stars (10 reviews); web_wanderer's actor was last built on 2026-06-26.
- **Every language in one run.** Yelp serves one language per request; this actor reads them all and merges them newest first.
- **No depth limit.** A business with 9,000 reviews is read to the end; stars, language and sort are applied by Yelp.
- **Only new reviews.** Repeats are not charged; edited reviews come back once, marked `edited`.
- **No personal data.** No reviewer names, photos, profiles or locations. A free `coverage` row and a free `error` row with a `code` say exactly what you got. 46 of our 46 runs since 2026-10-21 succeeded (scheduled and test runs, Apify run history).

| Row | Free plan | Business (Gold) and above |
| --- | --- | --- |
| Review | $0.30 per 1,000 | $0.23 per 1,000 |
| Business summary, coverage and error rows, repeats in only-new mode | Free | Free |

Built by Arcadium Data: public data, dated and agent-ready, never personal data.

### Use with AI agents

Returns Yelp reviews (rating, text, date, owner reply, useful/funny/cool votes) for business URLs, in every language. Agents can call it through the Apify MCP server (`https://mcp.apify.com`, open source as `apify/actors-mcp-server`) as `arcadium/yelp-reviews`: the input schema is read from the actor, the result is a dataset of JSON rows.

Input example (minimal):

```json
{
  "startUrls": [
    {
      "url": "https://www.yelp.com/biz/tartine-bakery-san-francisco-3"
    }
  ],
  "maxReviewsPerBusiness": 20
}
```

What comes back: one `review` row per review (charged), free `coverage` rows (stated total vs delivered), an optional free `business-summary` row (`includeBusinessSummary`) and a free `error` row for an input that could not be read. Filter on the `rowType` field. An input that fails is reported, not hidden (`includeErrorRows`, on by default): the error row carries `rowType: "error"`, a `code` (`invalid_input`, `not_found`, `blocked`, `unavailable`, `filter_unsupported` or `no_match`), a `message` and the `input` it is about. Retry on `blocked` and `unavailable` later; do not retry the other codes with the same input.

Cost of the call above: 20 reviews at $0.30 per 1,000 plus the $0.001 start fee is about $0.007 on the free plan; paid plans pay less. Free rows are never charged.

### What you get

| Field | What it holds |
| --- | --- |
| `reviewId` | `Yelp___` plus Yelp's own review ID. Stable between runs, so you can dedupe weekly exports. |
| `reviewUrl` | Direct link to the review on Yelp. |
| `date` | Date the review was written (UTC), ISO format. `extras.localDateTime` has the local time at the business. |
| `text` | The review, in the language it was written in. |
| `ratingOverall` | Stars, 1 to 5. |
| `language` | Language of the review. |
| `helpfulVotes` | Useful votes. `extras.coolCount` and `extras.funnyCount` hold the other two. |
| `extras.reactions` | Counts of the newer reactions: `helpful`, `thanks`, `loveThis`, `ohNo`. |
| `vendorResponse`, `extras.vendorResponseDate` | The owner or manager's public reply and its date, when there is one. |
| `extras.checkInCount`, `extras.isFirstReviewer`, `extras.reviewOfTheDay` | Yelp's review tags. |
| `extras.hasPaidThroughYelp`, `extras.hasPurchasedDeal`, `extras.hasPlacedReservation`, `extras.reservationProvider` | Whether the reviewer paid, bought a deal or booked through Yelp. |
| `extras.photoCount`, `extras.videoCount` | How many photos and videos the review has. Links to the photos come with `includeReviewPhotos`. |
| `product.rating`, `product.reviewCount` | The business's overall rating and total number of reviews, repeated on every row. |
| `productName`, `productUrl`, `entityId` | The business, its Yelp page and its Yelp business ID. |
| `scrapedAt` | When the row was collected. |

Output example:

```json
{
  "reviewId": "Yelp___abc123",
  "platform": "yelp",
  "productName": "Katz's Delicatessen",
  "date": "2026-10-09",
  "text": "Great pastrami, long line, worth it.",
  "ratingOverall": 4,
  "language": "en",
  "helpfulVotes": 2,
  "vendorResponse": "Hi [name], thank you for the kind words.",
  "extras": { "reactions": { "helpful": 2, "thanks": 0, "loveThis": 1, "ohNo": 0 }, "vendorResponseDate": "2026-10-10" }
}
```

With `includeBusinessSummary` you also get one free row per business: overall rating, review count, the star histogram (how many 1, 2, 3, 4 and 5 star reviews) and the review count per language.

### Input

```json
{
  "startUrls": [{ "url": "https://www.yelp.com/biz/katzs-delicatessen-new-york" }],
  "maxReviewsPerBusiness": 100
}
```

| Field | What it does |
| --- | --- |
| `startUrls` | Business pages on any Yelp domain (yelp.com, yelp.co.uk, yelp.de and so on). |
| `businessIds` | Yelp business IDs (22 characters) or aliases (the last part of the business URL). |
| `maxReviewsPerBusiness` | Cap per business (default 100, up to 1,000,000). |
| `sort` | `DATE_DESC` newest first (default), `DATE_ASC`, `RELEVANCE_DESC` (Yelp's own sort), `RATING_DESC`, `RATING_ASC`, `ELITES_DESC`. |
| `ratings` | Only these star ratings, for example `["1", "2"]`. |
| `languages` | Only these review languages, for example `["de", "fr"]`. Empty means every language the business has. |
| `keywords` | Only reviews whose text contains one of these words. Checked after reading; you pay only for the matches. |
| `dateFrom` | Only reviews from this date on (`2026-01-01`, `30 days`, `2 months`, `1 year`). Stops early with the newest first sort. |
| `onlyNewReviews`, `stateKey` | Skip reviews that earlier runs with the same key already delivered. They are not charged. |
| `includeBusinessSummary` | One free summary row per business. |
| `includeReviewPhotos` | Add links of the photos attached to reviews (off by default: photos can show people). |
| `includeErrorRows`, `includeCoverageRows` | Free rows for businesses that failed and for coverage per business (both on by default). |
| `requestsPerSession` | Advanced: requests per proxy IP before the actor moves to a fresh one (default 45). Yelp often refuses an IP after about 50 requests; the actor also moves on at the first refusal, so large businesses are read without gaps. |

Notes on sorting: with several languages, newest first merges them into one list ordered by date. The other orders read one language after another. `RATING_ASC` and `RATING_DESC` are served as one newest-first pass per star rating (1 star first, then 2 and so on, or the reverse), because Yelp's own rating sort times out on large businesses. Within one star rating the newest come first.

### Coverage and edited reviews

A free `coverage` row per business says how many reviews Yelp reports (`stated`) against how many you received (`delivered`), how many were skipped as already seen, and why reading stopped. With `onlyNewReviews`, a review edited after it was delivered comes back once more with `extras.changeType` set to `edited`; that row is charged like a new review.

### How it compares with the other popular Yelp reviews actor

Based on the other actor's published input options.

| | This actor | The other popular actor |
| --- | --- | --- |
| Reads a business to the end | Yes | Yes |
| All languages in one run | Yes, merged newest first | One language per run |
| Only-new-reviews mode between runs (not charged for repeats) | Yes | No |
| Coverage row (reported vs delivered, why it stopped) | Yes | No |
| Rating, language, keyword, date filters | Yes | Yes |
| Reviewer names, photos, profiles | Never | Optional |
| Translation of reviews | No | Yes |
| Yelp search result pages as input | No | Yes |

Say what you need most: if you scrape across many languages, run on a schedule, or need to know exactly what was missed, this actor is built for that.

### Migrating from the other popular Yelp reviews actor

Its input works as it is. These field names are accepted and mapped:

| Their field | Used as |
| --- | --- |
| `biz_urls` | `startUrls` |
| `biz_ids` | `businessIds` |
| `reviews_limit` | `maxReviewsPerBusiness` |
| `reviews_sort` (`recommended`, `newest`, `oldest`, `rating_desc`, `rating_asc`, `elites`) | `sort` |
| `date_from` (a date, or `30 days`, `2 months`, `1 year`) | `dateFrom` |
| `reviews_rating` | `ratings` |
| `reviews_language` (a code; empty for all) | `languages` |
| `reviews_keywords` | `keywords` |
| `include_personal_data`, `reviews_translate`, `domain`, `search_*` | Ignored. Reviewer details are never returned. |

If you leave `reviews_limit` out, this actor reads 100 reviews per business, not all of them: set `maxReviewsPerBusiness` high to read everything. Output field names are our own (see the table above), so check any downstream mapping once.

From `tri_angle/yelp-review-scraper`: `startUrls` and `dateFrom` are ours already, `maxReviewsPerUrl` → `maxReviewsPerBusiness`, `language` (one code, empty for all) → `languages`. `dateTo` is not supported and is ignored. From `tri_angle/yelp-scraper`, business URLs in `directUrls` are read as `startUrls`; its business search (`searchTerms`, `locations`) is not supported.

### Use it from an AI assistant

Paste this into your assistant to run the actor for you:

```text
Use the Apify actor "yelp-reviews" to collect reviews.
Input: {"startUrls":[{"url":"<Yelp business URL>"}],"maxReviewsPerBusiness":100}
Each dataset row is one review. Key fields: reviewId, date, text, ratingOverall, language, vendorResponse.
Run it, then summarize the main praise and complaints. Mention the review count.
```

### Use it from code

Python:

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("arcadium/yelp-reviews").call(run_input={
    "startUrls": [{"url": "https://www.yelp.com/biz/katzs-delicatessen-new-york"}],
    "maxReviewsPerBusiness": 200,
    "ratings": ["1", "2"],
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    if item.get("rowType") == "review":
        print(item["date"], item["ratingOverall"], item["text"][:80])
```

JavaScript:

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

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const run = await client.actor('arcadium/yelp-reviews').call({
  businessIds: ['katzs-delicatessen-new-york'],
  maxReviewsPerBusiness: 100,
  onlyNewReviews: true,
  stateKey: 'weekly-katz',
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.filter((i) => i.rowType === 'review').length, 'reviews');
```

### Pricing

You pay per review delivered, at the price of your Apify plan. Summary, coverage and error rows are free, and so are failed or empty lookups and repeats in only-new mode.

| Apify plan | Per 1,000 reviews |
| --- | --- |
| Free | $0.30 |
| Starter (Bronze) | $0.27 |
| Scale (Silver) | $0.24 |
| Business (Gold) | $0.23 |
| Platinum | $0.23 |
| Diamond | $0.23 |

Plus a one-off $0.001 per GB of memory when a run starts.

Set a maximum cost per run in the Apify run options and the actor stops before it goes over.

### Related actors

- [Tripadvisor Reviews Scraper: Ratings, Replies, Translations](https://apify.com/arcadium/tripadvisor-reviews)
- [Review Monitor: Negative Review Alerts and Rating Drift](https://apify.com/arcadium/reputation-monitor)

### Use cases

- Reputation monitoring: pull the 1 and 2 star reviews of all your locations every week, in every language.
- Competitor tracking: export a rival's newest reviews on a schedule and watch what changes.
- Franchise reporting: one run over hundreds of locations, with a coverage row per location.
- Sentiment analysis: feed review text, stars and owner replies into your own model or spreadsheet.

### Limitations

- Public reviews only, nothing behind a login. Yelp shows "recommended" reviews; the ones Yelp's filter hides ("not currently recommended") are not available.
- Reviewer names, photos, locations and profile data are never returned. Neither is the business phone number.
- Businesses are found from their page URL, alias or ID. Search result pages are not supported.
- Reviews are not translated; `text` is always what the reviewer wrote.
- Review photos are links only and are off unless you ask for them.
- `ELITES_DESC` (elite reviewers first) is Yelp's own sort and can time out on very large businesses; use the other sorts there.
- Yelp changes its site from time to time. The actor adapts on its own in most cases; if a run fails for several businesses at once, try again later or open an issue.
- You are responsible for using the data in line with Yelp's terms and the law where you live.

### Privacy

Reviewer names, profile photos, profile links, locations, friend counts and elite status are not collected. Names in greetings and sign-offs of owner replies (for example 'Hi Anna' or 'Regards, Mike') are replaced with \[name]; other names in the text are not detected. You get the review and the context around it, not the person.

### FAQ

**How fresh is the data?**
It is read when you run the actor, so it matches what the site shows at that moment.

**Can I get only new reviews since my last run?**
Yes. Turn on `onlyNewReviews` and keep the same `stateKey` between runs. Reviews you already received are skipped and not charged. The state lives in a key-value store in your Apify account. Pick a new `stateKey` to start over.

**A business returned no reviews. Why?**
Check that the URL opens a business page in your browser. Unknown businesses return a free error row with the code `not_found`.

**Why do I get fewer reviews than the number on the Yelp page?**
Yelp's page count includes reviews in all languages and not-recommended reviews are never shown. Look at the `coverage` row: `stated` is what Yelp reports for your filters, `delivered` is what you got.

**Something looks wrong in the output. Who do I tell?**
Open an issue on the actor page with the run link. We read them all.

# Actor input Schema

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

Yelp business pages, for example https://www.yelp.com/biz/tartine-bakery-san-francisco-3. Any Yelp domain works. Add this, business IDs, or both. Also read from biz_urls or directUrls (other Yelp actors' names).

## `businessIds` (type: `array`):

Yelp business IDs (22 characters, for example zLOmLckX_sNmhUwMW6yQMg) or aliases (the last part of the business URL). Use this instead of URLs, or next to them. Also read from biz_ids.

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

Maximum number of reviews to collect for each business. There is no depth limit: a business with 9,000 reviews can be read to the end. Example: 100. Also read from reviews_limit or maxReviewsPerUrl.

## `sort` (type: `string`):

Order of the reviews. Newest first enables the date filter and the only-new-reviews mode. With several languages, newest first merges them into one list ordered by date; other orders read one language after another.

## `ratings` (type: `array`):

Only reviews with these star ratings (1 to 5). Leave empty for all.

## `languages` (type: `array`):

Two-letter language codes such as en or de. Leave empty to read every language the business has reviews in, in one run. Also read from reviews_language or language (one code; empty = all).

## `keywords` (type: `array`):

Only reviews whose text contains at least one of these words or phrases (case-insensitive). The filter is applied after reading, and you only pay for the reviews that match. Example: \["parking", "vegan"].

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

Only reviews on or after this date (YYYY-MM-DD, or 30 days / 2 months / 1 year). Reading stops early with the newest first sort. Example: 2026-01-01.

## `onlyNewReviews` (type: `boolean`):

Skip reviews delivered by earlier runs that used the same state key, and do not charge for them. Forces the newest first sort.

## `stateKey` (type: `string`):

Name of the incremental state (letters, digits and dashes). Change it to start over. State is kept in a key-value store in your account. Example: weekly-monitoring.

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

Add one free row per business with its overall rating, review count, star histogram and review count per language.

## `includeReviewPhotos` (type: `boolean`):

Add the links of photos attached to each review in extras.photoUrls. Off by default because photos can show people.

## `includeErrorRows` (type: `boolean`):

Add one free row per business that could not be read, with the reason.

## `includeCoverageRows` (type: `boolean`):

Add one free row per business: how many reviews Yelp reports, how many you received, and why reading stopped.

## `markEdited` (type: `boolean`):

With 'Only new reviews': also deliver reviews seen before whose text changed in the last 7 days, marked extras.changeType 'edited'. Edited reviews are charged like new ones.

## `maxRetries` (type: `integer`):

How many times a failed request is retried.

## `requestsPerSession` (type: `integer`):

Advanced: how many requests one proxy IP sends before the actor switches to a fresh IP, for example 45. Yelp often starts refusing an IP after about 50 requests, so keep the default unless you use your own proxies. The IP is also switched on the first refusal.

## `gqlDocumentId` (type: `string`):

Advanced: a 64 character hex id of Yelp's review query to try first. Leave empty; the actor already knows a working id.

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

Advanced: use your own proxy. By default the actor uses datacenter proxies.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.yelp.com/biz/tartine-bakery-san-francisco-3"
    }
  ],
  "maxReviewsPerBusiness": 20,
  "sort": "DATE_DESC",
  "onlyNewReviews": false,
  "stateKey": "default",
  "includeBusinessSummary": false,
  "includeReviewPhotos": false,
  "includeErrorRows": true,
  "includeCoverageRows": true,
  "markEdited": true,
  "maxRetries": 3,
  "requestsPerSession": 45
}
```

# Actor output Schema

## `results` (type: `string`):

All rows of this run in the default dataset.

## `view_overview` (type: `string`):

No description

## `view_replies` (type: `string`):

No description

## `view_coverage` (type: `string`):

No description

## `view_errors` (type: `string`):

No description

## `record_stats` (type: `string`):

Requests, data volume, retries and cost per result for this run.

## `record_product` (type: `string`):

Business profile data (rating, review count, star histogram, language counts) collected next to the reviews.

# 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/tartine-bakery-san-francisco-3"
        }
    ],
    "maxReviewsPerBusiness": 20,
    "sort": "DATE_DESC"
};

// Run the Actor and wait for it to finish
const run = await client.actor("arcadium/yelp-reviews").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/tartine-bakery-san-francisco-3" }],
    "maxReviewsPerBusiness": 20,
    "sort": "DATE_DESC",
}

# Run the Actor and wait for it to finish
run = client.actor("arcadium/yelp-reviews").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/tartine-bakery-san-francisco-3"
    }
  ],
  "maxReviewsPerBusiness": 20,
  "sort": "DATE_DESC"
}' |
apify call arcadium/yelp-reviews --silent --output-dataset

```

## MCP server setup

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

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/nlaqiJBg2fKnS2sHl/builds/xssPckoIQqQeysgnc/openapi.json