# Yelp Reviews Scraper: Every Language, Owner Replies (`alexmorain/yelp-reviews-scraper`) Actor

Scrape Yelp reviews from any business: rating, original text in every language, exact date, photos, reactions, owner reply, optional translation. Filters by stars, language, keyword and date, new-reviews-only monitoring, webhook. No residential proxy.

- **URL**: https://apify.com/alexmorain/yelp-reviews-scraper.md
- **Developed by:** [Alexis Morain](https://apify.com/alexmorain) (community)
- **Categories:** Travel, Marketing, Automation
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.20 / 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

This Actor exports the reviews of any Yelp business. Give it Yelp business URLs and it returns one row per review: the star rating, the review text exactly as the customer wrote it, the language, the exact date, the photos attached to the review, the reactions (helpful, thanks, love this, oh no), the owner's reply with its date, and optionally Yelp's own translation and the reviewer's public profile. A summary row per business comes with it: address, phone, website, opening hours, rating, and review counts by star and by language.

It works as a **Yelp reviews API**: plain HTTP requests to the data source the business page uses when you page through its reviews. No browser, no Yelp account, no residential proxy, no Yelp Fusion API key. Pricing is pay per event: $0.25 per 1,000 reviews on the Apify Free plan, down to $0.20 per 1,000 from Silver, plus $0.005 when a run starts.

**What makes it different:** Yelp's "all languages" setting only returns English reviews. This Actor reads each language Yelp lists for the business, one after the other, so a business with reviews in 14 languages comes back in 14 languages (17,131 of 17,131 on Katz's Delicatessen). It also filters by star rating and keyword, and has a **New reviews only** mode that remembers what it already delivered, so a scheduled run charges only for new reviews.

***

### What does Yelp Reviews Scraper do?

For each business you give it, the Actor:

