# 🍽️ Ultimate Yelp Scraper (`scraper-engine/ultimate-yelp-scraper`) Actor

Ultimate Yelp Scraper extracts public business data including names, categories, ratings, reviews, addresses, phone numbers, websites, hours, and business URLs. Build structured datasets for local lead generation, market research, competitor analysis, and business discovery.

- **URL**: https://apify.com/scraper-engine/ultimate-yelp-scraper.md
- **Developed by:** [Scraper Engine](https://apify.com/scraper-engine) (community)
- **Categories:**
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.99 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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 Business Scraper — Reviews, Photos, Hours and Amenities

Ultimate Yelp Scraper extracts Yelp business listings as structured JSON — ratings, price range, categories, address and coordinates, phone and website, hours, amenities, and the full paginated review feed with reviewer details. It also scrapes Yelp Collection and Event pages. Point it at business, search, collection or event URLs, or just give it a keyword and a location, and results save to your Apify dataset the moment each record is ready. Run it from the Actor's Apify Store page — no coding required.

### What is Ultimate Yelp Scraper?

Ultimate Yelp Scraper is an Apify Actor that navigates Yelp with a headless stealth browser, reads the same data a signed-out visitor sees, and returns it as clean JSON — business details, reviews, photos, amenities, hours, Q\&A, and the businesses/subscribers listed on Collection and Event pages. It does not require a Yelp account, login, or API key — every field comes from Yelp pages that are publicly visible without signing in. It's built for developers, local-SEO and market-research teams, and data/AI engineers who need structured Yelp data without maintaining their own scraper or Yelp API integration.

### What Yelp business data is publicly available to scrape?

Anyone who visits a Yelp business, search, collection, or event page without logging in can already see the fields listed below — no Yelp account is required to view them.

| Data Category | Publicly Available | Restricted (requires Yelp login / Yelp for Business account) |
| --- | --- | --- |
| Business identity & contact | Name, categories, price range, phone, website, address, coordinates | — |
| Ratings & review counts | Overall rating, total review count | — |
| Review text & reviewer info | Full review text, rating, date, reviewer name, elite status, reaction counts | Sending a message to a reviewer, voting/reacting yourself |
| Photos | Business photo URLs | Uploading photos, tagging yourself in one |
| Hours, amenities & Q\&A | Operating hours, amenities/attributes, "Ask the Community" questions | Posting a new question or answer |
| Collections & Events | Collection business lists, event details and subscriber lists | Creating or editing a collection, RSVPing to an event |
| Business analytics & inbox | — | Owner-side traffic stats, lead/message inbox, ad performance (Yelp for Business login only) |

Ultimate Yelp Scraper only returns publicly visible data — what any visitor sees. Nothing behind a login wall.

### What data can I extract with Ultimate Yelp Scraper?

Ultimate Yelp Scraper returns business identity and location fields, rating/review/media fields, and — with Deep Detail Mode on — amenities, about, Q\&A and highlight fields, plus separate Collection and Event record shapes.

| Field Name | Description |
| --- | --- |
| `businessId` | Yelp's internal encoded business ID |
| `type` | Record shape: `business`, `collection`, or `event` |
| `url` | Canonical Yelp URL for the business |
| `title` | Business name |
| `address` | Object: `city`, `regionCode`, `addressLine1`–`addressLine3`, `postalCode`, `formatted` |
| `coordinates` | Array of `{latitude, longitude}` |
| `categories` | Array of category names |
| `phoneNumber` | Formatted phone number |
| `website` | External business website URL (resolved from Yelp's outbound link) |
| `reservationUrl` | Reservation link, if Yelp exposes one |
| `rating` | Overall star rating |
| `reviewCount` | Total review count shown on Yelp |
| `priceRange` | Yelp price tier, e.g. `$$` |
| `isClaimed` | Whether the business owner has claimed the listing |
| `isBusinessClosed` | Whether Yelp marks the business permanently closed |
| `reviews` | Array of review objects (see below) |
| `mediaCount` | Total photo count Yelp reports for the business |
| `media` | Array of original-resolution photo URLs |
| `operationHours` | Object of day → hours string, e.g. `{"Mon": "8:00 AM - 8:00 PM"}` |
| `amenities` | Array of amenity objects (Deep Detail Mode most reliable) |
| `about` | About/history text shown on the business page |
| `yearEstablished` | Year the business states it was established |
| `history` | Business history text, if present |
| `highlights` | Array of highlight strings pulled from review highlights |
| `questions` | Array of "Ask the Community" question objects |
| `searchUrl` | The search URL that surfaced this business, if found via search |
| `startUrl` | The original Start URL this record came from |

#### Business identity & location fields

`businessId`, `title`, `url`, `address`, `coordinates`, `categories`, `phoneNumber`, `website`, `reservationUrl`.

#### Ratings, review & media fields

`rating`, `reviewCount`, `priceRange`, `isClaimed`, `isBusinessClosed`, `reviews`, `mediaCount`, `media`, `operationHours`.

Each object in `reviews` carries: `userName`, `userUrl`, `isElite`, `rating`, `date`, `review` (full text), `reviewLanguage`, `reviewLink`, `feedback` (an object of `Helpful`/`Thanks`/`Love this`/`Oh no` reaction counts), and `author` (`id`, `name`, `location`, `friendCount`, `reviewCount`, `businessPhotoCount`, `isElite`, and `photoUrls` when the reviewer has a profile photo).

#### Amenities, about & Q\&A fields (Deep Detail Mode)

`amenities` (array of single-key objects, e.g. `{"wifi_options": "Free Wi-Fi", "isEnabled": true}`), `about`, `yearEstablished`, `history`, `highlights`, `questions` (each `{question, answer, user, answerDate}`).

#### 🤖 Add-on: Need additional Yelp-adjacent data?

Pair Ultimate Yelp Scraper with [Shopify Store Leads Scraper](https://apify.com/scraper-engine/shopify-store-leads-scraper-emails-phones-ratings) if the businesses you're researching also run Shopify storefronts, or [Zillow Property Details Scraper](https://apify.com/scraper-engine/zillow-property-details-scraper) when you need the property records behind a business address. For turning a business's own site into text for an LLM pipeline, run its `website` field through [Website Content Crawler](https://apify.com/scraper-engine/website-content-crawler).

### How does Ultimate Yelp Scraper differ from the official Yelp Fusion API?

Yelp's own Fusion API returns basic business fields and up to three review excerpts per business behind a paid, approval-gated API key; Ultimate Yelp Scraper returns the full paginated review feed, the complete photo set, amenities/Q\&A/about, and Collection/Event pages, started directly from a Yelp URL or keyword with no key required.

| Feature | Yelp Fusion API | Ultimate Yelp Scraper |
| --- | --- | --- |
| Access | Requires a Yelp developer account, an API key, and a selected commercial plan | Runs on Apify — no Yelp account or API key |
| Reviews per business | Up to 3 review excerpts | Full review feed, paginated, sortable by relevance/date/rating/elite |
| Photos | A small photos field on the business record | Full original-resolution photo set, page-limited if you choose |
| Search result cap | Up to 240 businesses per search request | Governed by your own `maxItems` / `endPage` input |
| Amenities, about, Q\&A | Not part of the documented business fields | Included via Deep Detail Mode |
| Collection & Event pages | Not part of the documented endpoints | Scraped directly as their own record types |

Use the Fusion API when you're building a Yelp-branded integration under Yelp's own terms and three review excerpts are enough. Use Ultimate Yelp Scraper when you need full review text, the complete photo set, amenities/Q\&A, or Collection/Event data in one JSON export.

### How to use Ultimate Yelp Scraper

Ultimate Yelp Scraper runs on the Apify platform — there's no separate signup or API key to obtain before starting a run.

1. Open the Actor's page in Apify Console (or the Apify Store listing) and click **Try for free** / **Start**.
2. Provide input: either paste one or more Yelp URLs into `startUrls`, or fill in `search` (and optionally `searchLocation`) — no field is strictly required, but you need at least one of the two or the run exits immediately.
3. Set optional filters — `maxItems` to cap total results, `deepDetail` to include amenities/about/Q\&A, `includeReviews`/`includePhotos`/`includeAmenities` to toggle each data type, and `reviewSort` to control review order.
4. Start the run.
5. Open the **Output** tab to browse results by section (Overview, Location & Hours, Reviews, Amenities & About, Media, Collections & Events), or export the full dataset as JSON or CSV.

#### How to scale to bulk business extraction

`startUrls` is an array — paste business, search, collection, and event URLs in bulk (one per line, or upload a file) and the Actor works through all of them in a single run, deduplicating and dispatching each by URL type. For keyword-based bulk discovery instead of a URL list, use `search` + `searchLocation` with `endPage` to control how many search-result pages get paginated before businesses are queued for detail extraction.

### What can you do with Yelp business data?

- A local-SEO consultant auditing a client uses `rating`, `reviewCount`, and `categories` to benchmark a business against its Yelp presence over time.
- A market researcher comparing neighborhoods uses `priceRange`, `amenities`, and `address` across many businesses to map competitive density by area.
- A reputation-management team uses `reviews[].rating`, `reviews[].date`, and `reviews[].review` to track sentiment trends and flag repeat complaints.
- An events marketer uses an Event record's `fromDate`, `toDate`, and `subscribers` to gauge interest before promoting a listing.
- An AI engineer feeds `about`, `amenities`, and `reviews[].review` text into a RAG pipeline so an agent can answer natural-language questions about a business's offerings and reputation grounded in real Yelp data.

### How does Ultimate Yelp Scraper handle rate limits and blocking?

Yelp fronts www.yelp.com with DataDome; a request without a browser-bound `datadome` cookie is hard-blocked. Ultimate Yelp Scraper handles this by launching one stealth browser session (camoufox) that passes Yelp's DataDome check, then issues every subsequent request as an in-page call from that same passed session instead of a bare HTTP client. If a bootstrap attempt is blocked, it automatically escalates the proxy tier — no proxy → Apify datacenter proxy → Apify residential proxy — retrying at least 3 times on residential, and once it reaches residential it stays there for the rest of the run. Every escalation is logged. Individual GraphQL calls that fail or get rate-limited are retried up to `maxRetries` times with a backoff delay; a business page that still can't be reached is skipped (logged) rather than failing the whole run.

⚠️ Deep Detail Mode processes businesses one at a time (it navigates and renders each page to read amenities/about/Q\&A/highlights from the DOM), so it is slower than the default; turning it off runs businesses concurrently via `concurrency` but returns amenities and about/Q\&A only on a best-effort basis from the GraphQL response.

### ⬇️ Input

Ultimate Yelp Scraper takes no required fields — provide either `startUrls` or `search`, or the run exits with nothing to do.

| Parameter | Required | Type | Description | Example Value |
| --- | --- | --- | --- | --- |
| `startUrls` | No | Array | One or more Yelp URLs — business (`/biz/...`), search (`/search?...`), collection (`/collection/...`), or event (`/events/...`) pages. Takes priority over `search` when non-empty. | `["https://www.yelp.com/biz/maxs-restaurant-glendale-glendale-3"]` |
| `search` | No | String | Keyword to search for on Yelp. Used only when `startUrls` is empty. | `"restaurants"` |
| `searchLocation` | No | String | City/state or ZIP to search in. Used together with `search`. | `"Los Angeles, CA"` |
| `maxItems` | No | Integer (min 1) | Stop after this many businesses/collections/events, combined across all inputs. Empty = no limit. | `10` |
| `endPage` | No | Integer (min 1) | How many search-result pages (10 businesses/page) to paginate before stopping. Empty = keep paging until `maxItems` or results run out. | `3` |
| `deepDetail` | No | Boolean, default `true` | When on, navigates each business page to also capture amenities, about/history, Q\&A, highlights, claimed status, and year established. When off, runs fully concurrent using only Yelp's GraphQL API. | `true` |
| `includeReviews` | No | Boolean, default `true` | Paginate and collect the full review feed. When off, only the first page of reviews shipped with the business detail is kept. | `true` |
| `reviewSort` | No | String, default `"relevance_desc"`, enum: `relevance_desc`, `date_desc`, `date_asc`, `rating_desc`, `rating_asc`, `elites_desc` | Order reviews are fetched in. | `"date_desc"` |
| `startPageForReviews` | No | Integer (min 1) | Skip ahead to this review page (10 reviews/page) instead of starting from page 1. | `1` |
| `endPageForReviews` | No | Integer (min 1) | Stop after this review page. Empty = fetch every available review. | `5` |
| `includePhotos` | No | Boolean, default `true` | Collect original-resolution photo URLs for every business. | `true` |
| `endPageForPhotos` | No | Integer (min 1) | Limit how many photo pages (~30 photos/page) to collect. Empty = collect every available photo. | `2` |
| `includeAmenities` | No | Boolean, default `true` | Extract amenities/attributes. Best-effort; most reliable with `deepDetail` on. | `true` |
| `proxyConfiguration` | No | Object | Proxy settings. Default connects with no proxy and auto-escalates to datacenter then residential if DataDome blocks a bootstrap attempt. You can also force a tier here. | `{"useApifyProxy": false}` |
| `concurrency` | No | Integer, default `5`, min 1, max 20 | How many businesses to process in parallel (used only when `deepDetail` is off). | `5` |
| `maxRetries` | No | Integer, default `3`, min 1, max 10 | How many times to retry a single GraphQL/API call before giving up on it. | `3` |
| `maxBootstrapAttempts` | No | Integer, default `12`, min 1, max 30 | How many fresh browser/IP attempts to make while trying to pass Yelp's DataDome challenge before giving up the whole run. | `12` |
| `reloadsPerAttempt` | No | Integer, default `3`, min 1, max 10 | How many times to reload the same page (same IP) before rotating to a fresh browser attempt. | `3` |

#### Example input

```json
{
  "startUrls": [
    { "url": "https://www.yelp.com/biz/maxs-restaurant-glendale-glendale-3" },
    { "url": "https://www.yelp.com/collection/user-abc123/my-favorite-spots" }
  ],
  "search": "",
  "searchLocation": "",
  "maxItems": 25,
  "endPage": 3,
  "deepDetail": true,
  "includeReviews": true,
  "reviewSort": "date_desc",
  "startPageForReviews": 1,
  "endPageForReviews": 5,
  "includePhotos": true,
  "endPageForPhotos": 2,
  "includeAmenities": true,
  "proxyConfiguration": { "useApifyProxy": false },
  "concurrency": 5,
  "maxRetries": 3,
  "maxBootstrapAttempts": 12,
  "reloadsPerAttempt": 3
}
```

### ⬆️ Output

Every run pushes typed JSON rows to your Apify dataset live, one per business, collection, or event, using the same field names in every run. The dataset also exposes six pre-built views (Overview, Location & Hours, Reviews, Amenities & About, Media, Collections & Events) plus an All Fields view, and the whole dataset can be exported as JSON or CSV.

#### Example output — business record

```json
{
  "businessId": "znEKghXteVgPyaUboU1Dsg",
  "type": "business",
  "url": "https://www.yelp.com/biz/maxs-restaurant-glendale-glendale-3",
  "title": "Max's Restaurant - Glendale",
  "rating": 3.3,
  "reviewCount": 1403,
  "priceRange": "$$",
  "categories": ["Filipino", "Asian Fusion", "Bars"],
  "isClaimed": true,
  "isBusinessClosed": false,
  "yearEstablished": "1980",
  "history": null,
  "address": {
    "city": "Glendale",
    "regionCode": "CA",
    "addressLine1": "740 N Brand Blvd",
    "addressLine2": null,
    "addressLine3": null,
    "postalCode": "91203",
    "formatted": "740 N Brand Blvd\nGlendale, CA 91203"
  },
  "coordinates": [{ "latitude": 34.15556, "longitude": -118.2554 }],
  "highlights": ["Great for groups", "Family-friendly"],
  "reviews": [
    {
      "userName": "Sarah K.",
      "userUrl": "https://www.yelp.com/user_details?userid=abc123",
      "isElite": true,
      "rating": 5,
      "date": "2026-07-08T00:12:15.000Z",
      "review": "The crispy pata here is unbeatable...",
      "reviewLanguage": "en",
      "reviewLink": "https://www.yelp.com/biz/maxs-restaurant-glendale-glendale-3?hrid=xyz789",
      "author": {
        "id": "abc123",
        "name": "Sarah K.",
        "location": "Los Angeles, CA",
        "friendCount": 42,
        "reviewCount": 118,
        "businessPhotoCount": 6,
        "isElite": true
      },
      "feedback": { "Helpful": 4, "Thanks": 1, "Love this": 2, "Oh no": 0 }
    }
  ],
  "operationHours": { "Mon": "11:00 AM - 9:00 PM", "Tue": "11:00 AM - 9:00 PM" },
  "amenities": [
    { "wifi_options": "Free Wi-Fi", "isEnabled": true },
    { "has_outdoor_seating": "Outdoor seating", "isEnabled": false }
  ],
  "about": "A Filipino-American restaurant chain serving classic Filipino comfort food since 1980.",
  "questions": [
    { "question": "Do they take large group reservations?", "answer": null, "user": null, "answerDate": null }
  ],
  "website": "https://www.maxsrestaurant.com",
  "phoneNumber": "(818) 500-1096",
  "reservationUrl": null,
  "mediaCount": 892,
  "media": ["https://s3-media0.fl.yelpcdn.com/bphoto/abcXYZ123/o.jpg"],
  "searchUrl": null,
  "startUrl": "https://www.yelp.com/biz/maxs-restaurant-glendale-glendale-3"
}
```

#### Example output — collection record

```json
{
  "type": "collection",
  "url": "https://www.yelp.com/collection/user-abc123/my-favorite-spots",
  "title": "My Favorite Spots",
  "description": "Best places I've found around LA.",
  "user": { "name": "Jordan T.", "avatar": "https://s3-media0.fl.yelpcdn.com/photo/abc/ls.jpg", "isElite": true },
  "businesses": [
    {
      "url": "https://www.yelp.com/biz/maxs-restaurant-glendale-glendale-3",
      "name": "Max's Restaurant - Glendale",
      "reviewCount": 1403,
      "rating": 3.3,
      "image": "https://s3-media0.fl.yelpcdn.com/bphoto/abcXYZ123/o.jpg",
      "priceRange": "$$",
      "userReview": "'s 5-star review: Best sisig in town...",
      "categories": []
    }
  ]
}
```

#### Example output — event record

```json
{
  "type": "event",
  "url": "https://www.yelp.com/events/los-angeles-night-market",
  "title": "LA Night Market",
  "image": "https://s3-media0.fl.yelpcdn.com/photo/eventimg/o.jpg",
  "categories": ["Food & Drink Yelp Events"],
  "business": { "url": "", "name": null, "reviewCount": null, "rating": null, "location": "Los Angeles, CA 90012" },
  "fromDate": "2026-09-12T18:00:00-07:00",
  "toDate": "2026-09-12T23:00:00-07:00",
  "price": "Free",
  "description": "An evening night market featuring local vendors and live music.",
  "subscribers": [
    { "name": "Alex R.", "avatar": "https://s3-media0.fl.yelpcdn.com/photo/abc/ls.jpg", "friendCount": null, "reviewCount": null, "isElite": false }
  ]
}
```

### How does it work?

Ultimate Yelp Scraper launches a single headless stealth browser session (camoufox) and lands it on Yelp until it passes Yelp's DataDome bot check — a request without that passed session's cookie is hard-blocked, so every subsequent request in the run reuses the same warmed browser context rather than a bare HTTP client. From there it calls Yelp's own internal GraphQL endpoints for business detail, reviews, hours, map data, and photos, and reads the rendered page DOM for fields Yelp only renders client-side (amenities, about, Q\&A, highlights) when Deep Detail Mode is on. Yelp's internal GraphQL `documentId` signatures are re-extracted live from the page's own network traffic at the start of each run and used ahead of a hardcoded fallback, so a routine Yelp-side signature rotation doesn't require a code update. Only data visible to a signed-out visitor is returned, and the output field names stay the same regardless of how Yelp's page markup changes.

### Integrations

Ultimate Yelp Scraper is an Apify Actor, so it's reachable anywhere Apify's API and client libraries reach — direct API calls, the Apify CLI, or any automation platform that can make an HTTP request.

#### Calling Ultimate Yelp Scraper programmatically

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_API_TOKEN>")

run = client.actor("scraper-engine/ultimate-yelp-scraper").call(run_input={
    "search": "restaurants",
    "searchLocation": "Los Angeles, CA",
    "maxItems": 25,
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["title"], item["rating"])
```

Works in Go, Ruby, Node.js, cURL — any language that can make an HTTP request.

#### No-code tools (n8n, Make, LangChain)

In n8n, use the HTTP Request node (or the Apify node) pointed at the Actor's run endpoint with your API token, then parse the returned dataset items. In Make, use an HTTP module the same way to trigger a run and poll for its dataset. In LangChain or a similar framework, wrap the Apify client call above as a tool so an agent can request fresh Yelp business data on demand.

### Is it legal to scrape Yelp business data?

Scraping publicly available web data is generally legal in the US and EU, and Ultimate Yelp Scraper only returns data any signed-out visitor can already see on Yelp. Business-identity fields (name, address, categories, price, hours) are business/product data, governed by Yelp's own Terms of Service rather than a personal-data regime. The `reviews` array is different: it carries reviewer names, profile details, and elite status, which are personal data under GDPR and CCPA — you need a lawful basis to store and use that data, and reviewers may have rights to access or deletion requests under those regimes. Consult legal counsel if your use case involves bulk storage of personal data.

### Frequently asked questions

#### What Yelp business fields does Ultimate Yelp Scraper return?

The top-level fields include `title`, `rating`, `reviewCount`, `address`, and `reviews` (with full review text and reviewer details) — see [What data can I extract](#what-data-can-i-extract-with-ultimate-yelp-scraper) above for the complete field list, including the separate Collection and Event record shapes.

#### Does Ultimate Yelp Scraper require a Yelp account or login?

No. It reads pages exactly as a signed-out visitor would, using a headless stealth browser to pass Yelp's DataDome check — no Yelp account, login, or API key is needed.

#### How many businesses can I extract in one run?

As many as `maxItems` allows, or unlimited if you leave it empty — the actual count also depends on how many results your `search`/`searchLocation` or `startUrls` combination actually surfaces on Yelp, and `endPage` controls how many search-result pages get walked.

#### What happens if a business page is blocked or can't be resolved?

If a business page can't be reached after `maxRetries` attempts, or its internal business ID can't be resolved, the Actor logs the failure and skips that one URL rather than stopping the whole run — every other queued business, collection, or event still gets processed.

#### Can I scrape multiple Yelp businesses at once?

Yes — pass an array of business, search, collection, or event URLs in `startUrls` (one per line, or upload a file), or use `search` + `searchLocation` to have the Actor discover businesses from Yelp's own search results.

#### Does Ultimate Yelp Scraper work with Claude, ChatGPT, and other AI agent tools?

It's callable as a standard Apify Actor run via HTTP by any agent framework that can make an API call — wrap the run-and-fetch-dataset pattern shown in Integrations above as a tool function for your agent.

#### Does Ultimate Yelp Scraper return data in a format LLMs can use directly?

Yes. Every run returns typed, normalized JSON with the same field names across runs — no HTML parsing or CSS selectors required. Pass it directly to an LLM prompt, index it into a vector store, or wire it into an agent tool.

#### What happens when Yelp changes its layout or anti-bot system?

The Actor's GraphQL `documentId` signatures are re-extracted live from Yelp's own network traffic on every run, so routine signature rotations are handled automatically; DOM-read fields (amenities, about, Q\&A, highlights) are anchored on heading text rather than hashed class names to reduce breakage when Yelp restyles a page.

#### Can I use Ultimate Yelp Scraper without managing proxies or browser infrastructure?

Yes. It runs headless on Apify's infrastructure and handles the stealth browser bootstrap and proxy tier escalation (no proxy → datacenter → residential) automatically; you only need to touch `proxyConfiguration` if you want to force a specific tier yourself.

#### Which Yelp business fields work best for AI training data and RAG indexing?

For RAG, index `about`, `reviews[].review`, and `questions[].question` — the highest-information free text fields. For structured training data, `rating`, `reviewCount`, `priceRange`, and `categories` are the most consistently populated fields across records, and all fields return as typed strings, numbers, booleans, or arrays.

### Related scrapers

| Scraper Name | What it extracts |
| --- | --- |
| [Shopify Store Leads Scraper](https://apify.com/scraper-engine/shopify-store-leads-scraper-emails-phones-ratings) | Shopify store emails, phone numbers, addresses, and ratings |
| [Zillow Property Details Scraper](https://apify.com/scraper-engine/zillow-property-details-scraper) | Property price, Zestimate, tax history, schools, and photos |
| [Y Combinator Scraper](https://apify.com/scraper-engine/y-combinator-scraper) | Companies, founders, and open jobs from the YC directory |
| [Website Content Crawler](https://apify.com/scraper-engine/website-content-crawler) | Clean text, Markdown, HTML, and metadata from any website |

### Your feedback

Found a bug or missing a field in Ultimate Yelp Scraper? Let us know at dev.scraperengine@gmail.com so we can fix it — active issue reports directly shape what gets prioritized in the next update.

# Actor input Schema

## `startUrls` (type: `array`):

🌐 One or more Yelp URLs — bulk-friendly, one per line or upload a file. Mix and match freely: 🏪 direct business pages (<code>/biz/...</code>), 🔍 search/listing pages (<code>/search?...</code>), 🗂️ collections (<code>/collection/...</code>), and 🎫 events (<code>/events/...</code>). When this is non-empty it takes priority over <b>🔎 Search by Keyword</b> below.

## `search` (type: `string`):

💡 What to search for on Yelp, e.g. <code>restaurants</code>, <code>plumber</code>, <code>max</code>. Used only when <b>🔗 Start URLs</b> above is empty.

## `searchLocation` (type: `string`):

🏙️ City/state (or ZIP) to search in, e.g. <code>Los Angeles, CA</code>. Used together with 🔎 Search Keyword.

## `maxItems` (type: `integer`):

✂️ Stop after this many businesses/collections/events, combined across every Start URL / search. Leave empty for no limit (careful with big searches!).

## `endPage` (type: `integer`):

🔢 How many search-result pages to paginate through (10 businesses/page) before stopping. Leave empty to keep paging until 🎯 Maximum Results is hit or results run out.

## `deepDetail` (type: `boolean`):

🕵️ When ON, the Actor navigates to each business page and reads the rendered DOM to also capture 🎪 amenities, 📖 about/history, ❓ Q\&A, ✨ highlights, ✅ claimed status and 📅 year established — richer data, but sequential (slower). Turn OFF for a fast, fully concurrent run that returns everything available from Yelp's GraphQL API alone.

## `includeReviews` (type: `boolean`):

💬 Paginate and collect the full review feed for every business (author, rating, text, date, reactions). When OFF, only the first page of reviews that ships with the business detail is kept.

## `reviewSort` (type: `string`):

📊 Order reviews are fetched in.

## `startPageForReviews` (type: `integer`):

🔢 Skip ahead to this review page (10 reviews/page) instead of starting from page 1.

## `endPageForReviews` (type: `integer`):

🔢 Stop after this review page. Leave empty to fetch every available review — can be slow for businesses with thousands of reviews.

## `includePhotos` (type: `boolean`):

🖼️ Collect original-resolution photo URLs for every business.

## `endPageForPhotos` (type: `integer`):

📄 Limit how many photo pages (~30 photos/page) to collect. Leave empty to collect every available photo.

## `includeAmenities` (type: `boolean`):

🏷️ Extract amenities/attributes (parking, Wi-Fi, accepted payments, accessibility, etc). Best-effort — most reliable with 🔬 Deep Detail Mode ON.

## `proxyConfiguration` (type: `object`):

🌐 By default the Actor connects with <b>NO proxy</b> for maximum speed. If Yelp's DataDome challenge rejects a bootstrap attempt, it automatically escalates: ⚡ No proxy → 🏢 Datacenter proxy → 🏠 Residential proxy (retried at least 3×) — then <b>sticks with Residential for every remaining request</b> in the run. Every escalation is logged clearly in real time. You can also force a specific tier yourself here (e.g. start straight on Residential for the toughest targets).

## `concurrency` (type: `integer`):

🚦 How many businesses to process in parallel on the shared warmed browser session (used only when 🔬 Deep Detail Mode is OFF — Deep Detail Mode is always sequential, one page at a time). Higher is faster but heavier.

## `maxRetries` (type: `integer`):

🔄 How many times to retry a single GraphQL/API call on a network error or transient block before giving up on it.

## `maxBootstrapAttempts` (type: `integer`):

🎰 How many fresh browser/IP attempts to make while trying to pass Yelp's DataDome challenge before giving up the whole run. Each attempt may also trigger a 🛡️ proxy tier escalation (see above).

## `reloadsPerAttempt` (type: `integer`):

♻️ How many times to reload the SAME page (same IP) before rotating to a fresh browser attempt.

## Actor input object example

```json
{
  "startUrls": [
    "https://www.yelp.com/biz/maxs-restaurant-glendale-glendale-3"
  ],
  "search": "restaurants",
  "searchLocation": "Los Angeles, CA",
  "maxItems": 10,
  "deepDetail": true,
  "includeReviews": true,
  "reviewSort": "relevance_desc",
  "includePhotos": true,
  "includeAmenities": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  },
  "concurrency": 5,
  "maxRetries": 3,
  "maxBootstrapAttempts": 12,
  "reloadsPerAttempt": 3
}
```

# Actor output Schema

## `overview` (type: `string`):

Identity, rating, price and contact info for every scraped business.

## `locationHours` (type: `string`):

Address, map coordinates and operating hours for every scraped business.

## `reviews` (type: `string`):

Full review feed collected per business (author, rating, text, date, reactions).

## `amenitiesAbout` (type: `string`):

Amenities/attributes, about text, Q\&A and highlights.

## `media` (type: `string`):

Original-resolution photo URLs collected per business.

## `collectionsEvents` (type: `string`):

Records scraped from Yelp Collection and Event pages.

## `fullRecord` (type: `string`):

Every field, unfiltered, exactly as pushed to the dataset.

## `csv` (type: `string`):

The full result set as a CSV file.

# 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 = {
    "startUrls": [
        "https://www.yelp.com/biz/maxs-restaurant-glendale-glendale-3"
    ],
    "search": "restaurants",
    "searchLocation": "Los Angeles, CA",
    "maxItems": 10,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraper-engine/ultimate-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 = {
    "startUrls": ["https://www.yelp.com/biz/maxs-restaurant-glendale-glendale-3"],
    "search": "restaurants",
    "searchLocation": "Los Angeles, CA",
    "maxItems": 10,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("scraper-engine/ultimate-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 '{
  "startUrls": [
    "https://www.yelp.com/biz/maxs-restaurant-glendale-glendale-3"
  ],
  "search": "restaurants",
  "searchLocation": "Los Angeles, CA",
  "maxItems": 10,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call scraper-engine/ultimate-yelp-scraper --silent --output-dataset

```

## MCP server setup

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