# Yelp Scraper \[Only $1.5💰] | Reviews | Business Data | Ratings (`ahmed_jasarevic/yelp-scraper`) Actor

Scrape Yelp business profiles and full reviews with ratings, dates, author details and reaction counts. Build lead lists, monitor reputation and run competitor analysis at scale, with no official API limits.

- **URL**: https://apify.com/ahmed_jasarevic/yelp-scraper.md
- **Developed by:** [Ahmed Jasarevic](https://apify.com/ahmed_jasarevic) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.30 / 1,000 results

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: Business Profiles And Full Review Data

Scrape Yelp business profiles and complete review feeds with no browser and no proxy. Get business name, rating, review count, categories, price range, city, today's hours and full review text with author details, dates and reaction counts. The official Yelp Fusion API caps reviews at three excerpts of about 160 characters; this actor returns the full review feed instead.

### Main Use Cases

- Local SEO and listing audits for agencies managing many client businesses
- Reputation monitoring and rating tracking across multiple locations
- Competitor analysis: benchmark ratings, review counts and categories in a market
- Market research on rating distributions, category trends and price ranges
- Building structured local business datasets for dashboards and analysis
- Collecting full review text as input for sentiment analysis and NLP projects

### How Yelp Scraper Works

This actor runs entirely over HTTP, with no browser and no proxy by default. It impersonates a real Chrome TLS/JA3 fingerprint to read Yelp's European storefronts, then pulls business profile and review data from Yelp's own internal GraphQL endpoint as clean structured JSON. That makes runs fast and cheap: roughly 0.05 to 0.1 compute units per 100 businesses with reviews.

### Build Yelp Business And Review Datasets Without An Official API

Yelp's public API does not return full review text, and its reviews endpoint returns only up to three excerpts of about 160 characters each. This actor reads Yelp the same way the website does, but without a browser:

1. Regional storefronts, not yelp.com. `impit`, a Rust-based HTTP client, fetches Yelp's European domains (yelp.de, yelp.fr, yelp.ie, yelp.dk, yelp.se, yelp.co.uk) with a real Chrome fingerprint. Those storefronts serve the same global business data to datacenter IPs that yelp.com itself gates with DataDome.
2. Discovery. Search URLs are read from the `/search` page's embedded `react-root-props` blob (business id and alias per result). Business URLs and aliases are resolved to their encoded id through the `<meta name="yelp-biz-id">` tag on the `/biz/<alias>` page. Encoded business ids are used directly.
3. Profiles and reviews come from `POST https://www.yelp.com/gql/batch` using Yelp's persisted-query ids for `GetBizHeaderData` (name, rating, review count, categories, price, city, today's hours) and `GetBusinessReviewFeed` (paginated with a base64 offset cursor). There is no character limit and no three-review cap.
4. If Yelp rotates a persisted-query id, set `YELP_REVIEW_DOCUMENT_ID` or `YELP_PROFILE_DOCUMENT_ID` to the new value (grab it from DevTools: Network, filter `batch`, then `<operationName>`, then `extensions.documentId`).

Three input modes are supported:

1. Direct business URLs: `https://www.yelp.com/biz/...`
2. Search result pages: `https://www.yelp.com/search?find_desc=...&find_loc=...`, which auto-discover every business on the page
3. Encoded business ids: the fastest path, skips the page request and goes straight to GraphQL

### Extract Yelp Business Profiles For Market Research

Each business becomes one record with name, star rating (1.0 to 5.0), total review count, categories, price range, city/region, today's hours, Yelp id, encoded business id, image and scrape timestamp. Because there is no browser and no proxy, a run of a few hundred businesses finishes in seconds to a couple of minutes depending on `maxConcurrency` and how many reviews are requested.

Fields and their source:

| Field | Source | Notes |
|---|---|---|
| name | GraphQL `GetBizHeaderData` | Official business name |
| rating | GraphQL `GetBizHeaderData` | Star rating (1.0 - 5.0) |
| reviewCount | GraphQL `GetBizHeaderData` | Total number of reviews |
| categories | GraphQL `GetBizHeaderData` | Business categories |
| priceRange | GraphQL `GetBizHeaderData` | Price level ($ to $$$$) |
| address | GraphQL `GetBizHeaderData` | City and state/region |
| hours | GraphQL `GetBizHeaderData` | Current day's opening hours |
| url, yelpId, encBizId, imageUrl | Page / GraphQL | Identifiers and image |
| reviews | GraphQL `GetBusinessReviewFeed` | Full review feed, paginated, no truncation |

