# Yelp Business Search via Fusion API - Reliable Local Data (`renzomacar/yelp-fusion-search`) Actor

Reliable Yelp business data via official Yelp Fusion API. No proxies, no anti-bot. Bring your free API key.

- **URL**: https://apify.com/renzomacar/yelp-fusion-search.md
- **Developed by:** [Renzo Madueno](https://apify.com/renzomacar) (community)
- **Categories:** Lead generation, Business, Marketing
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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 Search via Fusion API

### Reliable Yelp Data — Powered by Official API, Zero Anti-Bot Issues

Search Yelp businesses by category and location using the **official Yelp Fusion API**. Returns business names, ratings, locations, phone numbers, categories, price levels, review counts, and (optionally) up to 3 most-recent reviews per business. Because this uses the official API, there's **no scraping, no proxies, no anti-bot challenges, no broken HTML selectors** — 100% reliable, every time.

You provide your **free Yelp Fusion API key** (5,000 calls/day on the free tier) and the actor handles pagination, retries, and clean output.

### What data can you extract?

| Field | Type | Description |
|-------|------|-------------|
| `businessId` | string | Yelp internal business ID |
| `businessAlias` | string | URL-friendly business slug |
| `businessName` | string | Business name |
| `yelpUrl` | string | Direct Yelp page URL |
| `imageUrl` | string | Cover image URL |
| `isClaimed` | boolean | True if the business has been claimed by its owner |
| `isClosed` | boolean | True if Yelp marks it as permanently closed |
| `rating` | number | Average rating (1.0-5.0) |
| `reviewCount` | integer | Total number of reviews |
| `price` | string | Price level (`$`, `$$`, `$$$`, `$$$$`) |
| `phone` | string | Display phone number |
| `categories` | array | Category titles |
| `address` | string | Full street address |
| `city`, `state`, `zipCode`, `country` | string | Location components |
| `latitude`, `longitude` | number | GPS coordinates |
| `distanceMeters` | number | Distance from search center |
| `transactions` | array | Supported transactions (delivery, pickup, restaurant_reservation) |
| `reviews` | array | Up to 3 most-recent reviews (when `includeReviews: true`) |
| `searchTerm` / `searchLocation` | string | Origin search params |
| `scrapedAt` | string | ISO 8601 timestamp |

### How to get a free Yelp Fusion API key

1. Visit **https://docs.developer.yelp.com/**
2. Click **Get Started** → **Sign up** (Google login is fastest)
3. Click **Create New App**
4. Fill in: name, industry, website, contact email — Yelp accepts immediately
5. Yelp emails you the API key (a long alphanumeric string)
6. Paste it into the `yelpApiKey` input field of this actor

**Free tier: 5,000 API calls per day.** Each search call returns up to 50 businesses, so 5,000 calls = 250,000 businesses per day.

### Use cases

- **Cold outreach lead lists** — Build B2B prospect lists by extracting all dentists, lawyers, contractors, or restaurants in any US/UK/CA/AU city.
- **Competitive market analysis** — Map all businesses in a category across cities to size markets and identify gaps.
- **Local SEO research** — Build datasets of competitor ratings, review counts, categories, and price tiers.
- **Restaurant analytics** — Track price level distributions, transaction support (delivery/pickup), and review trends.
- **Real estate / location intelligence** — Enrich addresses with surrounding business density and quality.

### Input parameters

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| `yelpApiKey` | string | Yes | — | Your Yelp Fusion API key |
| `searches` | array | Yes | — | Queries formatted as "category in city, state" |
| `maxResultsPerSearch` | integer | No | 50 | Maximum businesses per search (Yelp limit: 240) |
| `includeReviews` | boolean | No | false | Add up to 3 reviews per business (1 extra API call each) |

### Example output

```json
{
    "businessId": "WavvLdfdP6g8aZTtbBQHTw",
    "businessName": "Joe's Pizza",
    "yelpUrl": "https://www.yelp.com/biz/joes-pizza-new-york",
    "rating": 4.5,
    "reviewCount": 2847,
    "price": "$",
    "phone": "(212) 388-9555",
    "categories": ["Pizza", "Italian"],
    "address": "150 E 14th St, New York, NY 10003",
    "city": "New York", "state": "NY", "zipCode": "10003",
    "latitude": 40.7330, "longitude": -73.9874,
    "transactions": ["pickup"],
    "searchTerm": "pizza", "searchLocation": "Brooklyn, NY",
    "scrapedAt": "2026-04-25T12:00:00.000Z"
}
````

### How much does it cost?

This actor uses a pay-per-result pricing model.

- **$0.001 per business** -- that is $1.00 per 1,000 businesses.
- 50 businesses cost **$0.05**.
- 1,000 businesses cost **$1.00**.

You only pay for what you extract — no monthly fees, no minimum commitments. **Cheapest Yelp data on Apify Store**, because the official API removes all proxy/scraping costs.

### Tips and tricks

- **The free tier is plenty for most use cases.** 5,000 calls/day = 250,000 businesses extracted daily. Most users never hit the limit.
- **Format searches as "category in city, state"** for the most precise results.
- **Disable `includeReviews` if you don't need them.** Reviews double API call usage (one extra call per business).
- **Combine with Google Maps Business Scraper** for cross-platform coverage.

### Found this useful?

If this scraper saved you time, please leave a quick review on the **Reviews** tab above — it really helps small developers compete on the Apify Store. Thanks!

### Related scrapers

- [Google Maps Business Scraper](https://apify.com/renzomacar/google-maps-businesses) — Cross-reference Yelp businesses with Google Maps data.
- [Website Contact Finder](https://apify.com/renzomacar/website-contact-finder) — Extract emails and phones from Yelp business websites.

# Actor input Schema

## `yelpApiKey` (type: `string`):

Your Yelp Fusion API key. Get one free at https://docs.developer.yelp.com/ (5,000 calls/day on the free tier).

## `searches` (type: `array`):

List of search definitions. Each is a 'category in city' string (e.g., 'pizza in Brooklyn, NY').

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

Maximum businesses per search (Yelp Fusion paginates 50 per call; this controls how many calls).

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

Yelp Fusion limits reviews to 3 most-recent per business. Adds 1 API call per business.

## Actor input object example

```json
{
  "searches": [
    "pizza in Brooklyn, NY",
    "dentists in Austin, TX",
    "coffee shops in Seattle, WA"
  ],
  "maxResultsPerSearch": 50,
  "includeReviews": false
}
```

# 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 = {
    "searches": [
        "pizza in Brooklyn, NY",
        "dentists in Austin, TX",
        "coffee shops in Seattle, WA"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("renzomacar/yelp-fusion-search").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 = { "searches": [
        "pizza in Brooklyn, NY",
        "dentists in Austin, TX",
        "coffee shops in Seattle, WA",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("renzomacar/yelp-fusion-search").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "searches": [
    "pizza in Brooklyn, NY",
    "dentists in Austin, TX",
    "coffee shops in Seattle, WA"
  ]
}' |
apify call renzomacar/yelp-fusion-search --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=renzomacar/yelp-fusion-search",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Yelp Business Search via Fusion API - Reliable Local Data",
        "description": "Reliable Yelp business data via official Yelp Fusion API. No proxies, no anti-bot. Bring your free API key.",
        "version": "0.1",
        "x-build-id": "C4jvfbh9xdMbaTbDQ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/renzomacar~yelp-fusion-search/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-renzomacar-yelp-fusion-search",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/renzomacar~yelp-fusion-search/runs": {
            "post": {
                "operationId": "runs-sync-renzomacar-yelp-fusion-search",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/renzomacar~yelp-fusion-search/run-sync": {
            "post": {
                "operationId": "run-sync-renzomacar-yelp-fusion-search",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "yelpApiKey",
                    "searches"
                ],
                "properties": {
                    "yelpApiKey": {
                        "title": "Yelp Fusion API Key",
                        "type": "string",
                        "description": "Your Yelp Fusion API key. Get one free at https://docs.developer.yelp.com/ (5,000 calls/day on the free tier)."
                    },
                    "searches": {
                        "title": "Searches",
                        "type": "array",
                        "description": "List of search definitions. Each is a 'category in city' string (e.g., 'pizza in Brooklyn, NY').",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResultsPerSearch": {
                        "title": "Max results per search",
                        "minimum": 1,
                        "maximum": 240,
                        "type": "integer",
                        "description": "Maximum businesses per search (Yelp Fusion paginates 50 per call; this controls how many calls).",
                        "default": 50
                    },
                    "includeReviews": {
                        "title": "Include up to 3 reviews per business",
                        "type": "boolean",
                        "description": "Yelp Fusion limits reviews to 3 most-recent per business. Adds 1 API call per business.",
                        "default": false
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
