# Yelp Scraper: Businesses, Phones, Hours & Reviews (`alexmorain/yelp-scraper`) Actor

Search Yelp by keyword and city and get one row per business: name, categories, address, GPS, phone, website, price, hours, rating and review counts. Up to 240 results per search, reviews optional, new-businesses-only monitoring, webhook.

- **URL**: https://apify.com/alexmorain/yelp-scraper.md
- **Developed by:** [Alexis Morain](https://apify.com/alexmorain) (community)
- **Categories:** Lead generation, 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 $1.50 / 1,000 business listings

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 Scraper

This Actor searches Yelp like you would in its search box, a keyword and a place, and returns one row per business: name, categories, full address and its parts, GPS coordinates, phone, website, price range, opening hours, rating, number of reviews per star and per language, whether the page is claimed, main photo, and the business's rank in the search. Reviews can be added after each business with one switch.

It works as a **Yelp search API**: plain HTTP requests to the data sources Yelp's own pages use. No browser, no Yelp account, no residential proxy, no Yelp Fusion API key. Pricing is pay per event: $2.00 per 1,000 businesses on the Apify Free plan, down to $1.50 per 1,000 on Gold, plus $0.25 per 1,000 reviews when you ask for them and $0.005 when a run starts.

**What makes it different:** up to 240 businesses per search, which is all Yelp serves for one query, with no repeats (240 of 240 unique on "pizza, San Francisco" in 49 seconds). Sponsored results are left out unless you want them. A **New businesses only** mode remembers what it already delivered, so a scheduled run returns and charges only the businesses that appeared since.

***

### What does Yelp Scraper do?

For each search, meaning each keyword in each location, the Actor:

1. Asks Yelp for the first page of results. The answer announces the number of results, which tells the Actor how many pages to read (10 businesses per page, 240 at most).
2. Reads the pages in order on a single session, so the ranking stays the one Yelp shows to one visitor. Sponsored results are dropped unless **Include ads** is on.
3. Reads each business's profile, six businesses at a time: address, coordinates, phone, website, hours, price range, rating, review counts.
4. Pushes one row per business, with its rank in the search, and its reviews right after it if **Also scrape reviews** is on.

You can also paste Yelp search URLs, with their filters (category, price, features, open now, neighbourhood, map area), or business URLs directly.

### Why scrape Yelp?

- **Lead generation.** Every plumber, dentist or hair salon in a city, with phone, website and address, ready for a CRM or a calling list.
- **Local market studies.** How many businesses of a kind in each neighbourhood, their ratings, their review volume, their price range.
- **Competitor mapping.** The businesses that rank around yours for the searches your customers make, with coordinates for a map.
- **New openings watch.** Schedule a search in New businesses only mode: each run returns only the businesses that were not in the previous results.
- **Review datasets.** Turn on reviews and get each business followed by its reviews, in every language.

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

#### From the Apify console

1. Click **Try for free** and open the Actor.
2. Type what you are looking for in **Search terms**, for example `pizza`, one per line.
3. Type where in **Locations**, for example `San Francisco, CA`, one per line. A neighbourhood, an address or a zip code works too. Each search term is run in each location.
4. Set **Max businesses per search**. The default is 50, and `0` means all 240 Yelp serves.
5. Optionally turn on **Also scrape reviews**, **Include ads** or **New businesses only**.
6. Click **Start**, then export the dataset as JSON, CSV or Excel.

Already have a Yelp search with filters? Copy its URL from your browser into **Yelp URLs** instead.

### Which fields should I fill?

| I want to... | Fill | Notes |
|---|---|---|
| Try it once | **Search terms** and **Locations** | The prefilled search, 10 pizza places in San Francisco, costs about three cents on the Free plan. |
| All the results of a search | **Max businesses per search** = `0` | 240 at most: that is all Yelp serves for one query. |
| More than 240 businesses | Several **Locations** | Split the city into neighbourhoods or zip codes. A business found twice in one run is delivered once. |
| Use Yelp's filters | **Yelp URLs** | Paste a search URL. Category, price, features, open now, neighbourhood and map area are kept. |
| Scrape known businesses | **Yelp URLs** | Business pages (`/biz/...`) are read directly, no search. |
| Get reviews too | **Also scrape reviews** = on | Then **Max reviews per business** (default 20, `0` = all) and the review filters apply. |
| Keep sponsored results | **Include ads** = on | Off by default. |
| Watch new businesses | **New businesses only** = on | Businesses already delivered are skipped and not charged. |
| Be told when a run ends | **Webhook URL** | Receives a JSON summary. |

### Input examples

**The first 10 pizza places in San Francisco:**

```json
{
    "searchTerms": ["pizza"],
    "locations": ["San Francisco, CA"],
    "maxBusinessesPerSearch": 10
}
```

**Every dentist and plumber Yelp lists in three Chicago zip codes:**

```json
{
    "searchTerms": ["dentist", "plumber"],
    "locations": ["60614", "60657", "60613"],
    "maxBusinessesPerSearch": 0
}
```

**A filtered Yelp search, pasted from the browser:**

```json
{
    "startUrls": ["https://www.yelp.com/search?find_desc=coffee&find_loc=Brooklyn%2C+NY&attrs=WiFi.free"],
    "maxBusinessesPerSearch": 0
}
```

**Ramen places in Paris with their French reviews:**

```json
{
    "searchTerms": ["ramen"],
    "locations": ["Paris, France"],
    "maxBusinessesPerSearch": 5,
    "includeReviews": true,
    "maxReviewsPerBusiness": 30,
    "languages": ["fr"]
}
```

**Weekly watch of new restaurants in a neighbourhood, with a webhook:**

```json
{
    "searchTerms": ["restaurants"],
    "locations": ["Williamsburg, Brooklyn, NY"],
    "maxBusinessesPerSearch": 0,
    "newOnly": true,
    "webhookUrl": "https://hooks.example.com/yelp"
}
```

### Details that need a word

- **240 results per search, never more.** Yelp stops serving results after the 240th, whatever the query. For more businesses, run the same keyword in several smaller locations. The run reads them all and delivers each business once.
- **Ranking depends on the visitor.** Yelp orders results differently from one session to another, and the top 240 shifts a little between runs. The Actor reads a search on one session, so the list it returns has no repeats and no holes: 240 of 240 unique businesses on "pizza, San Francisco". Two runs of the same search a few hours apart can still differ at the edges. `searchRank` is the rank in this run.
- **Sponsored results are dropped** by default, so the ranks follow the organic results. Turn on **Include ads** to keep them.
- **Business row first, then its reviews.** With reviews on, each business row comes before its own reviews in the dataset, and every review carries the business's `placeId` for joins.
- **Reviews in every language.** Yelp's "all languages" setting returns English only. With reviews on and **Review languages** empty, the Actor reads each language the business has, one after the other.
- **Phone and website** are those the business published on Yelp. Some businesses have neither, and the fields are then `null`.
- **IP and proxy.** The Actor starts from the Apify IP. If Yelp answers 401, 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 business is one dataset row with `"type": "business"`.

| Field | Type | Description |
|---|---|---|
| `type` | string | `business`, or `review` with reviews on |
| `source` | string | Always `yelp` |
| `placeId` | string | Yelp business id, stable across runs |
| `placeName` | string | Business name |
| `placeType` | string | Always `business` |
| `placeUrl` | string | `https://www.yelp.com/biz/<alias>` |
| `alias` | string | The business's Yelp alias |
| `categories` | array | Yelp categories, such as `Pizza`, `Italian` |
| `address` | string | Full address on one line |
| `street`, `city`, `region`, `postalCode`, `countryCode` | string | Address parts |
| `latitude`, `longitude` | number | Coordinates |
| `phone` | string | Phone number as published |
| `website` | string | The business's own website |
| `priceRange` | string | `$` to `$$$$` |
| `isClaimed` | boolean | `true` when the owner claimed the page |
| `hours` | object | Opening hours per day, as lists of ranges |
| `rating`, `ratingScale` | number | Overall rating, out of 5 |
| `reviewsCount` | integer | Number of reviews Yelp announces |
| `reviewCountsByRating` | object | Reviews per star, `"1"` to `"5"` |
| `reviewCountsByLanguage` | object | Reviews per language |
| `photoUrl` | string | Main photo |
| `searchQuery`, `searchLocation` | string | The search that found the business |
| `searchRank` | integer | Rank in the results, from 1 |
| `reviewsDelivered` | integer | Reviews delivered for it, with reviews on. `null` otherwise |
| `input` | string | The search or URL that led to it |
| `scrapedAt` | string | When the row was collected, ISO 8601 UTC |

#### Review rows

With **Also scrape reviews** on, each review is a row with `"type": "review"`: `reviewId`, `reviewUrl`, `rating`, `text` (original language), `language`, `publishedAt`, `isUpdated`, `photos`, `reactions`, `helpfulVotes`, `ownerResponse`, `ownerResponseDate`, `ownerResponderRole`, the optional translation (`textTranslated`, `translatedTo`) and reviewer details, plus `placeId` and `placeName`. They are the same rows as in [Yelp Reviews Scraper](https://apify.com/alexmorain/yelp-reviews-scraper), whose README lists every review field.

### Example output

A business row (from the "ramen, Paris" search, hours shortened):

```json
{
    "type": "business",
    "source": "yelp",
    "placeId": "WGm2729Xmwt0XJvRq0lN3w",
    "placeName": "Kodawari Ramen",
    "placeType": "business",
    "placeUrl": "https://www.yelp.com/biz/kodawari-ramen-paris-8",
    "alias": "kodawari-ramen-paris-8",
    "categories": ["Ramen"],
    "address": "12 rue de Richelieu, 75001 Paris, France",
    "street": "12 rue de Richelieu",
    "city": "Paris",
    "region": "01",
    "postalCode": "75001",
    "countryCode": "FR",
    "latitude": 48.864387,
    "longitude": 2.3362552,
    "phone": "01 42 61 34 60",
    "website": "https://www.kodawari-ramen.com",
    "priceRange": null,
    "isClaimed": true,
    "hours": {"Monday": ["11:45 AM - 11:00 PM"], "Sunday": ["11:45 AM - 11:00 PM"]},
    "rating": 4.2,
    "ratingScale": 5,
    "reviewsCount": 80,
    "reviewCountsByRating": {"1": 5, "2": 4, "3": 5, "4": 21, "5": 45},
    "reviewCountsByLanguage": {"en": 65, "fr": 12, "de": 1, "zh": 1, "es": 1},
    "photoUrl": "https://s3-media0.fl.yelpcdn.com/bphoto/fTA1HJ3j2Tq5T7WOcN7hkw/l.jpg",
    "searchQuery": "ramen",
    "searchLocation": "Paris, France",
    "searchRank": 2,
    "input": "ramen @ Paris, France",
    "scrapedAt": "2026-11-08T02:15:12Z"
}
```

A review row that follows it (reviewer fields left out):

```json
{
    "type": "review",
    "source": "yelp",
    "placeId": "WGm2729Xmwt0XJvRq0lN3w",
    "placeName": "Kodawari Ramen",
    "reviewId": "w7ftFpwSqaZxew12CSJIKg",
    "reviewUrl": "https://www.yelp.com/biz/kodawari-ramen-paris-8?hrid=w7ftFpwSqaZxew12CSJIKg",
    "rating": 5,
    "text": "Exactement ce que j'en attendais. Le bouillon du sesame noir et à l'ail peut être clivant mais un délice pour ceux qui apprécient. Le bouillon de poulet fermier est excellent. On ressent la qualité des produits",
    "language": "fr",
    "publishedAt": "2024-07-19T19:57:01Z",
    "photos": ["https://s3-media0.fl.yelpcdn.com/bphoto/egkcQ0bMuhyiZWBGVHouzA/o.jpg"],
    "reactions": {"helpful": 0, "thanks": 0, "loveThis": 0, "ohNo": 0},
    "ownerResponse": null
}
```

### How many businesses can it get? Measurements

All runs below are on the Apify platform, 7 and 8 November 2026.

| Search | Asked | Returned | Unique | Time |
|---|---|---|---|---|
| pizza, San Francisco, CA | all (240) | 240 | 240 | 49 s |
| Same search, second run in New businesses only mode | all | 0 new, 240 skipped | | 25 s |
| ramen, Paris, France, with French reviews (30 max) | 5 | 5 businesses, 126 reviews | 5 | |

In the ramen run, each business row came before its reviews, and the review counts matched the French counts Yelp announces (12, 24, then 30 for the three businesses with more than 30).

### Monitor new businesses: New businesses only mode

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

- The Actor keeps the ids of the businesses already delivered in a named key-value store of your account, `yelp-scraper-registry`.
- A business already delivered is skipped before its profile is read, so it is neither returned nor charged. The status message says how many were skipped.
- With **Also scrape reviews** on, the mode also applies to reviews: a known business is read again, and only its new reviews are delivered and charged.
- A **Monitoring key** names the watch yourself, for example one per client. Without it, there is one watch per set of searches and filters.

#### Webhook at the end of the run

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

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

`places` counts the businesses delivered, `skippedBusinesses` those skipped because an earlier run delivered them, and `skippedAlreadySeen` the reviews skipped the same way. `status` is `succeeded`, `partial` (some searches or businesses failed) or `failed` (nothing could be read). The URL is stored as a secret and is never written to the log. The call has a 15 second timeout, and a failure never changes the run's result.

### Export Yelp data 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>
```

With reviews on, filter on the `type` column to split businesses and reviews, and join them on `placeId`.

### Using the Yelp scraper API from your code

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_API_TOKEN>")
run = client.actor("alexmorain/yelp-scraper").call(run_input={
    "searchTerms": ["dentist"],
    "locations": ["Austin, TX"],
    "maxBusinessesPerSearch": 0,
})
for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(row["searchRank"], row["placeName"], row["phone"], row["website"])
```

#### JavaScript

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

const client = new ApifyClient({ token: '<YOUR_API_TOKEN>' });
const run = await client.actor('alexmorain/yelp-scraper').call({
    searchTerms: ['coffee'],
    locations: ['Seattle, WA'],
    maxBusinessesPerSearch: 100,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.filter((row) => row.phone).length);
```

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/alexmorain~yelp-scraper/run-sync-get-dataset-items?token=<YOUR_API_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"searchTerms": ["pizza"], "locations": ["San Francisco, CA"], "maxBusinessesPerSearch": 10}'
```

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

### What people use it for

#### Local lead lists

A trade and a list of zip codes give a list of businesses with phone, website and address, deduplicated across zip codes.

#### Market sizing

Count the businesses of a category per neighbourhood, with their ratings, review volume and price range.

#### Store location and competition maps

Coordinates, ratings and review counts of every competitor that shows up for your customers' searches.

#### New openings

A weekly run in New businesses only mode returns the businesses that were not in last week's results.

#### Business and review datasets

Turn on reviews to get each business followed by its reviews, in every language, with stable ids.

### Yelp Scraper pricing

You pay per event. There is no monthly rental.

| Event | Free plan | Bronze | Silver | Gold and above |
|---|---|---|---|---|
| Business listing (per 1,000) | $2.00 | $1.80 | $1.60 | $1.50 |
| Review, with reviews on (per 1,000) | $0.25 | $0.225 | $0.20 | $0.20 |
| 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 |
|---|---|---|
| 10 businesses, one search | $0.025 | $0.020 |
| 240 businesses, one full search | $0.485 | $0.365 |
| 50 businesses with 20 reviews each | $0.355 | $0.280 |
| Weekly watch with 4 new businesses | $0.013 | $0.011 |

The $5 of monthly credit in the Apify Free plan covers about 2,400 businesses.

**Cost control.** **Max businesses per search** caps each search and **Max reviews per business** caps each business. You can also set a maximum cost for the run in the Apify run options: the run stops when it is reached and says so in its status message. Businesses already delivered in New businesses only mode are not charged again.

### Limits and what this Actor does not do

- **240 businesses per search.** Yelp's own limit. Split the location for more.
- **The ranking is Yelp's for one session.** Another visitor, or another run, can see a slightly different order and top 240.
- **No email addresses.** Yelp does not publish them. Use the `website` column to look further.
- **Reviews are the recommended ones.** Yelp's "not currently recommended" reviews are not read.
- **Business details are those on Yelp.** A business that did not publish a phone, website or hours has `null` there.

### FAQ

#### Is there a Yelp API to search businesses?

Yelp's official Fusion API has a business search with its own key and quotas. This Actor does not use it. It reads the results and business data that Yelp's public pages load, and returns them as JSON through the Apify API. You call it with an Apify token.

#### How do I scrape Yelp search results?

Type a search term and a location in the Actor, set the maximum number of businesses, press Start, and download the dataset as CSV, Excel or JSON.

#### How do I get more than 240 businesses from Yelp?

Yelp serves at most 240 results per query. Put several smaller locations in **Locations**, such as neighbourhoods or zip codes. The Actor runs the search in each and delivers each business once.

#### Does it get phone numbers and websites?

Yes, when the business published them on Yelp: `phone` and `website` are in every business row.

#### Can I scrape Yelp reviews with it?

Yes. Turn on **Also scrape reviews**. To read the reviews of businesses you already know, [Yelp Reviews Scraper](https://apify.com/alexmorain/yelp-reviews-scraper) is the simpler tool.

#### Why are the results different from what I see on Yelp?

Yelp ranks results per visitor and per session, and drops or adds a few businesses at the edges of the top 240 from one moment to the next. Sponsored results are also left out unless **Include ads** is on.

#### Can I use Yelp's filters?

Yes. Run the search on yelp.com with your filters, copy the URL, and paste it in **Yelp URLs**.

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

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

#### Is it legal to scrape Yelp?

The Actor reads pages that anyone can open without logging in. Business rows hold the contact details the businesses published. Reviews and reviewer details are off by default. 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 Reviews Scraper](https://apify.com/alexmorain/yelp-reviews-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).

### Guide and use cases

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

# Actor input Schema

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

What you would type in Yelp's search box: pizza, dentist, plumber, hair salon…

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

Where to search: a city, a neighbourhood, an address or a zip code. Each search term is run in each location.

## `maxBusinessesPerSearch` (type: `integer`):

Yelp shows at most 240 businesses per search (0 = all 240). For more, split the location (neighbourhoods, zip codes). Each business is one charged result.

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

Yelp search result pages (<code>https://www.yelp.com/search?find_desc=…\&find_loc=…</code>, filters kept) or business pages. 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.

## `includeAds` (type: `boolean`):

Keep the sponsored businesses Yelp mixes into the results.

## `includeReviews` (type: `boolean`):

Adds the reviews of each business after its row (each review is one charged result).

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

With reviews on. <b>0 = every review</b>, in every language.

## `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 which businesses and reviews it already delivered and returns only new ones on the next run, without charging the rest again.

## `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.

## `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
{
  "searchTerms": [
    "pizza"
  ],
  "locations": [
    "San Francisco, CA"
  ],
  "maxBusinessesPerSearch": 10,
  "includeAds": false,
  "includeReviews": false,
  "maxReviewsPerBusiness": 20,
  "sortBy": "newest",
  "includeReviewerDetails": false,
  "newOnly": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

One row per business

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

One row per review

## `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 = {
    "searchTerms": [
        "pizza"
    ],
    "locations": [
        "San Francisco, CA"
    ],
    "maxBusinessesPerSearch": 10,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("alexmorain/yelp-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "searchTerms": ["pizza"],
    "locations": ["San Francisco, CA"],
    "maxBusinessesPerSearch": 10,
    "proxyConfiguration": { "useApifyProxy": True },
}

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

```

## MCP server setup

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