### Input Parameters

| Field | Type | Required | Default | Notes |
|---|---|---|---|---|
| `startUrls` | array | Yes | prefill: a coffee search in San Francisco | Business URLs, search result URLs, bare aliases or 22-char encoded business ids. Encoded ids skip the page fetch entirely and are the fastest input |
| `maxBusinesses` | integer | No | 50 | Maximum business listings to scrape (1 to 1000) |
| `maxReviewsPerBusiness` | integer | No | 10 | Maximum full reviews per business (0 to 500). Set 0 to skip reviews |
| `includeReviews` | boolean | No | true | Fetch full review text, rating, date, author info and reaction counts |
| `sortBy` | string | No | `DATE_DESC` | Review order: `DATE_DESC`, `RELEVANCE_DESC` or `ELITES_DESC` |
| `maxConcurrency` | integer | No | 5 | Businesses processed in parallel (1 to 20). Higher is faster |
| `proxyConfiguration` | object | No | `{ "useApifyProxy": false }` | Optional. Data comes from Yelp's unblocked storefronts and GraphQL, so no proxy is needed. Enable a proxy only if you hit rate limits |

### Output Fields

The actor pushes two record types. Businesses go to the default dataset, reviews go to a separate `reviews` dataset.

Business record fields: `_type` (`business`), `url`, `name`, `rating`, `reviewCount`, `categories` (array), `priceRange`, `address`, `phone`, `website`, `hours` (object), `latitude`, `longitude`, `yelpId`, `encBizId`, `imageUrl`, `scrapedAt`.

Review record fields: `_type` (`review`), `businessUrl`, `businessName`, `reviewId`, `rating`, `text` (full review text), `date`, `authorName`, `authorUrl`, `authorPhotoUrl`, `usefulCount`, `funnyCount`, `coolCount`.

Note on missing fields: the internal GraphQL profile endpoint exposes name, rating, review count, categories, price range, city/region and hours. It does not expose phone, full street address, website or exact GPS coordinates, so `phone`, `website`, `latitude` and `longitude` are usually `null` unless the data is present on the fetched business page.

### Example Input And Output

Example input:

```json
{
    "startUrls": [
        { "url": "https://www.yelp.com/search?find_desc=coffee&find_loc=San+Francisco%2C+CA" }
    ],
    "maxBusinesses": 20,
    "maxReviewsPerBusiness": 20,
    "includeReviews": true,
    "sortBy": "DATE_DESC",
    "maxConcurrency": 5
}
```

Example business record (default dataset):

```json
{
    "_type": "business",
    "url": "https://www.yelp.com/biz/the-coffee-place-san-francisco",
    "name": "The Coffee Place",
    "rating": 4.5,
    "reviewCount": 234,
    "categories": ["Coffee & Tea", "Breakfast & Brunch"],
    "priceRange": "$$",
    "address": "San Francisco, CA",
    "phone": null,
    "website": null,
    "hours": { "today": "7:00 AM - 6:00 PM" },
    "latitude": null,
    "longitude": null,
    "yelpId": "the-coffee-place-san-francisco",
    "encBizId": "T20VEwi7AzKbY2TuVEt_ig",
    "imageUrl": "https://s3-media0.fl.yelpcdn.com/photo/example/o.jpg",
    "scrapedAt": "2026-08-27T10:00:00.000Z"
}
```

Example review record (`reviews` dataset):

```json
{
    "_type": "review",
    "businessUrl": "https://www.yelp.com/biz/the-coffee-place-san-francisco",
    "businessName": "The Coffee Place",
    "reviewId": "pJ5tnzX01EC2n6wH7ru0Bw",
    "rating": 5,
    "text": "Amazing coffee and the baristas are incredibly friendly. The breakfast burrito is worth the trip alone.",
    "date": "2026-08-15T10:00:00-07:00",
    "authorName": "John D.",
    "authorUrl": "https://www.yelp.com/user_details?userid=x5HkOYmLXJDjHDx6G8sajw",
    "authorPhotoUrl": "https://s3-media0.fl.yelpcdn.com/photo/example/180s.jpg",
    "usefulCount": 12,
    "funnyCount": 2,
    "coolCount": 5
}
```

