# Yelp Scraper (`happitap/yelp-scraper`) Actor

This Actor extracts comprehensive business data from Yelp, including business names, ratings, review counts, addresses, phone numbers, websites, and more. Perfect for lead generation, market research, competitive analysis, and business intelligence.

- **URL**: https://apify.com/happitap/yelp-scraper.md
- **Developed by:** [HappiTap](https://apify.com/happitap) (community)
- **Categories:** Lead generation, Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## 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 Scraper

**Scrape Yelp businesses, ratings, reviews, and contact information from [Yelp.com](https://www.yelp.com) search results and business pages.**

This Actor extracts comprehensive business data from Yelp, including business names, ratings, review counts, addresses, phone numbers, websites, and more. Perfect for lead generation, market research, competitive analysis, and business intelligence.

### What can Yelp Scraper do?

- ✅ **Search by keywords** - Find businesses by type (restaurants, dentists, hotels, etc.)
- ✅ **Search by location** - Target specific cities or areas
- ✅ **Extract business details** - Get complete business information from detail pages
- ✅ **Contact information** - Phone numbers and websites
- ✅ **Ratings and reviews** - Star ratings and review counts
- ✅ **Export formats** - JSON, CSV, Excel, HTML
- ✅ **Integrations** - API, webhooks, Make, Zapier
- ✅ **No coding required** - Simple interface

### Why scrape Yelp?

Yelp contains valuable data for:

- 🎯 **Lead generation** - Find potential customers and business contacts
- 📊 **Market research** - Analyze competitors and market trends
- 📍 **Location intelligence** - Understand local business landscapes
- 💼 **Sales prospecting** - Build targeted contact lists
- 🔍 **Business discovery** - Find services and businesses in specific areas

### What data can you extract from Yelp?

| Data Field | Description | Example |
|------------|-------------|---------|
| **businessName** | Name of the business | "Joe's Pizza" |
| **rating** | Star rating (1-5) | 4.5 |
| **reviewCount** | Number of reviews | 127 |
| **address** | Business address | "123 Main St, New York, NY 10001" |
| **phoneNumber** | Contact phone number | "(555) 123-4567" |
| **website** | Business website URL | "https://joespizza.com" |
| **url** | Yelp business page URL | "https://www.yelp.com/biz/joes-pizza-new-york" |
| **scrapedAt** | Timestamp of extraction | "2024-01-15T10:30:00.000Z" |

### How to scrape Yelp data

1. **Click "Try for free"** to start
2. **Enter your input** - Add search terms (e.g., "restaurants", "dentists") and/or locations (e.g., "New York, NY")
3. **Configure options** - Set max items, concurrency, and other settings
4. **Start the scraper** - Click Start and wait for results
5. **Download results** - Export as JSON, CSV, Excel, or view in the dataset

### Input

The Actor accepts multiple input methods. Click the **Input** tab for all options.

Key settings:
- **Search Terms** - Business types or keywords to search for
- **Locations** - Cities or locations to search in
- **Start URLs** - Direct Yelp URLs (search pages or business detail pages)
- **Max Items** - Maximum number of businesses to extract (default: 50)
- **Max Concurrency** - Number of pages to process simultaneously (default: 5)

#### Example Input

```json
{
  "searchTerms": ["restaurants", "pizza"],
  "locations": ["New York, NY", "San Francisco, CA"],
  "maxItems": 100,
  "maxConcurrency": 10
}
````

### Output

You can download data in multiple formats:

- **JSON** - For developers and APIs
- **CSV** - For Excel and spreadsheet tools
- **Excel** - Ready-to-use spreadsheet format

#### Output example

```json
{
  "businessName": "Joe's Pizza",
  "rating": 4.5,
  "reviewCount": 127,
  "address": "123 Main St, New York, NY 10001",
  "phoneNumber": "(555) 123-4567",
  "website": "https://joespizza.com",
  "url": "https://www.yelp.com/biz/joes-pizza-new-york",
  "scrapedAt": "2024-01-15T10:30:00.000Z"
}
```

### How much does it cost to scrape Yelp?

**Free tier**: $5 in credits = ~1,800-2,000 businesses

**Cost estimates**:

- Basic scraping: ~350-400 businesses per $1
- With detailed data: ~350-400 businesses per $1

**Pricing breakdown**:

- **Actor start**: $0.00005 (includes 5 seconds free compute)
- **Per business**: $0.0028 per item extracted

**Tips to reduce costs**:

- Limit max items to what you need
- Use specific search terms to avoid unnecessary pages
- Disable unnecessary features if available

### Is it legal to scrape Yelp?

Yes, scraping publicly available data is legal. This Actor only extracts public information that is visible to anyone visiting Yelp.com.

**Best practices**:

- Use ethically and responsibly
- Respect rate limits (built into the Actor)
- Review Yelp's Terms of Service
- Don't use data for spam or harassment

### Troubleshooting

#### No results found

- **Check search terms** - Make sure your search terms are valid
- **Verify locations** - Ensure location names are spelled correctly
- **Try direct URLs** - Use specific Yelp business URLs as start URLs
- **Increase max items** - Your limit might be too low

#### Missing data fields

- **Yelp structure changes** - Yelp occasionally updates their website structure
- **Try again later** - Some pages may load differently
- **Check individual pages** - Some businesses may not have all information available

#### Slow scraping

- **Reduce concurrency** - Lower max concurrency if getting blocked
- **Use proxies** - Enable Apify Proxy for better success rates
- **Check network** - Ensure stable internet connection

### Use cases

#### Lead Generation

Find potential customers by searching for businesses in your target market. Extract contact information to build your sales pipeline.

#### Market Research

Analyze competitors in specific locations. Compare ratings, review counts, and business information to understand market positioning.

#### Business Intelligence

Track business listings, ratings, and contact information over time. Monitor changes in your industry or target markets.

#### Location Analysis

Understand the business landscape in specific areas. Identify trends, popular business types, and market saturation.

### Yelp API alternative

This scraper provides advantages over Yelp's official API:

- ✅ **Unlimited results** vs API rate limits
- ✅ **Cost-effective** vs expensive API pricing
- ✅ **Complete data** vs limited fields in API
- ✅ **No API key required** vs registration and approval process
- ✅ **Flexible search** vs API restrictions

### Integrations

Connect with 1000+ apps:

- **Google Sheets** - Auto-update spreadsheets with Yelp data
- **Slack** - Get notifications when scraping completes
- **Webhooks** - Send data to your applications automatically
- **API** - Programmatic access to run and retrieve results
- **Make (Integromat)** - Automate workflows with Yelp data
- **Zapier** - Connect Yelp scraping to your favorite apps

### Support and feedback

- 📧 **Issues?** Use the Issues tab in the Actor page
- 💬 **Questions?** Check the troubleshooting section above
- 🔧 **Custom solution?** Contact us for enterprise needs
- ⭐ **Like it?** Leave a review and rating

### Related Actors

- **Google Maps Scraper** - Extract business data from Google Maps
- **TripAdvisor Scraper** - Scrape reviews and ratings from TripAdvisor
- **Foursquare Scraper** - Get venue data from Foursquare

***

**License**: Apache-2.0 | **Version**: 1.0.0

# Actor input Schema

## `searchTerms` (type: `array`):

Business types or keywords to search for (e.g., 'restaurants', 'dentists', 'hotels')

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

Cities or locations to search in (e.g., 'New York, NY', 'San Francisco, CA')

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

Direct Yelp URLs to scrape (search pages or business detail pages)

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

Maximum number of businesses to extract

## `maxReviews` (type: `integer`):

Maximum number of reviews to extract per business

## `maxImages` (type: `integer`):

Maximum number of images to extract per business

## `maxConcurrency` (type: `integer`):

Maximum number of pages to process simultaneously (lower values reduce detection risk, recommended: 1-2)

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

Proxy settings for requests (residential proxies recommended for better success rates)

## Actor input object example

```json
{
  "searchTerms": [],
  "locations": [],
  "startUrls": [
    {
      "url": "https://www.yelp.com/search?find_desc=restaurants&find_loc=New+York%2C+NY"
    }
  ],
  "maxItems": 50,
  "maxReviews": 10,
  "maxImages": 10,
  "maxConcurrency": 1,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

Dataset containing scraped Yelp business information

# 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 = {
    "searchTerms": [],
    "locations": [],
    "startUrls": [
        {
            "url": "https://www.yelp.com/search?find_desc=restaurants&find_loc=New+York%2C+NY"
        }
    ],
    "maxItems": 50,
    "maxReviews": 10,
    "maxImages": 10,
    "maxConcurrency": 1
};

// Run the Actor and wait for it to finish
const run = await client.actor("happitap/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 = {
    "searchTerms": [],
    "locations": [],
    "startUrls": [{ "url": "https://www.yelp.com/search?find_desc=restaurants&find_loc=New+York%2C+NY" }],
    "maxItems": 50,
    "maxReviews": 10,
    "maxImages": 10,
    "maxConcurrency": 1,
}

# Run the Actor and wait for it to finish
run = client.actor("happitap/yelp-scraper").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 '{
  "searchTerms": [],
  "locations": [],
  "startUrls": [
    {
      "url": "https://www.yelp.com/search?find_desc=restaurants&find_loc=New+York%2C+NY"
    }
  ],
  "maxItems": 50,
  "maxReviews": 10,
  "maxImages": 10,
  "maxConcurrency": 1
}' |
apify call happitap/yelp-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Yelp Scraper",
        "description": "This Actor extracts comprehensive business data from Yelp, including business names, ratings, review counts, addresses, phone numbers, websites, and more. Perfect for lead generation, market research, competitive analysis, and business intelligence.",
        "version": "0.0",
        "x-build-id": "m41rniXHp00YqDJ1a"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/happitap~yelp-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-happitap-yelp-scraper",
                "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/happitap~yelp-scraper/runs": {
            "post": {
                "operationId": "runs-sync-happitap-yelp-scraper",
                "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/happitap~yelp-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-happitap-yelp-scraper",
                "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",
                "properties": {
                    "searchTerms": {
                        "title": "Search Terms",
                        "type": "array",
                        "description": "Business types or keywords to search for (e.g., 'restaurants', 'dentists', 'hotels')",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "locations": {
                        "title": "Locations",
                        "type": "array",
                        "description": "Cities or locations to search in (e.g., 'New York, NY', 'San Francisco, CA')",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Direct Yelp URLs to scrape (search pages or business detail pages)",
                        "default": [],
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of businesses to extract",
                        "default": 50
                    },
                    "maxReviews": {
                        "title": "Max Reviews per Business",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of reviews to extract per business",
                        "default": 10
                    },
                    "maxImages": {
                        "title": "Max Images per Business",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of images to extract per business",
                        "default": 10
                    },
                    "maxConcurrency": {
                        "title": "Max Concurrency",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Maximum number of pages to process simultaneously (lower values reduce detection risk, recommended: 1-2)",
                        "default": 1
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings for requests (residential proxies recommended for better success rates)",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