1. Reads the business alias from the URL (the part after `/biz/`), on any Yelp domain, and turns it into Yelp's internal business id. A bare id works too.
2. Reads the business profile: name, categories, address, coordinates, phone, website, price range, hours, rating, and the number of reviews per star and per language.
3. Reads the reviews 49 at a time (Yelp's own page size), one language after another, eight pages in parallel, in the order you chose.
4. Applies your filters: stars (sent to Yelp), keywords and dates (checked by the Actor).
5. Pushes the reviews in batches of 100, and adds one summary row per business unless you turn it off.

Supported pages are business pages: `https://www.yelp.com/biz/<alias>`, with or without query strings, on `.com`, `.fr`, `.co.uk`, `.de`, `.ca`, `.com.au` and the other Yelp domains. Aliases with accents (`café-blanc-paris-7`) work typed or encoded.

### Why scrape Yelp reviews?

- **Reputation monitoring.** Schedule it in New reviews only mode for your own locations: each run returns only the reviews published since the last one, and you are not charged again for the ones you already have. A webhook tells Slack, Make, Zapier or n8n when a run ends.
- **Competitor research.** Read what customers praise or complain about at the businesses around yours, with the 1 and 2 star reviews only if you want.
- **Sentiment analysis and LLM pipelines.** The text is the original review, with its language code. Yelp's translation can be added in a separate column.
- **Owner reply tracking.** Which reviews got a reply, how fast, and from whom (owner or manager).
- **Datasets.** Complete review histories with stable review ids, permalinks, photos and exact timestamps.

Apify adds scheduling, an API for every run, integrations with Google Sheets, Slack, Zapier, Make and n8n, and exports to JSON, CSV and Excel.

### How to scrape Yelp reviews

#### From the Apify console

1. Click **Try for free** and open the Actor.
2. Open a business on Yelp and copy its URL, for example `https://www.yelp.com/biz/katzs-delicatessen-new-york`.
3. Paste it in **Yelp business URLs**, one per line.
4. Set **Max reviews per business**. The default is 100, and `0` means every review in every language.
5. Optionally pick languages, star ratings, keywords, a date, an order, a translation, or **New reviews only**.
6. Click **Start**, then export the dataset as JSON, CSV or Excel.

You only have a business name and a city? The sister Actor [Yelp Scraper](https://apify.com/alexmorain/yelp-scraper) searches Yelp by keyword and location and returns the businesses, with their reviews if you want.

### Which fields should I fill?

| I want to... | Fill | Notes |
|---|---|---|
| Try it once | **Yelp business URLs** | The prefilled business with 20 reviews costs about one cent on the Free plan and took 16 seconds in our test. |
| Get every review of a business | **Max reviews per business** = `0` | Every language. One charged result per review, so this is also your cost cap per business. |
| Get only some languages | **Review languages** | Codes such as `en`, `fr`, `de`, `es`, `ja`. Empty = every language. |
| Get only bad reviews | **Star ratings** = `1 star`, `2 stars` | Filtered by Yelp, so the Actor reads and charges only those. |
| Find reviews mentioning a topic | **Keywords** | Case insensitive, any of the words. Every review is read, only matching ones are delivered and charged. |
| Get reviews since a date | **Only reviews published after** or **Only reviews from the last N days** | Newest first is the only order that stops reading early at the date. |
| Translate into one language | **Translate to** | Adds Yelp's own translation in `textTranslated`. `text` stays the original. |
| Get the reviewer's profile | **Include reviewer details** | Name, profile, photo, home town, review, friend and photo counts, Elite year. Off by default. |
| Monitor a business | **New reviews only** = on | Add a **Monitoring key** for several independent watches on one business. |
| Be told when a run ends | **Webhook URL** | Receives a JSON summary. |
| Get a reviews-only CSV | **Add one summary row per business** = off | Otherwise the dataset also holds one `place` row per business. |

### Input examples

**One business, the 20 newest reviews:**

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

**Every review of a business, in every language:**

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

**The 1 and 2 star reviews of two restaurants since January 2025, translated into English:**

```json
{
    "startUrls": [
        "https://www.yelp.com/biz/katzs-delicatessen-new-york",
        "https://www.yelp.fr/biz/café-blanc-paris-7"
    ],
    "maxReviewsPerBusiness": 0,
    "ratings": ["1", "2"],
    "reviewsNewerThan": "2025-01-01",
    "translateTo": "en"
}
```

**French and German reviews that mention the service or the wait:**

```json
{
    "startUrls": ["https://www.yelp.com/biz/katzs-delicatessen-new-york"],
    "maxReviewsPerBusiness": 0,
    "languages": ["fr", "de"],
    "keywords": ["service", "attente", "warten"]
}
```

**Daily monitoring of your locations, with a webhook:**

```json
{
    "startUrls": [
        "https://www.yelp.com/biz/your-business-new-york",
        "https://www.yelp.com/biz/your-business-brooklyn"
    ],
    "maxReviewsPerBusiness": 0,
    "newOnly": true,
    "webhookUrl": "https://hooks.example.com/yelp"
}
```

### Details that need a word

- **"All languages" on Yelp means English.** Ask Yelp for its reviews in all languages and you get the English ones only. The Actor reads the business's review count per language first, then each language in turn. On Katz's Delicatessen that is 14 languages, from 16,930 English reviews down to one in Danish, Norwegian and Polish.
- **The count Yelp shows can be a few reviews short.** Katz's page announces 17,126 reviews, its per-language counts add up to 17,131, and the Actor returned 17,131 with 17,131 unique ids. The summary row gives both: `reviewsCount` (the headline number) and `reviewCountsByLanguage`.
- **49 reviews per page.** Yelp refuses 50. The Actor reads 49 at a time and checks the number of pages against the announced count, so no page is skipped.
- **Star filter by Yelp, keyword and date filters by the Actor.** A star filter is applied by Yelp and only the matching reviews are read. Keywords are checked on every review the Actor reads. A date stops the reading early only with newest first.
- **Translation is Yelp's own.** With **Translate to**, `textTranslated` holds the translation Yelp shows on its site and `translatedTo` the target language. A review already in that language has `textTranslated: null` rather than a copy of the text.
- **Updated reviews.** When a customer edits a review, Yelp keeps the new version. `isUpdated` is `true` on those, and `publishedAt` is the date Yelp shows.
- **Line breaks are kept** in the review text and in the owner's reply.
- **One business twice is read once**, and a business Yelp does not know is reported and skipped. The run is marked failed only when every business failed.
- **IP and proxy.** The Actor starts from the Apify IP. If Yelp answers 403, 429 or a server error, it moves to the Apify datacenter proxy and takes a new IP for each later refusal. At start-up it checks that Yelp still accepts its queries, and stops with a clear message if not, instead of returning an empty dataset.

### What data can it extract? Every output field

Each review is one dataset row with `"type": "review"`.

| Field | Type | Description |
|---|---|---|
| `type` | string | `review` for a review, `place` for the summary row |
| `source` | string | Always `yelp` |
| `reviewId` | string | Yelp review id, stable across runs |
| `reviewUrl` | string | Permalink to the review on Yelp |
| `rating` | number | Stars, 1 to 5 |
| `ratingScale` | integer | Always `5` |
| `text` | string | The review, original language, line breaks kept |
| `language` | string | Language code the customer wrote in (`en`, `fr`, `de`...) |
| `textTranslated` | string | Yelp's translation, with **Translate to** only. `null` when the review is already in that language |
| `translatedTo` | string | Target language of `textTranslated` |
| `publishedAt` | string | Exact review date and time, ISO 8601 UTC |
| `isUpdated` | boolean | `true` when the customer edited the review |
| `photos` | array | URLs of the photos attached to the review, full size |
| `reactions` | object | Counts of `helpful`, `thanks`, `loveThis`, `ohNo` |
| `helpfulVotes` | integer | Same as `reactions.helpful` |
| `ownerResponse` | string | The business's public reply |
| `ownerResponseDate` | string | Date of the reply, ISO 8601 UTC |
| `ownerResponderRole` | string | Role of whoever replied, as Yelp shows it (`Owner`, `Manager`...) |
| `reviewerId` | string | Yelp user id. With **Include reviewer details** only |
| `reviewerName` | string | Name as Yelp shows it (first name and initial) |
| `reviewerProfileUrl` | string | Reviewer's Yelp profile |
| `reviewerPhotoUrl` | string | Reviewer's profile photo |
| `reviewerLocation` | string | Home town |
| `reviewerReviewCount` | integer | Number of reviews the reviewer wrote |
| `reviewerFriendCount` | integer | Number of Yelp friends |
| `reviewerPhotoCount` | integer | Number of photos posted |
| `reviewerEliteYear` | string | Latest Elite year, when the reviewer has one |
| `placeId` | string | Yelp business id |
| `placeName` | string | Business name |
| `placeType` | string | Always `business` on Yelp |
| `placeUrl` | string | `https://www.yelp.com/biz/<alias>` |
| `scrapedAt` | string | When the row was collected, ISO 8601 UTC |

`title` and `originalLanguage` are always `null` on Yelp: a review has no title, and the text is always the original. `isMachineTranslated` is `false`. They stay in the rows to keep the column names of the Tripadvisor, Booking.com, Agoda and Airbnb Actors.

#### The summary row

One row per business, with `"type": "place"`:

| Field | Description |
|---|---|
| `placeId`, `placeName`, `placeType`, `placeUrl`, `alias` | The business |
| `categories` | Yelp categories, such as `Delis`, `American` |
| `address`, `street`, `city`, `region`, `postalCode`, `countryCode` | Full address and its parts |
| `latitude`, `longitude` | Coordinates |
| `phone`, `website` | Contact details the business published |
| `priceRange` | `$` to `$$$$` |
| `isClaimed` | `true` when the owner claimed the page |
| `hours` | Opening hours per day |
| `rating`, `ratingScale` | Overall rating, out of 5 |
| `reviewsCount` | Number of reviews Yelp announces |
| `reviewCountsByRating` | Reviews per star, `"1"` to `"5"` |
| `reviewCountsByLanguage` | Reviews per language |
| `photoUrl` | Main photo of the business |
| `reviewsDelivered` | Reviews this run delivered |
| `input` | The URL you gave |
| `scrapedAt` | Collection time |

### Example output

A review row with a translation (Café Blanc, Paris; reviewer fields left out):

```json
{
    "type": "review",
    "source": "yelp",
    "placeId": "J8q2EjxuOk3v19R5xQWAFA",
    "placeName": "Café Blanc",
    "placeType": "business",
    "placeUrl": "https://www.yelp.com/biz/caf%C3%A9-blanc-paris-7",
    "reviewId": "nHeXQY4gAv0qhL-kM-uiKQ",
    "reviewUrl": "https://www.yelp.com/biz/caf%C3%A9-blanc-paris-7?hrid=nHeXQY4gAv0qhL-kM-uiKQ",
    "rating": 5,
    "ratingScale": 5,
    "title": null,
    "text": "Le meilleur croque madame que j'ai jamais mangé de ma vie!...  tout simplemente délicieux",
    "language": "fr",
    "textTranslated": "The best croque madame I've ever eaten in my life!... simply delicious",
    "translatedTo": "en",
    "publishedAt": "2021-08-05T21:55:16Z",
    "isUpdated": false,
    "photos": ["https://s3-media0.fl.yelpcdn.com/bphoto/FcXUbF_n--KoOmPYm6I6_g/o.jpg"],
    "helpfulVotes": 0,
    "reactions": {"helpful": 0, "thanks": 0, "loveThis": 0, "ohNo": 0},
    "ownerResponse": null,
    "ownerResponseDate": null,
    "ownerResponderRole": null
}
```

With **Include reviewer details** on, the same row also carries (example values):

```json
{
    "reviewerId": "abcDEF123ghiJKL456mnoP",
    "reviewerName": "Anna B.",
    "reviewerProfileUrl": "https://www.yelp.com/user_details?userid=abcDEF123ghiJKL456mnoP",
    "reviewerLocation": "Lyon, France",
    "reviewerReviewCount": 26,
    "reviewerFriendCount": 1,
    "reviewerPhotoCount": 50,
    "reviewerEliteYear": null
}
```

A summary row (Katz's Delicatessen, hours and photo left out):

```json
{
    "type": "place",
    "source": "yelp",
    "placeName": "Katz's Delicatessen",
    "categories": ["Delis", "American"],
    "address": "205 E Houston St, New York, NY 10002",
    "phone": "(212) 254-2246",
    "priceRange": "$$",
    "rating": 4.1,
    "reviewsCount": 17126,
    "reviewCountsByRating": {"1": 1074, "2": 960, "3": 1906, "4": 4424, "5": 8767},
    "reviewCountsByLanguage": {"en": 16930, "de": 62, "es": 43, "fr": 38, "it": 25, "ja": 11, "pt": 6, "sv": 5, "tr": 3, "zh": 3, "nl": 2, "nb": 1, "da": 1, "pl": 1},
    "reviewsDelivered": 17131,
    "input": "https://www.yelp.com/biz/katzs-delicatessen-new-york"
}
```

### How many Yelp reviews can it get? Measurements

Yelp's review feed has no page limit we could find. We compared what Yelp announces with what the Actor returned and with the number of unique review ids. All runs below are on the Apify platform, 7 and 8 November 2026.

| Business | Announced | Per-language total | Returned | Unique ids | Time |
|---|---|---|---|---|---|
| Katz's Delicatessen, New York | 17,126 | 17,131 (14 languages) | 17,131 | 17,131 | 148 s |
| McGrath Elmhurst Toyota, Elmhurst | 322 | 322 (English) | 322 | 322 | 14 s, with Café Blanc in the same run |
| Café Blanc, Paris | 80 | 80 (78 en, 2 fr) | 80 | 80 | 5 s |

What the first 3,000 Katz reviews (newest first) look like: 438 have an owner reply, 1,398 have photos, 127 were edited by their author.

### Monitor new Yelp reviews: New reviews only mode

Turn on **New reviews only** and schedule the Actor.

- The Actor keeps a registry per business in a named key-value store of your account, `yelp-reviews-registry`, with the ids of the reviews already delivered.
- Set **Max reviews per business** to `0` on the first run. A run stopped by the review limit, a spend limit, a timeout or unreadable pages is not recorded as a complete read, and the next run reads the full history again. Reviews already delivered are never returned or charged twice.
- After a complete read, later runs read only the reviews newer than that read minus 30 days, which covers reviews Yelp shows late.
- Skipped reviews are not charged. The status message says how many were skipped.
- A **Monitoring key** names the watch yourself, for example one per client on the same business. Without it, there is one watch per business and set of filters.

We tested it on Café Blanc: the first run delivered its 80 reviews, the second run delivered 0 reviews and was charged only its start fee and the summary row. Turn off the summary row to keep monitoring runs at the start fee when nothing is new.

#### Webhook at the end of the run

Fill **Webhook URL** and the Actor sends one JSON POST when it has finished reading (example values):

```json
{
    "actor": "yelp-reviews-scraper",
    "runId": "abc123",
    "datasetId": "def456",
    "mode": "new-only",
    "status": "succeeded",
    "places": 2,
    "reviews": 3,
    "skippedAlreadySeen": 412,
    "targets": 2,
    "failedTargets": 0,
    "chargeLimitReached": false
}
```

`status` is `succeeded`, `partial` (some businesses failed) or `failed` (every business failed). The URL is stored as a secret and is never written to the log. The call has a 15 second timeout, a 307 or 308 redirect is followed once, and a failure never changes the run's result.

### Export Yelp reviews to CSV, Excel or JSON

Open the run, go to **Storage** or the **Output** tab, and choose JSON, CSV, Excel, HTML or XML. From the API:

```
https://api.apify.com/v2/datasets/<DATASET_ID>/items?format=csv&token=<YOUR_API_TOKEN>
```

For a reviews-only file, turn off **Add one summary row per business**, or filter on the `type` column after the export.

### Using the Yelp reviews API from your code

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_API_TOKEN>")
run = client.actor("alexmorain/yelp-reviews-scraper").call(run_input={
    "startUrls": ["https://www.yelp.com/biz/katzs-delicatessen-new-york"],
    "maxReviewsPerBusiness": 500,
    "ratings": ["1", "2"],
})
for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    if row["type"] == "review":
        print(row["publishedAt"], row["rating"], row["language"], row["ownerResponse"] is not None)
```

#### JavaScript

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

const client = new ApifyClient({ token: '<YOUR_API_TOKEN>' });
const run = await client.actor('alexmorain/yelp-reviews-scraper').call({
    startUrls: ['https://www.yelp.com/biz/katzs-delicatessen-new-york'],
    maxReviewsPerBusiness: 0,
    languages: ['fr', 'de', 'es'],
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.filter((row) => row.type === 'review').length);
```

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/alexmorain~yelp-reviews-scraper/run-sync-get-dataset-items?token=<YOUR_API_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"startUrls": ["https://www.yelp.com/biz/katzs-delicatessen-new-york"], "maxReviewsPerBusiness": 50}'
```

This call waits for the run and returns the items. For large businesses, start the run with `POST /v2/acts/alexmorain~yelp-reviews-scraper/runs` and read the dataset when it ends.

### What people use it for

#### Multi-location reputation monitoring

List your locations, turn on New reviews only, schedule a daily run and send the webhook to a chat channel. A run with a few new reviews costs under one cent.

#### Finding what makes customers unhappy

Run it on your competitors with **Star ratings** set to 1 and 2 stars. Yelp filters them, so you pay only for those reviews.

#### Topic research across languages

Combine **Review languages** and **Keywords** to pull every French or German review that mentions parking, waiting time or a dish.

#### Owner reply analysis

`ownerResponse`, `ownerResponseDate` and `ownerResponderRole` show which businesses answer their reviews, how fast, and who answers.

#### Review datasets

Complete histories with stable ids, permalinks, photos and reaction counts, for a list of businesses you choose.

### Yelp Reviews Scraper pricing

You pay per event. There is no monthly rental.

| Event | Free plan | Bronze | Silver | Gold and above |
|---|---|---|---|---|
| Review (per 1,000) | $0.25 | $0.225 | $0.20 | $0.20 |
| Business profile, the summary row (per 1,000) | $1.00 | $0.90 | $0.80 | $0.50 |
| Actor start (per run, per GB of memory, minimum one) | $0.005 | $0.005 | $0.005 | $0.005 |

The Actor runs with 512 MB, so the start fee is $0.005 per run. The tier that applies is the one of your Apify plan.

| Job | Free plan | Gold plan |
|---|---|---|
| 20 reviews, one business | $0.011 | $0.0095 |
| 1,000 reviews, one business | $0.256 | $0.206 |
| All 17,131 reviews of Katz's Delicatessen | $4.29 | $3.43 |
| Daily monitoring run with 5 new reviews | $0.007 | $0.007 |

Each worked example is the reviews plus one summary row plus the start fee. The $5 of monthly credit in the Apify Free plan covers about 19,000 reviews.

**Cost control.** **Max reviews per business** caps each business, and a star filter means the other reviews are never read. You can also set a maximum cost for the run in the Apify run options. We tested it on this Actor: with a limit of $0.05 on a Bronze account, the run stopped after 200 reviews, exactly 200 reviews were charged, and the status message said the limit was reached. Reviews already delivered in New reviews only mode are not charged again.

### Limits and what this Actor does not do

- **Business pages only.** It does not search Yelp. For a keyword and a city, use [Yelp Scraper](https://apify.com/alexmorain/yelp-scraper).
- **Recommended reviews only.** Yelp hides some reviews under "not currently recommended". They are not in Yelp's review feed and are not returned.
- **No review title.** Yelp reviews have none.
- **Keyword filter is not free of reads.** Yelp has no keyword filter for reviews, so every review is read and only matching ones are delivered and charged. A run with keywords takes as long as a full read.
- **Translations are limited to Yelp's languages**: English, French, German, Spanish, Italian, Portuguese, Dutch, Japanese and Chinese.
- **Reviewer data is limited to what Yelp shows publicly**: display name, home town, profile link and photo, counts and Elite year.
- **Above 17,131 reviews is not measured.** Katz's Delicatessen is the largest business we read in full.

### FAQ

#### Is there a Yelp reviews API?

Yelp's official Fusion API returns three review excerpts per business. This Actor does not use it. It reads the review data that the public business page loads and returns it as JSON through the Apify API, with the full text of every review. You call it with an Apify token.

#### How do I scrape Yelp reviews?

Paste the business URL in the Actor, set the maximum number of reviews, press Start, and download the dataset as CSV, Excel or JSON.

#### How do I export Yelp reviews to CSV or Excel?

Run the Actor, open the dataset and choose CSV or Excel. Turn off the summary row if you want only reviews in the file.

#### How many reviews can I scrape from one Yelp business?

All of them. We read 17,131 of 17,131 on Katz's Delicatessen in 148 seconds. Set **Max reviews per business** to `0`.

#### Why do I get more reviews than the count on the Yelp page?

Yelp's headline count and its per-language counts are computed separately and can differ by a few reviews. The Actor follows the per-language counts and reads every language. On Katz's the page says 17,126, the languages add up to 17,131, and 17,131 unique reviews came back.

#### Why are some reviews missing compared with what I see on Yelp?

Check the language and star filters. If none are set, the missing reviews are probably in Yelp's "not currently recommended" section, which this Actor does not read.

#### Does it get non-English Yelp reviews?

Yes, all of them by default. Leave **Review languages** empty and the Actor reads each language the business has. Fill it to keep only some.

#### Can I get only the 1 star Yelp reviews?

Yes. Set **Star ratings** to `1 star`. Yelp applies the filter, so the run is fast and you pay only for those reviews.

#### Is the review text translated?

No. `text` is always the original, with its `language` code. With **Translate to**, Yelp's translation goes into a separate `textTranslated` column.

#### Can I scrape the reviews of several businesses in one run?

Yes. Paste all of them in **Yelp business URLs**. A business Yelp does not know is skipped without stopping the run.

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

No. The Actor reads public pages, without login, through the Apify proxy.

#### How do I monitor new Yelp reviews?

Turn on New reviews only, schedule the Actor daily or weekly and add a webhook. See the monitoring section.

#### Is it legal to scrape Yelp reviews?

The Actor reads pages that anyone can open without logging in. Reviewer details are off by default; when you turn them on, the output contains data that reviewers made public: a display name, a home town, a profile link and photo. Personal data is protected by the GDPR in the European Union and by similar laws elsewhere. Use the data for a legitimate purpose, check Yelp's terms and take legal advice for your own use. This is not legal advice.

### Integrations, exports and support

Connect the dataset to Google Sheets, Slack, Zapier, Make or n8n with Apify's integrations, or use the Apify API and client libraries. Runs can be scheduled from the console.

Something not working, or a field you need? Open an issue in the **Issues** tab. The same developer publishes [Yelp Scraper](https://apify.com/alexmorain/yelp-scraper), [Tripadvisor Reviews Scraper](https://apify.com/alexmorain/tripadvisor-reviews-scraper), [Booking.com Reviews Scraper](https://apify.com/alexmorain/booking-reviews-scraper), [Agoda Reviews Scraper](https://apify.com/alexmorain/agoda-reviews-scraper) and [Airbnb Reviews Scraper](https://apify.com/alexmorain/airbnb-reviews-scraper), with the same column names.

### Guide and use cases

Use cases for outbound and automation, the output fields, pricing and common questions are on the [Yelp Reviews Scraper page](https://alexis.morain.fr/en/scrapers/yelp-reviews-scraper/) of my site. The [Reviews family page](https://alexis.morain.fr/en/scrapers/families/reviews/) puts it side by side with the other scrapers of the same family.

# Actor input Schema

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

Yelp business pages, one per line, such as <code>https://www.yelp.com/biz/katzs-delicatessen-new-york</code>. Any Yelp domain works (.com, .fr, .co.uk…) and query strings are fine. A 22-character business id such as <code>V7lXZKBDzScDeGB8JmnzSA</code> works too.

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

<b>0 = every review</b>, in every language. Each review is one charged result, so this is also your cost cap per business.

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

Language codes such as en, fr, de, es, it, ja, zh. <b>Empty = every language</b>: the actor reads each language Yelp lists for the business, one by one (Yelp's own "all languages" option only returns English reviews).

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

Only reviews with these ratings, filtered by Yelp itself. Empty = all.

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

Only reviews whose text contains at least one of these words or phrases (case insensitive). Every review is read and only matching ones are delivered and charged. Empty = all reviews.

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

Newest first is the default and the only order that stops early on a date filter.

## `reviewsNewerThan` (type: `string`):

Fixed start date (YYYY-MM-DD). Leave empty for the full history.

## `lastDays` (type: `integer`):

Rolling window, handy for scheduled runs. If both dates are set, the later one wins.

## `translateTo` (type: `string`):

Adds Yelp's own machine translation in <code>textTranslated</code>. <code>text</code> always stays the original.

## `includeReviewerDetails` (type: `boolean`):

Adds the reviewer's name, profile URL, photo, home town, review, friend and photo counts and Elite year. Off by default: these are personal data, collect them only if you have a lawful reason to.

## `newOnly` (type: `boolean`):

Remembers, per business, which reviews it already delivered and returns only the new ones on the next run. Already delivered reviews are not charged again. Schedule it daily or weekly.

## `registryKey` (type: `string`):

Name your monitoring memory to run several independent watches on the same business (one per client, say). Empty = one memory per business and filter set.

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

Receives a JSON summary when the run ends (reviews, businesses, status, dataset id). Works with Slack, Make, Zapier, n8n.

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

One extra row per business with address, phone, website, hours, rating, review counts by star and by language (charged as a business).

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

Requests start from the Apify IP and move to the datacenter proxy only if Yelp refuses. No residential proxy needed.

## Actor input object example

```json
{
  "startUrls": [
    "https://www.yelp.com/biz/katzs-delicatessen-new-york"
  ],
  "maxReviewsPerBusiness": 20,
  "sortBy": "newest",
  "includeReviewerDetails": false,
  "newOnly": false,
  "includeBusinessSummary": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

One row per review

## `businesses` (type: `string`):

One row per business

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

Every row with all fields

# 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": [
        "https://www.yelp.com/biz/katzs-delicatessen-new-york"
    ],
    "maxReviewsPerBusiness": 20,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("alexmorain/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": ["https://www.yelp.com/biz/katzs-delicatessen-new-york"],
    "maxReviewsPerBusiness": 20,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("alexmorain/yelp-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": [
    "https://www.yelp.com/biz/katzs-delicatessen-new-york"
  ],
  "maxReviewsPerBusiness": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call alexmorain/yelp-reviews-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,alexmorain/yelp-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/3W8a8Vy3un97qmhKV/builds/81ILhg6fian2ULbed/openapi.json
