⭐ Yelp Reviews Scraper by Business ID

Yelp Reviews Scraper by Business ID lets you collect structured Yelp reviews for one or more businesses using their 22-character Yelp business IDs.

Monitor new customer feedback, analyze competitors, track reputation changes, collect review history, and automate review-based workflows without manually opening Yelp business pages.

• ⭐ Collect Yelp reviews: extract ratings, full review text, dates, reviewer information, reactions, and owner responses
• 📈 Monitor reputation: collect only reviews published since your previous run
• 🏪 Track multiple businesses: process multiple Yelp business IDs independently in one Actor run
• 🔁 Run incremental monitoring: stop automatically when a previously collected review is encountered
• 📅 Collect reviews after a date: avoid repeatedly downloading old review history
• 🧹 Avoid duplicates: reviews are deduplicated using Yelp review IDs
• 🛡 Protect business identity: mismatched business IDs are rejected instead of attaching reviews to the wrong business
• ⚡ Automate workflows: export structured results to Apify Dataset, API, integrations, AI workflows, or downstream applications

---

📦 What data does Yelp Reviews Scraper extract?

Each Dataset row represents one Yelp review together with useful business context.

🆔 Yelp business ID	🏪 Business name
🔗 Business alias	⭐ Business rating
💬 Business review count	🖼 Business photo
📊 Review counts by rating	🌐 Review counts by language
🆔 Review ID	⭐ Review rating
📝 Full review text	🕒 Review date — UTC
🕐 Review date — local	👍 Useful count
😂 Funny count	😎 Cool count
👤 Reviewer ID	🙍 Reviewer name
📊 Reviewer review count	📷 Reviewer business photo count
🖼 Reviewer profile photo	❤️ Review reactions
💬 Business owner response

Missing fields are returned as null where applicable. The Actor does not invent review or business information that is not returned by Yelp.

---

🚀 Features

Yelp Reviews Scraper by Business ID is designed for review monitoring, reputation intelligence, competitor analysis, and automation.

• Multiple Yelp business IDs: process multiple businesses in one Actor run
• 22-character ID validation: malformed IDs are rejected before collection
• Business identity verification: returned review data is checked against the requested Yelp business ID
• Newest reviews first: reviews are collected in reverse chronological order
• Automatic cursor pagination: continue through review history without manually handling pages
• Exact review limits: stop at the requested maximum for each business
• Incremental review collection: use a previously collected review ID as a stopping point
• Date-based collection: stop when reviews become older than your selected date
• Review deduplication: duplicate review IDs are not emitted twice
• Per-business failure protection: one problematic business does not discard successful results from other businesses
• Structured Dataset output: every review follows a predictable schema
• Business context included: each review contains the relevant business name, rating, review count, alias, and business ID
• Dedicated Dataset views: inspect review data or business context directly in Apify Console
• HTTP-first architecture: normal review collection does not require browser automation

---

⬇️ Input

You can configure Yelp Reviews Scraper directly from the Apify Console or send the input programmatically through the Apify API.

---

🆔 Yelp business IDs

Enter one or more 22-character Yelp business IDs.

Example:

WavvLdfdP6g8aZTtbBQHTw

Multiple businesses can be entered:

WavvLdfdP6g8aZTtbBQHTw
ANOTHER_YELP_ID_HERE
ANOTHER_YELP_ID_HERE

Each business is processed independently.

Duplicate business IDs are automatically removed before processing.

Business ID format

A Yelp business ID used by this Actor is expected to contain exactly:

22 characters

using letters, numbers, underscores, or hyphens.

For example:

WavvLdfdP6g8aZTtbBQHTw

This Actor currently accepts business IDs only. Yelp business URLs, aliases, keywords, and locations are not accepted as substitutes.

---

🔢 Maximum reviews per business

Set the maximum number of reviews to collect for each Yelp business ID.

Minimum: 1
Default: 100

