# Yelp Reviews Scraper by Business ID (`aerodynamic_tripod/yelp-reviews-by-business-id`) Actor

Extract Yelp reviews by business ID with full review text, ratings, dates, reviewer data, reactions, owner responses, pagination, and incremental monitoring.

- **URL**: https://apify.com/aerodynamic\_tripod/yelp-reviews-by-business-id.md
- **Developed by:** [SearchShark Tools](https://apify.com/aerodynamic_tripod) (community)
- **Categories:**
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 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.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## ⭐ 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:

```text
WavvLdfdP6g8aZTtbBQHTw
```

Multiple businesses can be entered:

```text
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:

```text
22 characters
```

using letters, numbers, underscores, or hyphens.

For example:

```text
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**.

```text
Minimum: 1
Default: 100
```

For example:

```text
Business IDs:
Business A
Business B
Business C

Maximum reviews per business:
100
```

can return up to:

```text
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:

```text
reviewsAfterDate
```

to collect only reviews newer than a selected date.

Example:

```text
2026-07-01
```

The Actor processes reviews from **newest to oldest**.

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

```text
review date <= reviewsAfterDate
```

collection for that business stops.

The review that reaches the cutoff is **not included**.

#### Example

Suppose Yelp returns:

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

and your input is:

```text
reviewsAfterDate:
2026-07-01
```

the Actor keeps:

```text
2026-07-20
2026-07-15
2026-07-04
```

and stops when it reaches:

```text
2026-06-25
```

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

***

### 🔁 Stop at previously collected review ID

Use:

```text
stopAtReviewId
```

when you already collected reviews in a previous run.

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

Example:

```text
BVCWqzKpzRnioLYI455kPw
```

When the Actor encounters this review:

```text
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:

```text
Newest review:
NEW_REVIEW_A

Second review:
NEW_REVIEW_B

Third review:
PREVIOUS_REVIEW_ID
```

For the next run, set:

```text
stopAtReviewId:
PREVIOUS_REVIEW_ID
```

The Actor returns:

```text
NEW_REVIEW_A
NEW_REVIEW_B
```

and stops before emitting:

```text
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

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

#### Incremental example

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

#### Date-based example

```json
{
  "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:

```text
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

```json
{
  "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:

```text
reviewId
reviewRating
reviewText
reviewDateUtc
reviewDateLocal
```

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

***

### 👤 Reviewer fields

When available, reviewer information includes:

```text
reviewerId
reviewerName
reviewerReviewCount
reviewerBusinessPhotoCount
reviewerProfilePhotoUrl
```

Not every reviewer exposes every field.

Missing information may therefore appear as:

```text
null
```

***

### ❤️ Yelp reactions

Reviews may contain Yelp reaction data.

The Actor returns reactions as structured objects:

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

Reaction types observed by the Actor include:

```text
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:

```text
ownerResponse
```

If a review has no owner response:

```json
"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:

```text
businessId
businessAlias
businessName
businessRating
businessReviewCount
businessPrimaryPhotoUrl
businessReviewCountsByRating
businessReviewCountsByLanguage
```

The Apify Output page includes a separate:

```text
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:

```text
Requested ID:
BUSINESS_ID_A

Review records belong to:
BUSINESS_ID_B
```

Result:

```text
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:

```text
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:

```text
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:

```text
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:

```text
Business A
Business B
Business C
```

and Business B cannot be safely processed:

```text
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:

```text
stopAtReviewId
```

during the next run.

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

Use this for:

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

***

### 🏪 Multi-location review monitoring

Provide multiple Yelp business IDs:

```text
Location A ID
Location B ID
Location C ID
Location D ID
```

The Actor processes each location independently.

You can then compare:

```text
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:

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

***

### 🤖 Sentiment and NLP analysis

Export `reviewText` into:

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

Because each review has a stable:

```text
reviewId
```

incremental analysis pipelines can avoid processing the same review repeatedly.

***

### 💬 Owner-response auditing

Use:

```text
reviewRating
ownerResponse
reviewDateUtc
```

to identify reviews that may require attention.

For example:

```text
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**:

```text
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:

```text
22-character business ID
```

Example:

```text
WavvLdfdP6g8aZTtbBQHTw
```

***

### Can I enter a Yelp business URL?

**Not in the current version.**

The Actor currently accepts:

```text
businessIds[]
```

only.

It does not currently convert:

```text
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:

```text
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:

```text
businessIds
```

Each business is processed independently.

***

### How many reviews can I collect?

Use:

```text
maxReviewsPerBusiness
```

to control the maximum for each business.

The default is:

```text
100 reviews per business
```

You can request more when needed.

Actual output may be lower if:

```text
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:

```text
reviewsAfterDate
```

and:

```text
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:

```text
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:

```text
reviewsAfterDate
```

when you want all reviews newer than a calendar date.

Use:

```text
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:

```text
BUSINESS_ID_A
```

but Yelp returns reviews that belong to:

```text
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:

```json
"ownerResponse": null
```

is expected.

***

### Why are some reviewer fields null?

Yelp does not provide every reviewer field for every review.

The Actor deliberately returns:

```text
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:

```text
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:

```text
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

```text
businessIds:
your Yelp business IDs

maxReviewsPerBusiness:
100
```

Collect the current reviews.

Save the newest:

```text
reviewId
```

that your system has processed.

#### Future runs

Use that saved value as:

```text
stopAtReviewId
```

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

For date-based workflows instead, use:

```text
reviewsAfterDate
```

Example:

```text
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:

```text
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**.

# Actor input Schema

## `businessIds` (type: `array`):

Enter one or more 22-character Yelp business IDs. Each business is processed independently. Duplicate IDs are automatically ignored.

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

Maximum number of newest reviews to collect for each business. Yelp may return fewer reviews if there are fewer available or another stopping condition is reached.

## `reviewsAfterDate` (type: `string`):

Optional. Collect only reviews newer than this date. Use YYYY-MM-DD, for example 2026-01-01. Because reviews are processed newest first, collection stops once an older review is reached.

## `stopAtReviewId` (type: `string`):

Optional. Stop when this Yelp review ID is encountered. The matching review itself is not included. This is useful for incremental monitoring so you only collect reviews published since your previous run.

## Actor input object example

```json
{
  "businessIds": [
    "WavvLdfdP6g8aZTtbBQHTw"
  ],
  "maxReviewsPerBusiness": 100
}
```

# Actor output Schema

## `results` (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 = {
    "businessIds": [
        "WavvLdfdP6g8aZTtbBQHTw"
    ],
    "reviewsAfterDate": "",
    "stopAtReviewId": ""
};

// Run the Actor and wait for it to finish
const run = await client.actor("aerodynamic_tripod/yelp-reviews-by-business-id").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 = {
    "businessIds": ["WavvLdfdP6g8aZTtbBQHTw"],
    "reviewsAfterDate": "",
    "stopAtReviewId": "",
}

# Run the Actor and wait for it to finish
run = client.actor("aerodynamic_tripod/yelp-reviews-by-business-id").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 '{
  "businessIds": [
    "WavvLdfdP6g8aZTtbBQHTw"
  ],
  "reviewsAfterDate": "",
  "stopAtReviewId": ""
}' |
apify call aerodynamic_tripod/yelp-reviews-by-business-id --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,aerodynamic_tripod/yelp-reviews-by-business-id"
        }
    }
}

```

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/AGfxEkkz7yjMZXTJh/builds/WAt8W2ROTKW2rmsv5/openapi.json