You can download both datasets as JSON, CSV, Excel or HTML.

### Integrations & Automation

Results are available through the Apify API and can be connected to:

- Apify API: run the actor and read the default (businesses) and `reviews` datasets programmatically
- Webhooks: trigger downstream systems when a run finishes
- Zapier and Make: push new business and review rows into Sheets, Airtable, a CRM or a dashboard

For reputation and rating monitoring, schedule a recurring run (for example daily or weekly) with the same `startUrls` so you capture new reviews and rating changes over time. Recurring runs are the intended pattern for monitoring use cases. Set `includeReviews` to `false` or `maxReviewsPerBusiness` to `0` for cheaper, business-only refreshes.

### Related Actors

Verified related actors on the Apify Store that pair well with this one:

- [Yelp Reviews Scraper](https://apify.com/web_wanderer/yelp-reviews-scraper)
- [Yelp Review Scraper](https://apify.com/tri_angle/yelp-review-scraper)
- [Yelp Reviews Scraper](https://apify.com/delicious_zebu/yelp-reviews-scraper)
- [Google Maps Scraper](https://apify.com/compass/crawler-google-places)
- [Google Maps Reviews Scraper](https://apify.com/compass/Google-Maps-Reviews-Scraper)

### FAQ

#### Is there an official Yelp API?

Yes. The Yelp Fusion / Places API has a reviews endpoint, but it returns only up to three review excerpts of about 160 characters each, and the Yelp documentation states the Places API does not return full review text. Full review access requires paid plans, from about $229 per month up to about $643 per month, plus per-1,000-call overages. This actor returns the full review feed with no three-review cap.

#### How many reviews can I get for a business?

There is no three-review cap. Set `maxReviewsPerBusiness` to any value up to 500 and the actor paginates Yelp's review feed until it reaches that number. Set `maxReviewsPerBusiness` to 0 to skip reviews entirely.

#### What are the alternatives to Yelp Scraper or the Yelp API?

Alternatives include the official Yelp Fusion / Places API, Yelp Insights data licensing, the academic Yelp Open Dataset (historical, not live), SerpApi's Yelp Reviews API, and other Yelp actors on the Apify Store. This actor focuses on live business profiles plus full review text with no browser and no proxy.

#### Do I need a proxy or a browser to scrape Yelp?

No by default. The actor reads Yelp's European storefronts from a datacenter IP using a Chrome TLS/JA3 fingerprint, so there is no browser and no proxy requirement. You can enable a proxy through `proxyConfiguration` if you hit rate limits.

#### Can I scrape Yelp search results instead of individual businesses?

Yes. Pass a search URL such as `https://www.yelp.com/search?find_desc=pizza&find_loc=New+York` and the actor discovers every business on the page, up to `maxBusinesses`.

#### What Yelp data is not available?

Phone, full street address, website and exact GPS coordinates are not exposed by the internal endpoints this actor uses, so those fields are usually null. Profiles include name, rating, review count, categories, price range, city/region and hours; reviews include full text, rating, date, author details and reaction counts.

#### Is there a free tier?

Non-paying Apify users are capped at 5 businesses per run. Paid users are not capped by that limit and are billed per event (see the pricing).

### SEO Keywords

yelp scraper, yelp reviews scraper, scrape yelp reviews, yelp business scraper, yelp scraper api, yelp api alternative, yelp fusion api alternative, yelp places api, yelp reviews api, yelp reviews without api, yelp dataset, yelp reputation monitoring, yelp rating monitoring, yelp competitor analysis, yelp review sentiment analysis, yelp lead generation, yelp data extraction, extract yelp reviews, yelp business data, yelp business profiles, yelp search scraper, yelp full review text api, local business data, local seo yelp data

### For AI Agents & LLM Apps

Purpose: return Yelp business profiles (default dataset) and full reviews (separate `reviews` dataset) as structured JSON, given Yelp URLs, search URLs, aliases or 22-char encoded business ids.

Minimal working input:

```json
{ "startUrls": ["https://www.yelp.com/biz/the-coffee-place-san-francisco"] }
```

Variant inputs (distinct modes):

```json
{ "startUrls": ["T20VEwi7AzKbY2TuVEt_ig"], "includeReviews": false }
```

```json
{ "startUrls": ["https://www.yelp.com/search?find_desc=pizza&find_loc=New+York"], "maxBusinesses": 30, "maxReviewsPerBusiness": 50 }
```

Output fields:

- Businesses (default dataset): \_type, url, name, rating, reviewCount, categories, priceRange, address, phone, website, hours, latitude, longitude, yelpId, encBizId, imageUrl, scrapedAt
- Reviews (`reviews` dataset): \_type, businessUrl, businessName, reviewId, rating, text, date, authorName, authorUrl, authorPhotoUrl, usefulCount, funnyCount, coolCount

Behaviors an agent should know:

- `startUrls` is the only required field. Any entry containing `/search` or `find_desc=` is treated as a search and expanded into businesses.
- Non-paying runs are capped at 5 businesses (`FREE_LIMIT`); paid runs are not capped by that limit.
- Setting `includeReviews` to `false` or `maxReviewsPerBusiness` to `0` skips the billed review feed.
- `proxyConfiguration` defaults to `{ "useApifyProxy": false }`; the actor works without a proxy. Only enable it if you hit rate limits.
- `maxConcurrency` is clamped to 1 to 20.
- Reviews are pushed to a separate `reviews` dataset, not the default dataset.
- A 22-char encoded business id skips the page fetch and is the fastest input mode.

Billing: pay per event. Actor Start $0.00005 per event, each result (dataset item) $0.0015 on the FREE tier (down to $0.0013 at higher tiers), each review $0.0004 on the FREE tier (down to $0.0003 at higher tiers).

### Legal & Compliance Disclaimer

This actor is an independent tool and is not affiliated with, endorsed by or sponsored by Yelp. It reads publicly available Yelp business pages and Yelp's internal GraphQL endpoints through Yelp's public regional storefronts. It does not log in, does not use an account or API key and does not solve CAPTCHAs.

Users are responsible for their own compliance with Yelp's Terms of Service and with applicable data-protection law. The default dataset may contain reviewer display names and public profile links (personal data), so if you process it you should consider your obligations under laws such as the GDPR and the CCPA. Do not use reviewer personal data for unsolicited commercial outreach in violation of applicable law.

# Actor input Schema

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

Yelp business URLs (https://www.yelp.com/biz/...), search result URLs (https://www.yelp.com/search?find_desc=...\&find_loc=...), bare aliases, or 22-char encoded business IDs. Encoded IDs skip the page fetch entirely and are the fastest input.

## `maxBusinesses` (type: `integer`):

Maximum number of business listings to scrape

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

Maximum number of full reviews to fetch per business via Yelp's internal GraphQL feed. Set 0 to skip reviews.

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

Fetch full review text, rating, date, author info and reaction counts

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

Order in which reviews are returned

## `maxConcurrency` (type: `integer`):

Number of businesses processed in parallel. Higher is faster but stresses the proxy more.

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

Optional. The Actor reads data from Yelp's European storefronts and its internal GraphQL API, which are reachable from datacenter IPs without a proxy. Enable a proxy only if you hit rate limits.

## Actor input object example

```json
{
  "startUrls": [
    "https://www.yelp.com/search?find_desc=coffee&find_loc=San+Francisco%2C+CA"
  ],
  "maxBusinesses": 50,
  "maxReviewsPerBusiness": 10,
  "includeReviews": true,
  "sortBy": "DATE_DESC",
  "maxConcurrency": 5,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

No description

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

No description

# 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/search?find_desc=coffee&find_loc=San+Francisco%2C+CA"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("ahmed_jasarevic/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 = { "startUrls": ["https://www.yelp.com/search?find_desc=coffee&find_loc=San+Francisco%2C+CA"] }

# Run the Actor and wait for it to finish
run = client.actor("ahmed_jasarevic/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 '{
  "startUrls": [
    "https://www.yelp.com/search?find_desc=coffee&find_loc=San+Francisco%2C+CA"
  ]
}' |
apify call ahmed_jasarevic/yelp-scraper --silent --output-dataset

```

## MCP server setup

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