For example:

Business IDs:
Business A
Business B
Business C

Maximum reviews per business:
100

can return up to:

100 reviews for Business A
+
100 reviews for Business B
+
100 reviews for Business C
=
300 Dataset rows

The requested number is a maximum, not a guarantee.

The Actor may return fewer reviews when:

• the business has fewer available reviews
• reviewsAfterDate is reached
• stopAtReviewId is reached
• pagination naturally ends
• the business cannot be safely validated
• a request for that business fails

---

📅 Only reviews after this date

Use:

reviewsAfterDate

to collect only reviews newer than a selected date.

Example:

2026-07-01

The Actor processes reviews from newest to oldest.

When it reaches a review at or before the selected cutoff date:

review date <= reviewsAfterDate

collection for that business stops.

The review that reaches the cutoff is not included.

Example

Suppose Yelp returns:

2026-07-20
2026-07-15
2026-07-04
2026-06-25
2026-06-10

and your input is:

reviewsAfterDate:
2026-07-01

the Actor keeps:

2026-07-20
2026-07-15
2026-07-04

and stops when it reaches:

2026-06-25

This can significantly reduce unnecessary requests when you only need recent review activity.

---

🔁 Stop at previously collected review ID

Use:

stopAtReviewId

when you already collected reviews in a previous run.

Enter the Yelp review ID of the review where collection should stop.

Example:

BVCWqzKpzRnioLYI455kPw

When the Actor encounters this review:

stopAtReviewId

it immediately stops processing older reviews for that business.

The matching review itself is not included again.

Incremental monitoring example

Your previous run returned:

Newest review:
NEW_REVIEW_A

Second review:
NEW_REVIEW_B

Third review:
PREVIOUS_REVIEW_ID

For the next run, set:

stopAtReviewId:
PREVIOUS_REVIEW_ID

The Actor returns:

NEW_REVIEW_A
NEW_REVIEW_B

and stops before emitting:

PREVIOUS_REVIEW_ID

This makes stopAtReviewId useful for:

• daily review monitoring
• scheduled reputation tracking
• multi-location review feeds
• CRM synchronization
• notification systems
• incremental data pipelines

---

🧪 Example input

{
  "businessIds": [
    "WavvLdfdP6g8aZTtbBQHTw"
  ],
  "maxReviewsPerBusiness": 100,
  "reviewsAfterDate": "",
  "stopAtReviewId": ""
}

Incremental example

{
  "businessIds": [
    "WavvLdfdP6g8aZTtbBQHTw"
  ],
  "maxReviewsPerBusiness": 100,
  "reviewsAfterDate": "",
  "stopAtReviewId": "BVCWqzKpzRnioLYI455kPw"
}

Date-based example

{
  "businessIds": [
    "WavvLdfdP6g8aZTtbBQHTw"
  ],
  "maxReviewsPerBusiness": 500,
  "reviewsAfterDate": "2026-07-01",
  "stopAtReviewId": ""
}

---

⬆️ Output

Results are stored in the Actor's default Apify Dataset.

You can access them from:

Output
Storage
Apify API
Integrations

Each Dataset row represents:

One Yelp review for one confirmed Yelp business ID.

Business context is included directly with every review so exported CSV, JSON, Excel, and API results remain easy to use.

---

📊 Example result

