Yelp Reviews Scraper

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.

$0.30 per 1,000 reviews on the Free plan, down to $0.23 on higher plans

Why this actor

• 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).

Drop-in input

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.

As stated in the actor’s README. The full list of accepted input names is on the Store page.

Switching from another actor

• From Yelp Reviews Scraper web_wanderer/yelp-reviews-scraper, 8 input fields work as they are

What you get

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.

Sample row (from the README example; long text shortened, lists cut to two items):

{
  "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"
  }
}

Price

Live Apify price on 2026-11-01, per 1,000 rows, by Apify plan. You pay only for rows delivered; error and summary rows marked free in the README cost nothing. Plus $0.001 per GB of memory when a run starts.

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.

Run it from code or an AI agent

Actor ID arcadium/yelp-reviews. Set APIFY_TOKEN to your Apify API token. The input below is the actor’s prefilled example; see the guide for every field.

curl -X POST "https://api.apify.com/v2/acts/arcadium~yelp-reviews/run-sync-get-dataset-items" \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"startUrls":[{"url":"https://www.yelp.com/biz/tartine-bakery-san-francisco-3"}],"maxReviewsPerBusiness":20,"sort":"DATE_DESC"}'

// npm install apify-client
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('arcadium/yelp-reviews').call({
  "startUrls": [
    {
      "url": "https://www.yelp.com/biz/tartine-bakery-san-francisco-3"
    }
  ],
  "maxReviewsPerBusiness": 20,
  "sort": "DATE_DESC"
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);

# pip install apify-client
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("arcadium/yelp-reviews").call(run_input={
    "startUrls": [{
        "url": "https://www.yelp.com/biz/tartine-bakery-san-francisco-3",
    }],
    "maxReviewsPerBusiness": 20,
    "sort": "DATE_DESC",
})
items = client.dataset(run.default_dataset_id).list_items().items  # apify-client 3.x returns a Run object
print(items)

{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com/?tools=arcadium/yelp-reviews",
      "headers": {
        "Authorization": "Bearer <APIFY_TOKEN>"
      }
    }
  }
}

# pip install langchain-apify   (reads APIFY_API_TOKEN from the environment)
from langchain_apify import ApifyActorsTool

tool = ApifyActorsTool("arcadium/yelp-reviews")
rows = tool.invoke({"run_input": {
    "startUrls": [{
        "url": "https://www.yelp.com/biz/tartine-bakery-san-francisco-3",
    }],
    "maxReviewsPerBusiness": 20,
    "sort": "DATE_DESC",
}})
# or give `tool` to an agent: create_react_agent(llm, [tool])

# pip install llama-index-readers-apify
import os
from llama_index.core import Document, VectorStoreIndex
from llama_index.readers.apify import ApifyActor

reader = ApifyActor(os.environ["APIFY_TOKEN"])
documents = reader.load_data(
    actor_id="arcadium/yelp-reviews",
    run_input={
        "startUrls": [{
            "url": "https://www.yelp.com/biz/tartine-bakery-san-francisco-3",
        }],
        "maxReviewsPerBusiness": 20,
        "sort": "DATE_DESC",
    },
    dataset_mapping_function=lambda item: Document(text=str(item.get("text") or ""), metadata={"url": item.get("url")}),
)
index = VectorStoreIndex.from_documents(documents)

# pip install crewai crewai-tools langchain-apify   (reads APIFY_API_TOKEN from the environment)
from crewai import Agent
from crewai_tools import ApifyActorsTool

tool = ApifyActorsTool(actor_name="arcadium/yelp-reviews")
researcher = Agent(
    role="Research analyst",
    goal="Answer with data collected by the tool",
    backstory="Uses public web data.",
    tools=[tool],
)

{
  "nodes": [
    {
      "name": "Run arcadium/yelp-reviews",
      "type": "n8n-nodes-base.httpRequest",
      "typeVersion": 4,
      "position": [
        0,
        0
      ],
      "parameters": {
        "method": "POST",
        "url": "https://api.apify.com/v2/acts/arcadium~yelp-reviews/run-sync-get-dataset-items",
        "authentication": "genericCredentialType",
        "genericAuthType": "httpHeaderAuth",
        "sendBody": true,
        "specifyBody": "json",
        "jsonBody": "{\"startUrls\":[{\"url\":\"https://www.yelp.com/biz/tartine-bakery-san-francisco-3\"}],\"maxReviewsPerBusiness\":20,\"sort\":\"DATE_DESC\"}",
        "options": {
          "timeout": 300000
        }
      }
    }
  ],
  "connections": {}
}

// Extensions > Apps Script. Store your token once: Project Settings > Script properties > APIFY_TOKEN.
function importLastRun() {
  const token = PropertiesService.getScriptProperties().getProperty('APIFY_TOKEN');
  const url = 'https://api.apify.com/v2/acts/arcadium~yelp-reviews/runs/last/dataset/items?status=SUCCEEDED&clean=true&format=json';
  const res = UrlFetchApp.fetch(url, { headers: { Authorization: 'Bearer ' + token } });
  const rows = JSON.parse(res.getContentText());
  if (!rows.length) return;
  const keys = Object.keys(rows[0]);
  const values = rows.map((r) => keys.map((k) => (typeof r[k] === 'object' ? JSON.stringify(r[k]) : r[k])));
  const sheet = SpreadsheetApp.getActiveSheet();
  sheet.clearContents();
  sheet.getRange(1, 1, 1, keys.length).setValues([keys]);
  sheet.getRange(2, 1, values.length, keys.length).setValues(values);
}

Tutorials

• Export Yelp reviews for a list of businesses

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.

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.

Related actors