Yelp Reviews Scraper: All Languages, Owner Replies

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

Why this actor

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

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

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

Use with AI agents

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

Input example (minimal):

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

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

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

What you get

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

Output example:

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

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

Input

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

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

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

Coverage and edited reviews

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

How it compares with the other popular Yelp reviews actor

Based on the other actor's published input options.

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

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

Migrating from the other popular Yelp reviews actor

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

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

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

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

Use it from an AI assistant

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

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

Use it from code

Python:

from apify_client import ApifyClient

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

JavaScript:

import { ApifyClient } from 'apify-client';

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

Pricing

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

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

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

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

Related actors

• Tripadvisor Reviews Scraper: Ratings, Replies, Translations
• Review Monitor: Negative Review Alerts and Rating Drift

Use cases

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

Limitations

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

Privacy

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

FAQ

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

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

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

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

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