{
  "businessId": "WavvLdfdP6g8aZTtbBQHTw",
  "businessAlias": "gary-danko-san-francisco",
  "businessName": "Gary Danko",
  "businessRating": 4.5,
  "businessReviewCount": 6138,
  "businessPrimaryPhotoUrl": "https://...",
  "businessReviewCountsByRating": [],
  "businessReviewCountsByLanguage": [],
  "reviewId": "60ntr31UWUsUDjrIlozZEQ",
  "reviewRating": 5,
  "reviewText": "Full Yelp review text...",
  "reviewDateUtc": "2026-09-03T05:39:14Z",
  "reviewDateLocal": "2026-09-02T22:39:14",
  "usefulCount": 0,
  "funnyCount": 0,
  "coolCount": 0,
  "reviewerId": "REVIEWER_ID",
  "reviewerName": "roger t.",
  "reviewerReviewCount": 123,
  "reviewerBusinessPhotoCount": 4,
  "reviewerProfilePhotoUrl": "https://...",
  "reactions": [
    {
      "type": "HELPFUL",
      "count": 0
    },
    {
      "type": "THANKS",
      "count": 0
    },
    {
      "type": "LOVE_THIS",
      "count": 0
    },
    {
      "type": "OH_NO",
      "count": 0
    }
  ],
  "ownerResponse": null
}

---

⭐ Review fields

The main review fields are:

reviewId
reviewRating
reviewText
reviewDateUtc
reviewDateLocal

reviewId is also used internally to prevent duplicate review rows during pagination.

---

👤 Reviewer fields

When available, reviewer information includes:

reviewerId
reviewerName
reviewerReviewCount
reviewerBusinessPhotoCount
reviewerProfilePhotoUrl

Not every reviewer exposes every field.

Missing information may therefore appear as:

null

---

❤️ Yelp reactions

Reviews may contain Yelp reaction data.

The Actor returns reactions as structured objects:

[
  {
    "type": "HELPFUL",
    "count": 2
  },
  {
    "type": "THANKS",
    "count": 1
  }
]

Reaction types observed by the Actor include:

HELPFUL
THANKS
LOVE_THIS
OH_NO

Reaction availability and counts vary by review.

---

💬 Business owner responses

When Yelp provides a public business-owner response, it is returned in:

ownerResponse

If a review has no owner response:

"ownerResponse": null

This makes the output useful for workflows such as:

• identifying unanswered negative reviews
• response-rate analysis
• reputation-management dashboards
• customer-service audits

---

🏪 Business context

Each review also contains business-level fields:

businessId
businessAlias
businessName
businessRating
businessReviewCount
businessPrimaryPhotoUrl
businessReviewCountsByRating
businessReviewCountsByLanguage

The Apify Output page includes a separate:

Business context

view to make these fields easier to inspect.

---

🛡 Business ID validation

Business identity is treated as a critical part of the scraper.

The Actor does not blindly trust the requested ID.

When review records are returned, the Actor verifies that their embedded Yelp business identity matches the business ID supplied by the user.

If Yelp returns review data for a different business, the Actor rejects that business instead of incorrectly labeling the reviews.

Example:

Requested ID:
BUSINESS_ID_A

Review records belong to:
BUSINESS_ID_B

Result:

Business failed
0 incorrect review rows stored

Other valid business IDs in the same run continue processing.

This protects Dataset quality when:

• an ID was mistyped
• an ID is invalid
• Yelp returns inconsistent data
• a business identifier cannot be safely confirmed

---

🧹 Review deduplication

Reviews are deduplicated by:

reviewId

within each business collection.

If the same review appears again during pagination, it is not added to the Dataset twice.

This prevents repeated review records from inflating your results.

---

📄 Pagination

Yelp Reviews Scraper automatically follows Yelp's review pagination cursors.

The Actor processes:

Page 1
↓
Page 2
↓
Page 3
↓
...

until a stopping condition is reached.

Collection stops when:

• 🎯 Maximum reviews per business reached
• 🔁 stopAtReviewId encountered
• 📅 reviewsAfterDate reached
• 📭 No reviews returned
• 🏁 Yelp reports no next page
• ⚠️ No next cursor is available
• 🔄 A previously seen cursor repeats

The scraper does not continue sending unnecessary requests once a stopping condition is reached.

---

⚡ Performance

The scraper uses an HTTP-first architecture.

Instead of launching a full browser for normal review collection, it requests Yelp review data directly through the web transport used for the review feed.

This generally provides:

