# Yelp Scraper Alternative - Local Leads + Verified Emails (`flash_scraper/yelp-leads-scraper`) Actor

No-API-key alternative to a Yelp scraper. Turn any business category + city into local business leads via OpenStreetMap: emails pulled from each website & MX-verified, plus phone, address, socials, a 0-100 lead score (A-F) and optional AI cold openers. Export CSV/JSON/Excel.

- **URL**: https://apify.com/flash\_scraper/yelp-leads-scraper.md
- **Developed by:** [Flash Scrape](https://apify.com/flash_scraper) (community)
- **Categories:** Lead generation, Travel, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 business leads

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#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 Email Scraper - Business Leads, Phone & Reviews

**Yelp email scraper** that turns any Yelp category + location into a contactable list of **local business leads** — complete with emails, phones, websites, ratings, and reviews. Search something like *"dentists in Austin, TX"* and get back a clean, scored, ready-to-contact spreadsheet of businesses, not a raw listing dump.

Unlike Yelp itself (which almost never shows an email), this **Yelp scraper** visits each business's own website to find the real email address — so the leads you export are actually reachable. Built for cold outreach, agencies, B2B sales prospecting, and anyone building a local-business lead list.

***

### How to get local business leads

You don't need an API key, a Yelp login, or any code. Three steps:

1. Enter one or more **search terms** (e.g. `coffee shops`, `plumbers`, `med spas`).
2. Enter one or more **locations** (e.g. `Austin, TX`, `Miami, FL`). Every term is searched in every location.
3. Set your filters and `maxItems`, then run.

The actor finds matching local businesses via OpenStreetMap, visits each business website to enrich emails and social links, removes duplicates, scores every lead 0–100, and pushes a clean dataset you can export to CSV, JSON, or Excel — best leads first.

- **Find local business emails** — visits each website's home / contact / about pages to pull the real email.
- **Get phone, website & address for every business** — the core contact fields you need to reach out.
- **Filter to contactable leads** — keep only businesses with a website or a verified email.
- **Export only contactable leads** — drop businesses with no website or no email so you don't pay for dead rows.
- **Rank leads automatically** — a 0–100 lead score sorts the best prospects to the top.
- **Write AI cold-email openers** — an optional one-line personalized icebreaker per lead.

***

### What data you get

One row per business, scored and sorted best-first. Field names below match the dataset schema exactly.

| Field | Description |
|---|---|
| `lead_score` | 0–100 score from verified email deliverability + phone + website + socials. |
| `name` | Business name. |
| `category` | Business category (e.g. `cafe`). |
| `phone` | Business phone number. |
| `email` | Best email found (MX-verified when verification is on). |
| `email_status` | `deliverable`, `risky`, `undeliverable`, or `none` — MX + role + disposable check. |
| `email_provider` | Mailbox host (e.g. Google Workspace, Microsoft 365) when known. |
| `website` | Business website URL. |
| `address` | Full street address. |
| `city` | City. |
| `rating` / `reviews` | Always `null` — OpenStreetMap carries no rating/review data (kept for schema stability). |
| `icebreaker` | Optional AI-written cold-email opener. |
| `source_url` | Link back to the OpenStreetMap listing this lead came from. |

#### JSON output sample

```json
{
  "lead_score": 85,
  "name": "Joe's Coffee House",
  "category": "cafe",
  "phone": "+1 512-555-0199",
  "email": "hello@joescoffee.com",
  "email_status": "deliverable",
  "email_provider": "Google Workspace",
  "website": "https://joescoffee.com",
  "address": "123 Congress Ave, Austin, TX 78701",
  "city": "Austin",
  "rating": null,
  "reviews": null,
  "icebreaker": "Loved that your cold brew spot anchors Congress Ave in Austin…",
  "source_url": "https://www.openstreetmap.org/node/1234567890"
}
```

Results also render as a sortable table on the Output tab and export to CSV / JSON / Excel.

***

### Filters & options (input)

Provide search terms + locations, then tune what gets delivered. You're only charged for leads that survive your filters.

| Field | What it does |
|---|---|
| `searchTerms` | Categories / keywords to scrape, one per line — e.g. `plumbers`, `dentists`. |
| `locations` | Cities / areas, one per line — e.g. `Denver, CO`. Each term is searched in each location. |
| `maxItems` | Max businesses to scrape across all searches (default 50). |
| `minRating` | *Accepted for compatibility but **not applied** — the OpenStreetMap source exposes no ratings.* |
| `minReviews` | *Accepted for compatibility but **not applied** — the OpenStreetMap source exposes no review counts.* |
| `onlyWithWebsite` | Drop businesses with no website. |
| `onlyWithEmail` | Drop businesses where no email was found — best for cold email. |
| `enrichEmails` | Visit each business website to extract emails + socials (default on, no key needed). |
| `writeOpeners` | Add an AI cold-opener per lead — needs your own AI key. |
| `llmProvider` / `llmApiKey` / `llmModel` | Pick OpenAI or Anthropic and supply your key for the openers. |

Example input:

```json
{
  "searchTerms": ["restaurants", "coffee shops"],
  "locations": ["Austin, TX", "Portland, OR"],
  "maxItems": 50,
  "onlyWithWebsite": true,
  "onlyWithEmail": true,
  "enrichEmails": true,
  "writeOpeners": false
}
```

***

### Use with AI agents & automation

This **Yelp lead scraper** plugs straight into your stack. Call it from the Apify **MCP** server so AI agents (Claude, ChatGPT, Cursor) can pull leads on demand, or wire the dataset into **Make**, **n8n**, or **Zapier** to push new leads into your CRM the moment a run finishes. Sync the output to **Google Sheets** for a live, shareable lead list — no engineering required.

***

### Pricing

Pay per result on top of Apify platform usage — you're only charged for leads delivered **after** filtering, so tightening `onlyWithWebsite` or `onlyWithEmail` directly lowers your cost. The optional AI openers run on **your own** OpenAI/Anthropic key, billed by that provider. See the actor's pricing tab for current rates.

***

### Other Flash Scrape scrapers

Building leads from more than one source? The rest of the suite shares the same clean, scored output format:

- [Google Maps Leads Opener](https://apify.com/flash_scraper/google-maps-leads-opener) — Google Maps business leads
- [BBB + Yellow Pages Leads Scraper](https://apify.com/flash_scraper/bbb-yellowpages-leads-scraper) — BBB + Yellow Pages leads
- [Instagram Leads Scraper](https://apify.com/flash_scraper/instagram-leads-scraper) — Instagram profile leads
- [TikTok Leads Scraper](https://apify.com/flash_scraper/tiktok-leads-scraper) — TikTok creator leads
- [YouTube Leads Scraper](https://apify.com/flash_scraper/youtube-leads-scraper) — YouTube creator leads
- [Smart Scraper by Example](https://apify.com/flash_scraper/smart-scraper-by-example) — no-code web scraper

***

### FAQ

**Is this data legal to use?**
This actor collects **public** business listing data — the same information any visitor can see. That's generally fine for legitimate prospecting, but you're responsible for how you use it: follow Yelp's terms and anti-spam laws like CAN-SPAM and GDPR in any outreach you send.

**Do I need an API key?**
No. The Yelp scraping and email enrichment work without any key. The only place a key is needed is the optional AI cold-openers, where you supply your own OpenAI or Anthropic key — it's used once per run and never stored.

**Will every business have an email?**
No. Yelp itself rarely lists an email, so emails are pulled from each business's own website. Businesses with no site, or no email on it, show `email_status: missing`. Turn on `onlyWithEmail` to keep just the contactable leads.

**How many results can I get?**
Set `maxItems` up to 1000 businesses per run across all your search terms and locations. Add more terms or locations and run again to scale further.

**Can I export to CSV / Google Sheets?**
Yes. Every run exports to CSV, JSON, or Excel from the dataset, and you can sync results to Google Sheets automatically via Make, n8n, Zapier, or the Apify API.

**Can I scrape multiple cities at once?**
Yes. Add several locations and several search terms — each term is searched in each location, then deduped into a single scored list.

# Actor input Schema

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

Business categories / keywords to scrape — one per line. e.g. 'coffee shops', 'dentists', 'plumbers'.

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

Cities / areas to search in — one per line. e.g. 'Austin, TX', 'Miami, FL'. Each search term is searched in each location.

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

Maximum number of local businesses to scrape across all search terms.

## `minRating` (type: `integer`):

Keep only businesses with at least this star rating, 1-5 (0 = no filter). — NOTE: not applied; the OpenStreetMap source carries no rating/review data.

## `minReviews` (type: `integer`):

Keep only businesses with at least this many reviews (0 = no filter). A proxy for established, real businesses. — NOTE: not applied; the OpenStreetMap source carries no rating/review data.

## `onlyWithWebsite` (type: `boolean`):

Drop businesses with no website (you can't enrich an email without one).

## `onlyWithEmail` (type: `boolean`):

Drop businesses where no email could be found. Best for cold-email campaigns.

## `onlyVerifiedEmail` (type: `boolean`):

Drop leads whose email fails deliverability verification. Keeps only addresses on a domain with real mail servers (MX) — protects your sender reputation. Requires 'Verify email deliverability' on.

## `enrichEmails` (type: `boolean`):

Visit each business website (home + /contact + /about) to extract emails and social links. Higher email fill-rate. No key needed.

## `verifyEmails` (type: `boolean`):

Check every email's domain for real mail servers (MX) and flag role (info@, sales@) and disposable addresses. Each lead gets an email\_status of deliverable / risky / undeliverable and, where known, the mailbox provider. No key needed — protects your cold-email sender reputation.

## `writeOpeners` (type: `boolean`):

Generate a personalized one-sentence outreach opener for each lead. Requires your OpenAI/Anthropic key below.

## `llmProvider` (type: `string`):

AI provider used to write the cold openers — OpenAI (GPT) or Anthropic (Claude). Use the provider that matches the LLM API key you supply.

## `llmApiKey` (type: `string`):

Your own OpenAI or Anthropic API key. Used only to write the openers; never stored.

## `llmModel` (type: `string`):

Override the default model (gpt-4o-mini for OpenAI, claude-haiku-4-5-20251001 for Anthropic).

## `minScore` (type: `integer`):

Keep only leads scoring at or above this value, 0-100 (0 = no filter). Pay only for your best A/B leads.

## Actor input object example

```json
{
  "searchTerms": [
    "dentists",
    "med spas"
  ],
  "locations": [
    "Miami, FL",
    "New York, NY"
  ],
  "maxItems": 50,
  "minRating": 0,
  "minReviews": 0,
  "onlyWithWebsite": false,
  "onlyWithEmail": false,
  "onlyVerifiedEmail": false,
  "enrichEmails": true,
  "verifyEmails": true,
  "writeOpeners": false,
  "llmProvider": "openai",
  "minScore": 0
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "searchTerms": [
        "dentists"
    ],
    "locations": [
        "Austin, TX"
    ]
};

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

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

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/fQ8iA8Oun7X9DtbDM/builds/oN4T136sioP5FB8Ot/openapi.json