# YellowPages US Scraper - $2.5/1K - Leads with Address & Website (`mamies/yellowpages-us-scraper`) Actor

Scrape US business listings from YellowPages.com by category and city. Returns name, phone, split street/city/state/ZIP, website, categories, star rating, review count, and years in business, etc — one clean record per business. Pay only per business delivered.

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

## Pricing

from $2.50 / 1,000 business 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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## YellowPages US Scraper — Business Leads with Full Address & Website 📇

**Turn any US business category into a clean lead list.** Pick a category and a city — "dentists in New York, NY", "plumbers in Chicago, IL" — and get one structured record per business, with phone, full mailing address, website, ratings, and categories.

**Pay only per business delivered.** No subscriptions, no per-page fees.

---

### 🚀 Why this scraper?

- ✅ **Address split into real columns** — `street`, `city`, `state`, and `zip` as separate fields, not one jammed-together string. Import straight into a CRM, filter by territory, or run a mail merge without cleanup.
- ✅ **Website URLs included** — the business's own site, ready to enrich further
- ✅ **Ratings & reviews** — star rating and review count for every listing that has them
- ✅ **Years in business** — a strong quality signal when you're qualifying leads
- ✅ **Never pay twice for the same business** — every record is de-duplicated across the whole run
- ✅ **Ads clearly flagged** — sponsored listings are marked `is_ad` so you can keep or drop them
- ✅ **No empty rows** — listings with no phone, address *or* website are dropped before you're charged, so you never pay for a lead you can't contact
- ✅ **Emails & social profiles** — optional paid add-on that pulls email addresses, social media profiles, and contact pages from each business's own website
- ✅ **Clean export** — JSON, CSV, Excel, XML, or HTML