Lower memory use
Faster startup
Lower compute requirements
Less browser overhead
Efficient pagination

A consistent network session is maintained while processing each individual business.

---

🛡 Reliability

Each business ID is processed independently.

For example, if your input contains:

Business A
Business B
Business C

and Business B cannot be safely processed:

Business A → results preserved
Business B → failure logged
Business C → processing continues

A single failed business therefore does not automatically discard successful review data from the rest of the run.

The Actor also protects against:

• duplicate reviews
• repeated pagination cursors
• invalid input formats
• mismatched business identities
• non-JSON responses
• unsuccessful HTTP responses
• detected blocked requests
• malformed GraphQL responses

---

🔌 API & integrations

Yelp Reviews Scraper by Business ID can be used programmatically through the Apify API.

You can connect the resulting review data to workflows such as:

• Google Sheets
• Make
• Zapier
• CRMs
• Slack notifications
• reputation-management dashboards
• internal APIs
• data warehouses
• sentiment-analysis pipelines
• AI agents
• MCP workflows

Each Actor run stores structured review results in the default Dataset, making them straightforward to consume from another application.

---

💡 Example use cases

📈 Reputation monitoring

Run the Actor regularly for your own business locations.

Save the newest review ID from the previous run and use it as:

stopAtReviewId

during the next run.

The Dataset then contains only reviews that appeared since your previous collection.

Use this for:

Daily review monitoring
New-review alerts
Customer service workflows
Reputation dashboards

---

🏪 Multi-location review monitoring

Provide multiple Yelp business IDs:

Location A ID
Location B ID
Location C ID
Location D ID

The Actor processes each location independently.

You can then compare:

Ratings
Review volume
Recent customer feedback
Reaction activity
Owner responses

across locations.

---

📊 Competitor review research

Provide known Yelp business IDs for your competitors and collect their newest reviews.

Analyze:

Common complaints
Customer praise
Service quality patterns
Rating trends
Reviewer sentiment
Owner-response activity
Recurring operational problems

---

🤖 Sentiment and NLP analysis

Export reviewText into:

Sentiment models
Topic clustering
LLM pipelines
Complaint categorization
Feature extraction
Customer-experience analytics

Because each review has a stable:

reviewId

incremental analysis pipelines can avoid processing the same review repeatedly.

---

💬 Owner-response auditing

Use:

reviewRating
ownerResponse
reviewDateUtc

to identify reviews that may require attention.

For example:

1-star review
+
ownerResponse = null

can be routed into a reputation-management workflow.

---

⚠️ Current limitations

The current version focuses specifically on reliable review collection from known Yelp business IDs.

It does not currently perform:

Keyword + location Yelp search
Business discovery
Yelp URL input
Yelp alias input
Automatic URL-to-ID resolution
Full Yelp business profile extraction
Street address extraction
Phone extraction
Business website extraction
Latitude / longitude extraction
Opening-hours extraction
Category extraction
Photo gallery extraction
Search-result ranking
Grid or geographic crawling
Browser-based Yelp discovery
CAPTCHA solving
Anti-bot challenge bypass

These features are intentionally outside the current product scope.

If you need business discovery, you must first obtain the Yelp business IDs from another source or workflow.

---

❓ FAQ

What is a Yelp business ID?

A Yelp business ID is the business identifier used by this Actor to request reviews for a specific Yelp business.

The current Actor expects a:

22-character business ID

Example:

WavvLdfdP6g8aZTtbBQHTw

---

Can I enter a Yelp business URL?

Not in the current version.

The Actor currently accepts:

businessIds[]

only.

It does not currently convert:

https://www.yelp.com/biz/...

into a Yelp business ID.

---

Can I search Yelp by keyword and location?

No.

This Actor is intentionally an ID-first review scraper.

Inputs such as:

plumber
Los Angeles, California

are not supported.

The Actor is designed for users who already know which Yelp businesses they want to monitor.

