# Yelp Scraper — Businesses, Reviews — $2.50/1K until 11-24 (`architekture/yelp-scraper`) Actor

Yelp scraper at a launch price: $2.50 per 1,000 businesses until 2026-11-24, then $4.00. US businesses by query and city with rating, review count, categories, price tier, phone, address, coordinates and hours, or reviews by business URL; watch mode delivers only new reviews.

- **URL**: https://apify.com/architekture/yelp-scraper.md
- **Developed by:** [architek.earth](https://apify.com/architekture) (community)
- **Categories:** Agents, MCP servers
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.50 / 1,000 delivered businesses

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?

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 — Businesses, Reviews, Hours & Coordinates

**Recorded run: 100 businesses from 10 searches in 161 seconds** (2026-10-25, build 0.1.4, run `TE39sMKs5JHGvgd1L`). A bounded canary sample, not a full-catalogue benchmark.

architek.earth — an independent data studio. Pay-per-result scrapers with recorded runs, published canaries and stable schemas, built for people and AI agents.

**What's new**

- **2026-10-25** — Launch price: businesses $2.50 / 1,000 (was $4.00) until 2026-11-24, then back to $4.00 / 1,000; reviews unchanged at $2.50 / 1,000. Input recipes, a head-to-head table and MCP setup for Claude and Cursor added to this page.
- **2026-10-25** — First version: Yelp businesses by search query and US location (rating, review count, categories, price tier, phone, address, coordinates, weekly hours), reviews by business URL newest first, watch mode for new reviews, resumable runs.

Give this Yelp scraper a search query and a US location to get Yelp's organic results as business rows, or give it business URLs to get their reviews, newest first.

| Source | Market | From | Standout fields |
|---|---|---|---|
| Yelp (www.yelp.com) | United States | $2.50 / 1,000 businesses (launch price until 2026-11-24, then $4.00) | rating and review count, latitude/longitude, this week's opening hours |

### ✅ Why choose this scraper

- **Coordinates and hours on every business.** `latitude` and `longitude` were filled on 100 of 100 businesses in run `TE39sMKs5JHGvgd1L`, and `hours` on 99 of 100, from one batched Yelp data request per search page.
- **Recorded success on Yelp's DataDome wall.** In the container gate, 19 of 20 fresh browser sessions delivered complete rows (search 9/10, reviews 10/10), with 0 re-challenges inside a solved session; in every validation run on builds 0.1.4 to 0.1.7, charges equalled delivered rows.
- **New-review alerts.** `incrementalMode` with a `stateKey` delivers only reviews not delivered before: the rerun `yhQmKESsL3dqwFMXF` on 2 businesses found 20 known reviews and charged 0.
- **Organic results only.** `position` is Yelp's organic rank; sponsored results are never returned or charged.
- **Resumable.** A stopped run continues with the same `stateKey`: run `TsQjNqIBIsA8Zy1rv` resumed after a forced stop and delivered the 4 remaining searches (40 businesses) with no row charged twice.

#### Tested head-to-head (2026-10-25)

| | This actor | The field (11 Yelp actors in the store search) |
|---|---|---|
| Runs that did not succeed | 0% of 3 recorded canary runs (2026-10-25); 19 of 20 fresh browser sessions passed DataDome in the container gate | median 0%, range 0–78%; 4 of 11 had failed runs (30-day store stats) |
| Rows per run | 10 businesses or 10 reviews per canary run | not published |
| Price | $2.50 / 1,000 businesses (launch), $2.50 / 1,000 reviews | median $0.90 / 1,000 rows, most review-only; business scrapers $3.00–$5.00 / 1,000 |

### ⚠️ Worth knowing up front

- Yelp is protected by DataDome. Every run starts a real browser (Camoufox) on Apify residential proxies and waits for Yelp's device check, about 10 to 35 seconds per browser (median 27 s in the gate). The browser and proxy cost is included in the price, which is why a business costs $0.0025 at the launch price ($0.004 from 2026-11-24) rather than a fraction of a cent.
- Pacing: up to 3 browsers run at once, one per 5 searches or business URLs, and each search takes a few seconds once its browser is ready. A 10-search run took 161 seconds.
- US locations only in this version. The business `website` is not included (it needs one extra Yelp page per business); `priceRange` is empty where Yelp shows no price tier (most service businesses: 41 of 100 businesses had one in run `TE39sMKs5JHGvgd1L`), and `phone` and `hours` are empty where the listing has none.
- Reviews come newest first by default; `sortBy: "relevance"` uses Yelp's own order. Watch mode stops at the first page of reviews it has already delivered, so it reads one page per unchanged business.
- A browser whose device check does not clear is closed and the search is retried on a new browser and a new residential session, at most twice; then that search ends with a free `BLOCKED` row. Two blocked searches in a row stop the run as `PARTIAL`. A run that reaches its timeout stops with a free `ACTOR_DEADLINE` row and can be resumed with the same `stateKey`.
- Invalid input, a search with no results, a business URL with no Yelp business, a block, the timeout or your spending limit end with a free status row (`"recordType": "status"`) that says what happened.

### ⚡ Try the example

This actor has no free preview; the example below costs about $0.025 (10 businesses at the launch price).

Open the actor's input page, switch to JSON, paste this and start the run:

```json
{
  "mode": "search",
  "queries": ["pizza"],
  "locations": ["Austin, TX"]
}
```

For reviews, set `"mode": "reviews"` and `"businessUrls": ["https://www.yelp.com/biz/home-slice-pizza-austin"]`; add more queries, locations or `maxResultsPerSearch` for paid collection.

### ⚙️ Input

| Parameter | Type | Default | Description |
|---|---|---|---|
| `mode` | select | `search` | `search`: queries x locations to business rows. `reviews`: business URLs to review rows. |
| `queries` | array | — | Search mode. What you would type into Yelp's search box, e.g. `pizza`, `plumbers`. Each query runs in each location; at most 50 searches per run. |
| `locations` | array | — | Search mode. US city and state, ZIP code or neighbourhood, e.g. `Austin, TX`. |
| `maxResultsPerSearch` | integer | 10 | Search mode. Organic businesses per search, 1 to 100 (10 per Yelp page; more reads the next pages). |
| `businessUrls` | array | — | Reviews mode. 1 to 50 Yelp business pages, e.g. `https://www.yelp.com/biz/home-slice-pizza-austin`. |
| `maxReviewsPerBusiness` | integer | 20 | Reviews mode. Reviews per business, 1 to 1,000 (10 per Yelp page). |
| `sortBy` | select | `newest` | Reviews mode. `newest` or `relevance`. |
| `incrementalMode` | boolean | false | Deliver and charge only businesses or reviews this `stateKey` has not delivered before. Needs `stateKey`. |
| `stateKey` | string | — | Any name you choose, reused on every run of the same watch, or to resume a stopped run without re-charging. |
| `feedback` | string | — | Optional note for the maintainers. It is logged and read by a human, and it never changes output. |

#### Input recipes

Linked recipes open a public example task with exactly this input; run it as is or copy it. Paste the others into the JSON tab of the input page.

- [Pizza places in Austin, TX](https://apify.com/architekture/yelp-scraper/examples/yelp-pizza-austin): `{"mode": "search", "queries": ["pizza"], "locations": ["Austin, TX"]}`
- [Plumbers and dentists in Chicago, 20 each](https://apify.com/architekture/yelp-scraper/examples/yelp-plumbers-dentists-chicago): `{"mode": "search", "queries": ["plumbers", "dentist"], "locations": ["Chicago, IL"], "maxResultsPerSearch": 20}`
- [One query in three cities](https://apify.com/architekture/yelp-scraper/examples/yelp-coffee-three-cities): `{"mode": "search", "queries": ["coffee"], "locations": ["Seattle, WA", "Portland, OR", "Denver, CO"]}`
- [Search by ZIP code, three pages](https://apify.com/architekture/yelp-scraper/examples/yelp-dentists-by-zip): `{"mode": "search", "queries": ["dentist"], "locations": ["10001"], "maxResultsPerSearch": 30}`
- 50 most relevant reviews of one business: `{"mode": "reviews", "businessUrls": ["https://www.yelp.com/biz/lou-malnatis-pizzeria-chicago"], "maxReviewsPerBusiness": 50, "sortBy": "relevance"}`
- [Daily new-review watch on 2 businesses](https://apify.com/architekture/yelp-scraper/examples/yelp-new-reviews-watch): `{"mode": "reviews", "businessUrls": ["https://www.yelp.com/biz/home-slice-pizza-austin", "https://www.yelp.com/biz/lou-malnatis-pizzeria-chicago"], "maxReviewsPerBusiness": 20, "incrementalMode": true, "stateKey": "yelp-new-reviews-watch"}`

### 🧱 Stable fields

These top-level fields keep the same name and the same kind of value in every release. Fields are only ever added, never renamed or removed, so an n8n, Make, Zapier or spreadsheet pipeline can bind to them.

| Field | Type | Meaning |
|---|---|---|
| `query` | string | Business rows: the query as you gave it. |
| `location` | string | Business rows: the location as you gave it. |
| `position` | number | Business rows: Yelp's organic rank, from 1. |
| `encid` | string | Yelp's business id (on business and review rows); the dedupe key for businesses. |
| `alias` | string, nullable | Yelp's business slug, e.g. `home-slice-pizza-austin`. |
| `url` | string, nullable | Business page, `https://www.yelp.com/biz/<alias>`. |
| `name` | string, nullable | Business name. |
| `rating` | number, nullable | Star rating (business rows: the average; review rows: the reviewer's stars). |
| `reviewCount` | number, nullable | Number of reviews Yelp shows for the business. |
| `categories` | array | Yelp category titles, e.g. `["Pizza", "Italian"]`. |
| `priceRange` | string, nullable | `$` to `$$$$`; empty when Yelp shows none. |
| `phone` | string, nullable | Formatted phone number. |
| `address` | object | `line1`, `line2`, `line3`, `city`, `region`, `postalCode`, `formatted`. |
| `country` | string, nullable | Country code, `US`. |
| `latitude` | number, nullable | Business latitude. |
| `longitude` | number, nullable | Business longitude. |
| `hours` | object, nullable | This week's opening hours by day, e.g. `{"Mon": ["11:00 AM - 10:00 PM"]}`; empty when the listing has none. |
| `businessUrl` | string | Review rows: the business URL the review belongs to. |
| `reviewId` | string | Review rows: Yelp's review id; the dedupe and watch-mode key. |
| `text` | string, nullable | Review rows: the full review text. |
| `language` | string, nullable | Review rows: language code, e.g. `en`. |
| `createdAt` | string, nullable | Review rows: date and time in the business's time zone, ISO 8601. |
| `authorName` | string, nullable | Review rows: the reviewer's name as Yelp shows it, e.g. `Chad E.`. |
| `authorLocation` | string, nullable | Review rows: the reviewer's home town as Yelp shows it. |
| `authorReviewCount` | number, nullable | Review rows: how many reviews the reviewer has written. |
| `scrapedAt` | string | When the row was collected (UTC, ISO 8601). |
| `status`, `inputRef`, `message` | string | Status rows only: what happened, to which input, in words. |
| `recordType` | string | `"status"` on free status rows; `"business"` or `"review"` on data rows. |

Other fields are extras, not part of the contract. To have one pinned, say so in `feedback`.

### 📦 Output example

Abridged real row from run `TE39sMKs5JHGvgd1L` on 2026-10-25; values are a historical snapshot.

```json
{
  "recordType": "business",
  "query": "pizza",
  "location": "Chicago, IL",
  "position": 1,
  "encid": "8vFJH_paXsMocmEO_KAa3w",
  "alias": "lou-malnatis-pizzeria-chicago",
  "url": "https://www.yelp.com/biz/lou-malnatis-pizzeria-chicago",
  "name": "Lou Malnati's Pizzeria",
  "rating": 4,
  "reviewCount": 7977,
  "categories": ["Pizza", "Italian", "Sandwiches"],
  "priceRange": "$$",
  "phone": "(312) 828-9800",
  "address": {"line1": "439 N Wells St", "city": "Chicago", "region": "IL", "postalCode": "60654", "formatted": "439 N Wells St, Chicago, IL 60654"},
  "country": "US",
  "latitude": 41.8903586,
  "longitude": -87.6337084,
  "hours": {"Mon": ["11:00 AM - 11:00 PM"], "Fri": ["11:00 AM - 12:00 AM (Next day)"]},
  "scrapedAt": "2026-10-25T01:01:34.885343+00:00"
}
```

A review row from run `2SfEj5bBLCCOpEsYZ`:

```json
{
  "recordType": "review",
  "businessUrl": "https://www.yelp.com/biz/home-slice-pizza-austin",
  "encid": "1Eq16r_MSnvPsnIykBdy9w",
  "reviewId": "SnLCeXofs_9GJFRGhCapCQ",
  "rating": 5,
  "text": "Good cheap pizza.\n\nGo inside! The line is shorter.\n\nAlso got the white something pizza. Good stuff",
  "language": "en",
  "createdAt": "2026-10-24T13:00:47-05:00",
  "authorName": "Chad E.",
  "authorLocation": "Mesa, AZ",
  "authorReviewCount": 28,
  "scrapedAt": "2026-10-25T01:15:52.580782+00:00"
}
```

A free status row looks like this:

```json
{
  "recordType": "status",
  "inputRef": "https://www.yelp.com/biz/no-such-business-zzqx-austin",
  "status": "NOT_FOUND",
  "message": "No Yelp business at this URL; nothing was charged",
  "scrapedAt": "2026-10-25T01:24:38.178821+00:00"
}
```

### 🧠 Advanced usage

**New-review alerts for a competitor set.** Run `reviews` daily on the businesses you watch with `"incrementalMode": true` and one `stateKey`. Each run delivers and charges only reviews that are new since the last run; a run with no new reviews ends `COMPLETE` with 0 rows. Route the dataset to Slack or email with a webhook on run success.

**Local lead lists.** Use several `queries` and `locations` in one run (at most 50 searches); a business found by two searches is delivered and charged once. Raise `maxResultsPerSearch` to read further result pages, 10 businesses per page.

**Resume and check completion.** Give every large run a `stateKey`. If it stops on its timeout or your spending limit, start it again with the same input and `stateKey`: it continues after the last delivered batch. `RUN_SUMMARY` in the run's key-value store has `status` (`COMPLETE`, `PARTIAL`, `LIMITED`, `BUDGET_LIMIT`), `delivered`, `charged` and `checkpointComplete`.

### 🔌 Integrations

Results land in a dataset you can export as JSON, CSV or Excel. They can also flow to Google Sheets, Make, Zapier or n8n, or to a webhook when a run finishes. The Apify Scheduler runs it on a timetable. A daily `reviews` run in watch mode is the useful schedule for reputation tracking; a weekly `search` run tracks new businesses in a category. Code samples for the other studio actors are in [architek-earth/examples](https://github.com/architek-earth/examples); this actor has no folder there yet.

#### n8n and Make

No n8n workflow or Make blueprint for this actor yet: `architek-earth/examples` has no `yelp-scraper` folder. Until it does, n8n's Apify node ("Run actor and get dataset") with `architekture/yelp-scraper` and the input above, or Make's Apify "Run an Actor" module, returns the same rows.

### 💸 Pricing

Pay per result. Platform and proxy usage are included. Status rows and failed requests are free. Each business or review is charged once, after it is written to the dataset; a business found again by another search in the same run, or a row delivered by an earlier run with the same `stateKey` in watch mode, is not charged again, and a resumed run continues after the last confirmed batch without re-charging it.

| Event | Price | What it covers |
|---|---|---|
| `business` | $2.50 / 1,000 businesses (launch price until 2026-11-24, then $4.00 / 1,000) | One delivered business row from a search, with rating, categories, address, coordinates and hours. |
| `review` | $2.50 / 1,000 reviews | One delivered review row with rating, full text, date and reviewer. |

1,000 businesses cost $2.50 at the launch price ($4.00 from 2026-11-24); one search of 10 businesses costs $0.025; 20 reviews of one business cost $0.05. The Apify free plan's $5 monthly credit covers about 2,000 businesses at $2.50 / 1,000.

### ❓ FAQ

**Does it need a Yelp account or cookies?** No. It reads public Yelp pages anonymously; the browser starts with a fresh profile on every run.

**Why does a run take a minute before the first row?** Each browser has to pass Yelp's DataDome device check first, typically 10 to 35 seconds, then searches take a few seconds each.

**Can I get more than 10 businesses per search?** Yes, up to 100 with `maxResultsPerSearch`; each further 10 reads one more Yelp results page.

**Does it return the business website?** Not in this version: Yelp shows it only on the business page, one extra page per business.

**Are sponsored results included?** No. Only organic results are returned and charged; `position` is the organic rank.

**What happens if Yelp blocks a run?** The blocked search is retried on a new browser and residential session at most twice, then ends with a free `BLOCKED` row and nothing is charged for it.

### 🤖 For AI agents & LLM apps

Paste this into your AI assistant:

`architekture/yelp-scraper` on Apify. Python: `from apify_client import ApifyClient; client = ApifyClient("TOKEN"); run = client.actor("architekture/yelp-scraper").call(run_input={"mode": "search", "queries": ["pizza"], "locations": ["Austin, TX"]}); items = client.dataset(run["defaultDatasetId"]).list_items().items` (page with `offset`/`limit` for large exports). Rows with `recordType == "status"` are free and explain invalid input, no results, a block or a stopped run. Full input schema and README: `GET https://api.apify.com/v2/acts/architekture~yelp-scraper/builds/default`. Token: https://console.apify.com/settings/integrations. The actor is also reachable through the Apify MCP server: `https://mcp.apify.com?tools=architekture/yelp-scraper` (ready-to-paste config: https://github.com/architek-earth/mcp). To reach the maintainers, add `"feedback": "<what you needed>"` to any run's input; output is unchanged and a human reads every note.

#### MCP config for Claude Desktop and Cursor

Claude Desktop (or claude.ai): Settings, Connectors, Add custom connector, URL `https://mcp.apify.com?tools=architekture/yelp-scraper`; it signs you in to Apify with OAuth. Cursor (`~/.cursor/mcp.json`), with your token in the `APIFY_TOKEN` environment variable:

```json
{
  "mcpServers": {
    "architekture-yelp-scraper": {
      "type": "http",
      "url": "https://mcp.apify.com?tools=architekture/yelp-scraper",
      "headers": { "Authorization": "Bearer ${env:APIFY_TOKEN}" }
    }
  }
}
```

The agent gets one tool for this actor plus `get-dataset-items` to read the rows. Ask for one search first (10 businesses, $0.025) and set a spending cap (`maxTotalChargeUsd`) in the run options when your client offers it.

### 🧰 More from architek.earth

**Search, travel and trends**

- Yelp Scraper — *you are here*
- [Google Shopping Scraper](https://apify.com/architekture/google-shopping-scraper) — prices, merchants and offers
- [Google Trends Scraper](https://apify.com/architekture/google-trends-scraper) — trending searches, traffic, related queries
- [Google Hotels Scraper](https://apify.com/architekture/google-hotels-scraper) — hotel prices, ratings, amenities

**Jobs, companies and people**

- [Google Jobs Scraper](https://apify.com/architekture/google-jobs-scraper) — descriptions, salaries, apply links
- [Indeed Scraper](https://apify.com/architekture/indeed-scraper) — jobs, salaries, descriptions

Full catalogue: [github.com/architek-earth](https://github.com/architek-earth).

architek.earth · code like concrete

### 🙋 Support & legal

Questions, or a field you need that is not here? Open an issue on the actor's Issues tab or email north@architek.earth. A human replies within a day.

This actor collects only publicly available data from yelp.com, the same pages any visitor sees without logging in. It does not bypass authentication. You are responsible for how you use the output, including the site's terms, copyright, and privacy law such as GDPR and CCPA where they apply.

### 📝 Changelog

- **2026-10-25** — \[internal] Input recipes link only published example tasks; output and prices unchanged.
- **2026-10-25** — Launch price: businesses $2.50 / 1,000 (was $4.00) until 2026-11-24, then back to $4.00 / 1,000; reviews unchanged at $2.50 / 1,000. Input recipes, a head-to-head table and MCP setup for Claude and Cursor added to this page.
- **2026-10-25** — First version: Yelp businesses by search query and US location (rating, review count, categories, price tier, phone, address, coordinates, weekly hours), reviews by business URL newest first, watch mode for new reviews, resumable runs.

# Actor input Schema

## `mode` (type: `string`):

search: every query is searched in every location and the organic Yelp results come back as business rows. reviews: each business URL's reviews come back as review rows, newest first.

## `queries` (type: `array`):

What you would type into Yelp's search box, e.g. "pizza", "plumbers", "dentist". Each query is run in each location (at most 50 searches per run).

## `locations` (type: `array`):

US city and state, ZIP code or neighbourhood, as Yelp accepts it, e.g. "Austin, TX" or "Brooklyn, NY". US only in this version.

## `maxResultsPerSearch` (type: `integer`):

Organic results per query and location. Yelp shows 10 per page; more than 10 reads the next pages (one extra page request per 10). Sponsored results are never returned.

## `businessUrls` (type: `array`):

Yelp business pages, e.g. https://www.yelp.com/biz/home-slice-pizza-austin (1 to 50).

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

Most recent reviews to collect per business (10 per Yelp page).

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

Watch mode (incrementalMode) stops at the first page of known reviews only with newest first.

## `incrementalMode` (type: `boolean`):

Deliver and charge only businesses or reviews this stateKey has not delivered before. Needs a stateKey.

## `stateKey` (type: `string`):

Any name you choose, reused on every run of the same watch (incrementalMode) or to resume a stopped run without re-charging.

## `feedback` (type: `string`):

Optional note for the maintainers. It is logged and read by a human, and it never changes output.

## Actor input object example

```json
{
  "mode": "search",
  "queries": [
    "pizza"
  ],
  "locations": [
    "Austin, TX"
  ],
  "maxResultsPerSearch": 10,
  "maxReviewsPerBusiness": 20,
  "sortBy": "newest",
  "incrementalMode": false
}
```

# Actor output Schema

## `dataset` (type: `string`):

No description

## `summary` (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 = {
    "queries": [
        "pizza"
    ],
    "locations": [
        "Austin, TX"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("architekture/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 = {
    "queries": ["pizza"],
    "locations": ["Austin, TX"],
}

# Run the Actor and wait for it to finish
run = client.actor("architekture/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 '{
  "queries": [
    "pizza"
  ],
  "locations": [
    "Austin, TX"
  ]
}' |
apify call architekture/yelp-scraper --silent --output-dataset

```

## MCP server setup

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