**Pairs perfectly with our [Website Contact Scraper](https://apify.com/mamies/website-contact-scraper):** already have a domain list? Feed it straight in there instead.

---

### 📊 Output example

One record per business:

```json
{
  "name": "Hanson Place Dental",
  "phone": "(718) 403-0447",
  "full_address": "177 Livingston St, Brooklyn, NY 11201",
  "street": "177 Livingston St",
  "city": "Brooklyn",
  "state": "NY",
  "zip": "11201",
  "website": "https://downtownbrooklyn-dental.com",
  "categories": [
    "Dentists",
    "Implant Dentistry",
    "Oral & Maxillofacial Surgery"
  ],
  "star_rating": 4.5,
  "review_count": 45,
  "years_in_business": 49,
  "snippet": "I had the best experience had a crown and bridge done with no pain... awesome... thank you Doctor and staff\"",
  "yp_url": "https://www.yellowpages.com/brooklyn-ny/mip/hanson-place-dental-394137",
  "image": "https://i3.ypcdn.com/blob/c43fcadbe2f3e3207541a2ec88594676684c57bc_130x130_crop.jpg?8db9d441e",
  "is_ad": false
}
````

With contact enrichment enabled, each record also carries `emails`, all 10 social platform fields, and `contact_page`:

```json
{
  "name": "David A Nusblatt",
  "phone": "(833) 219-5360",
  "full_address": "10 E 40th St, New York, NY 10016",
  "website": "http://www.nusblattdental.com",
  "emails": ["adam.nusblatt@gmail.com"],
  "facebook": null,
  "instagram": null,
  "linkedin": null,
  "contact_page": "https://www.nusblattdental.com/contactus",
  "star_rating": 5,
  "review_count": 1
}
```

*Trimmed for readability — every record carries all the fields listed below, and contact-enriched records always include all 10 social platform fields (`facebook`, `instagram`, `linkedin`, `twitter`, `youtube`, `tiktok`, `pinterest`, `github`, `telegram`, `whatsapp`); platforms the business doesn't have come back as `null`.*

Every field is returned on every record — a business that doesn't publish something gets `null` (or `[]`) rather than a missing key, so your columns stay stable across runs.

***

### 📊 Data fields extracted

| Field | Description |
|---|---|
| **name** | Business name |
| **phone** | Phone number, as displayed — e.g. `(718) 403-0447` |
| **full\_address** | Street, city, state and ZIP joined into one line |
| **street** / **city** / **state** / **zip** | The same address as four separate columns |
| **website** | The business's own site. Listing links that aren't a real website come back as `null` rather than a misleading URL. |
| **categories** | Every category the business is listed under |
| **star\_rating** | Average star rating, `1`–`5` in half steps |
| **review\_count** | Number of reviews behind that rating |
| **years\_in\_business** | Years trading, where published |
| **snippet** | A short review excerpt or business blurb |
| **yp\_url** | The listing this record came from |
| **image** | Listing thumbnail; some listings use a generic placeholder |
| **is\_ad** | `true` for sponsored placements |
| **emails** | Contact emails found on the business website *(when contact enrichment is enabled)* |
| **facebook** … **whatsapp** | Social profile links — Facebook, Instagram, LinkedIn, Twitter/X, YouTube, TikTok, Pinterest, GitHub, Telegram, WhatsApp *(when contact enrichment is enabled)* |
| **contact\_page** | URL of the website's contact page *(when contact enrichment is enabled)* |

> **About emails & socials:** Contacts are extracted by visiting each business's website, so they're available **only for businesses that have a website** — about 9 in 10 YellowPages listings. Even then, not every site publishes an email; many use a contact form only. Across two 300-result test runs, **27–31%** of businesses yielded at least one email, so expect contacts on a meaningful share of results, not all of them. Enable **Find email addresses & social profiles** in the input to turn this on.

Download the full dataset as JSON, CSV, Excel, XML, or HTML from the Output tab.

***

### ⬇️ Input

Three fields — **fill them in and run.** No configuration, no proxy setup, nothing to tune.

| Parameter | Required | Description |
|---|---|---|
| **searchTerm** | Yes | The business category, as you'd type it on the site — `dentists`, `plumbers`, `roofing contractors` |
| **location** | Yes | A US city **and state** — `New York, NY` or `Chicago, Illinois`. The state is required. |
| **maxResults** | No | How many businesses to return (default `10`). Listings run deep, so this is what ends the run — raise it as high as you need. |
| **extractEmails** | No | **Paid add-on.** Visit each business website to extract contact emails, social profiles, and the contact page (adds the `emails`, social, and `contact_page` fields). Every result in the run is charged at the higher add-on rate. |

**Tip:** Start with a small **maxResults** to preview the data for a category, then raise it once you're happy with what comes back.

***

### 🎯 Use cases

- **Local lead generation** — build a targeted prospect list for any trade in any US city
- **Territory planning** — filter by ZIP or city to carve up sales regions
- **Market research** — size up how many competitors operate in a given area, and how they're rated
- **CRM enrichment** — fill in phone, address, and website for businesses you already track
- **Directory building** — assemble niche listings for a site or newsletter

***

### ❓ FAQ

**How is this billed?**
You pay a flat rate per business delivered. Runs with **Find email addresses & social profiles** switched on are charged at a higher rate — applied to every result in the run, whether or not that particular business turned out to publish an email. Duplicates are removed before billing, so the same business is never charged twice in a run. You can set a maximum spend per run — when it's reached, the run finishes cleanly and you keep everything scraped up to that point.

**How many results can I get?**
Listings for a popular category in a large city run into the thousands. Set `maxResults` to whatever you need. Smaller cities and narrower categories will naturally have fewer.

**Why are some fields empty on a few records?**
Not every business publishes everything. On a live test run, name, categories and listing URL came back on 100% of records; phone, full address, website and snippet on 96%; rating and review count on 94%; and years in business on 86%. Listings that publish *no* phone, address or website at all — mostly chain ad placements — are dropped entirely rather than delivered as empty rows, so you're never charged for them.

**Why don't all results have emails?**
Emails come from business websites. Listings without a website, or whose website doesn't publish an email, won't have one. Email coverage naturally varies by area and industry.

**What export formats are supported?**
JSON, CSV, Excel, XML, and HTML — from the Output tab or the Apify API.

**Are duplicates removed?**
Yes. Listings repeat across pages, and the same business can appear more than once in a single run's raw results. Every record is de-duplicated by its listing identity before it reaches you, so you never receive — or pay for — the same business twice. Note that genuinely separate branches of a chain are different businesses and are returned separately.

**Do I need proxies?**
No — proxies are managed automatically.

**Can I automate it?**
Yes — schedule it, chain it with other actors, or connect Make, n8n, Zapier, Google Sheets, and webhooks via Apify integrations.

**Is this legal?**
The actor only reads publicly available business listings — information companies publish about themselves to be found. You are responsible for using the data lawfully (e.g. GDPR, CAN-SPAM) in your outreach.

***

### 💡 Tips

- Proxies are managed automatically — no proxy setup or configuration needed.
- Start small: preview a category with a low **maxResults**, then scale up.
- Contact enrichment costs more per result — use it when you need emails, social profiles, or contact pages.
- Already have a list of domains? Feed it straight into our [Website Contact Scraper](https://apify.com/mamies/website-contact-scraper) instead.

> *Unofficial scraper — not affiliated with, endorsed by, or sponsored by YellowPages or Thryv.*

***

# Actor input Schema

## `searchTerm` (type: `string`):

The business category to search for, exactly as you'd type it on YellowPages — 'dentists', 'plumbers', 'roofing contractors'.

## `location` (type: `string`):

A US city and state: 'New York, NY' or 'Chicago, Illinois'. The state is required — a city on its own can't be resolved.

## `maxResults` (type: `integer`):

How many businesses to return. Results run about 30 per page and go hundreds of pages deep, so this is what ends the run. You're charged per business delivered.

## `extractEmails` (type: `boolean`):

Add-on: when this is on, EVERY result in the run is charged at the higher add-on rate, not just the ones that turn out to have an email. Visits each business's own website to find email addresses, social media profiles, and their contact page; social profiles are included free. Not every business publishes an email — across two 300-result test runs, 27-31% yielded one. Runs also take longer with this on. Leave it off for name, phone, address, website and ratings at the standard rate.

## Actor input object example

```json
{
  "searchTerm": "dentists",
  "location": "New York, NY",
  "maxResults": 10,
  "extractEmails": false
}
```

# Actor output Schema

## `businesses` (type: `string`):

All scraped business records — name, phone, full address split into street/city/state/ZIP, website, categories, star rating, review count, years in business, review snippet, listing URL and image, plus emails + social profiles and the contact page when contact enrichment is enabled. Append ?format=csv or ?format=xlsx to the URL for spreadsheet exports.

# 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 = {
    "searchTerm": "dentists",
    "location": "New York, NY"
};

// Run the Actor and wait for it to finish
const run = await client.actor("mamies/yellowpages-us-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 = {
    "searchTerm": "dentists",
    "location": "New York, NY",
}

# Run the Actor and wait for it to finish
run = client.actor("mamies/yellowpages-us-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 '{
  "searchTerm": "dentists",
  "location": "New York, NY"
}' |
apify call mamies/yellowpages-us-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "YellowPages US Scraper - $2.5/1K - Leads with Address & Website",
        "description": "Scrape US business listings from YellowPages.com by category and city. Returns name, phone, split street/city/state/ZIP, website, categories, star rating, review count, and years in business, etc — one clean record per business. Pay only per business delivered.",
        "version": "0.1",
        "x-build-id": "NhLYgeih7No9UCbuV"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/mamies~yellowpages-us-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-mamies-yellowpages-us-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/mamies~yellowpages-us-scraper/runs": {
            "post": {
                "operationId": "runs-sync-mamies-yellowpages-us-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/mamies~yellowpages-us-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-mamies-yellowpages-us-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",
                "required": [
                    "searchTerm",
                    "location"
                ],
                "properties": {
                    "searchTerm": {
                        "title": "Search term",
                        "type": "string",
                        "description": "The business category to search for, exactly as you'd type it on YellowPages — 'dentists', 'plumbers', 'roofing contractors'."
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "A US city and state: 'New York, NY' or 'Chicago, Illinois'. The state is required — a city on its own can't be resolved."
                    },
                    "maxResults": {
                        "title": "Maximum results",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "How many businesses to return. Results run about 30 per page and go hundreds of pages deep, so this is what ends the run. You're charged per business delivered.",
                        "default": 10
                    },
                    "extractEmails": {
                        "title": "Find email addresses & social profiles — paid add-on",
                        "type": "boolean",
                        "description": "Add-on: when this is on, EVERY result in the run is charged at the higher add-on rate, not just the ones that turn out to have an email. Visits each business's own website to find email addresses, social media profiles, and their contact page; social profiles are included free. Not every business publishes an email — across two 300-result test runs, 27-31% yielded one. Runs also take longer with this on. Leave it off for name, phone, address, website and ratings at the standard rate.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