---

Can I scrape multiple businesses in one run?

Yes.

Add multiple values to:

businessIds

Each business is processed independently.

---

How many reviews can I collect?

Use:

maxReviewsPerBusiness

to control the maximum for each business.

The default is:

100 reviews per business

You can request more when needed.

Actual output may be lower if:

The business has fewer reviews
reviewsAfterDate is reached
stopAtReviewId is reached
Pagination ends
The business fails validation

---

Are reviews returned newest first?

Yes.

The collection workflow processes Yelp reviews from newest to oldest.

This is what makes:

reviewsAfterDate

and:

stopAtReviewId

efficient for incremental monitoring.

---

How does incremental review monitoring work?

After a successful run, save the newest review ID you have already processed.

On the next run, supply that ID as:

stopAtReviewId

The Actor collects newer reviews and stops once it encounters the previously processed review.

The stop-marker review itself is not returned again.

---

Which is better: reviewsAfterDate or stopAtReviewId?

Use:

reviewsAfterDate

when you want all reviews newer than a calendar date.

Use:

stopAtReviewId

when you want to continue precisely from a previous collection.

For recurring monitoring workflows, stopAtReviewId is usually the more exact stopping marker.

---

Why did a business fail with "Business ID mismatch"?

The Actor validates the identity attached to returned review records.

If you request:

BUSINESS_ID_A

but Yelp returns reviews that belong to:

BUSINESS_ID_B

the Actor refuses to store those reviews under the wrong business ID.

This behavior protects Dataset accuracy.

---

Why is ownerResponse null?

Not every Yelp review has a public response from the business.

When no public owner response is available:

"ownerResponse": null

is expected.

---

Why are some reviewer fields null?

Yelp does not provide every reviewer field for every review.

The Actor deliberately returns:

null

when information is unavailable rather than inventing values.

---

Can I use this Actor through an API?

Yes.

Every Actor can be started through the Apify API, and the resulting Dataset can be retrieved programmatically.

This makes the scraper suitable for:

Scheduled monitoring
Review ingestion pipelines
CRM synchronization
AI analysis
Dashboards
Notifications
Internal applications

---

Can I export the results?

Yes.

Apify Dataset results can be exported in supported formats such as:

JSON
CSV
Excel
XML
HTML

---

Is a browser required?

Not for the normal review workflow.

The Actor uses an HTTP-first transport for standard review collection.

This reduces the compute and memory overhead associated with full browser automation.

---

Does the Actor scrape full Yelp business profiles?

No.

The current product only exposes business fields that are available and confirmed through the review collection response.

It does not currently advertise complete Yelp profile extraction.

---

🧭 Recommended workflow

For recurring review monitoring:

First run

businessIds:
your Yelp business IDs

maxReviewsPerBusiness:
100

Collect the current reviews.

Save the newest:

reviewId

that your system has processed.

Future runs

Use that saved value as:

stopAtReviewId

The Actor can then stop as soon as it reaches review data your system already knows about.

For date-based workflows instead, use:

reviewsAfterDate

Example:

2026-09-01

This keeps scheduled runs smaller and avoids repeatedly collecting unnecessary historical reviews.

---

💬 Feedback & support

Found a bug or have a feature request?

Use the Actor's Issues tab on Apify.

Useful future additions may include:

Business URL input
Alias-to-ID resolution
More business summary fields
Improved monitoring workflows
Additional review filters
Business-level summary output
Webhook-oriented review alerts

---

⚖️ Responsible use

Use this Actor responsibly and ensure your collection and use of Yelp data complies with applicable laws, website terms, and your own contractual obligations.

This Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by Yelp.

---

🚀 Yelp review data ready for monitoring and automation

Enter your Yelp business IDs, choose how many reviews you need, run the Actor, and receive structured Yelp review data ready for reputation monitoring, competitor research, APIs, AI analysis, and automation.