# Yellow Pages Email Scraper (`leads-scraper/yellow-pages-email-scraper`) Actor

Yellow Pages Email Scraper SD - Yellow Pages Email Scraper is a lead generation tool that extracts leads with public contact emails, account names and profile URLs from Yellow Pages results by keyword, location and email domain - Yellow Pages email extractor.

- **URL**: https://apify.com/leads-scraper/yellow-pages-email-scraper.md
- **Developed by:** [Leads Scraper](https://apify.com/leads-scraper) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.49 / 1,000 results

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

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

### Yellow Pages Email Scraper

The Yellow Pages Email Scraper turns the largest consumer directory in the United States into a clean, deduplicated list of business contact emails. It searches publicly indexed Yellow Pages, Yellowbook and Superpages listings through Google and extracts every email it finds on the domains you specify.

If you sell to plumbers, roofers, HVAC firms, dentists, movers or any other local trade, this is the fastest way to assemble a territory list without touching a browser. The Yellow Pages Email Scraper is a keyword-driven business directory scraper, not a bulk export tool, so you control exactly which niche and which city you harvest.

Directory listings exist so customers can call and email the business. That makes Yellow Pages one of the few sources where a published email is genuinely a contact channel the owner intended people to use.

#### What the Yellow Pages Email Scraper does

The Actor builds Google queries with the `site:` operator against `yellowpages.com`, `yellowbook.com` and `superpages.com`. It reads each result block, pulls the business identity out of the title, and applies a domain-filtered regex to the snippet text.

Every match is normalised, deduplicated globally and pushed straight to your Apify dataset. You get a local business email list you can open in Google Sheets or push into a CRM within minutes of the run starting.

The Yellow Pages Email Scraper never logs into Yellow Pages, never uses a Yellow Pages API, and never opens the Yellow Pages website. There is no browser, no JavaScript rendering, no authentication and no cookies - only publicly indexed search results.

Put plainly, the Yellow Pages Email Scraper is a search-driven email extractor that reads what Google already shows the public.

#### Why the Yellow Pages Email Scraper suits local lead generation

Local-services marketing agencies live and die by territory coverage. A single run of the Yellow Pages Email Scraper scoped to one metro and one trade gives you a prospect list that mirrors how homeowners actually find those businesses.

B2B SaaS teams selling booking software, POS systems, payroll or small-commercial insurance face the same problem: the buyer is a two-to-twenty-person company with no LinkedIn presence. Directory data reaches them where public data actually exists.

Franchise development teams use the Yellow Pages Email Scraper in reverse, mapping how many independent operators exist in a market before granting a territory. Market researchers use it to size a vertical city by city.

Because the Yellow Pages Email Scraper is keyword-scoped, the same account can build a plumber list on Monday and a dental list on Tuesday without changing anything but the input.

#### Features of the Yellow Pages Email Scraper

Everything below is implemented in the Yellow Pages Email Scraper today. Nothing in this table is a roadmap item.

| Feature | What it means in practice |
|---|---|
| Google `site:` search over three domains | Covers `yellowpages.com`, `yellowbook.com` and `superpages.com` in one run |
| Query expansion | Base, quoted and `intitle:` variants plus one query per modifier; base queries run first |
| Domain filtering | Only emails ending in your `customDomains` values are kept |
| Global deduplication | An email is emitted once per run, no matter how many queries surfaced it |
| Email normalisation | Understands `name [at] domain [dot] com`, `name (at) domain`, `name @ domain.com`, `domain .com`, zero-width characters and the full-width `＠` |
| Junk filter | Rejects placeholders such as `email@`, `yourname@`, `test@`, `xxx@` and single-character locals |
| Boundary-correct matching | `@gmail.com` never matches inside `@gmail.company` or `@gmail.com.br` |
| Soft-wrap repair | Drops a hit that is only the tail of another email in the same block |
| Structural block parsing | Locates the `<h3>` title then the smallest surrounding block; no reliance on Google CSS class names |
| Whole-page fallback parser | If Google's markup changes the run degrades to "emails without account details", not "no emails" |
| Concurrency control | `asyncio` worker pool with a shared stop signal on `maxEmails` |
| Retries and block detection | Up to 3 attempts per page with exponential backoff, a fresh proxy session per request, and CAPTCHA / "unusual traffic" / consent pages detected and retried |
| Failed-query requeue | Blocked or failed queries are re-queued once at the end of the run |
| Resumable state | Key-value store state keyed by an input hash, saved on `PERSIST_STATE`, `MIGRATING` and `ABORTING` |
| Run summary logging | Pages fetched, blocked pages, retries and emails per page |

#### How the Yellow Pages Email Scraper works

A run of the Yellow Pages Email Scraper follows six steps, start to finish.

1. Read your input: keywords, location, email domains and limits.
2. Build Google queries such as `site:yellowpages.com plumber "@gmail.com" "Tampa"`.
3. Fetch result pages through the Apify GOOGLE_SERP proxy using async `aiohttp` requests.
4. Parse each result block structurally to isolate title, account label and snippet.
5. Extract and normalise emails with a domain-filtered regex.
6. Deduplicate globally and push each lead to the dataset immediately.

Because results stream to the dataset as they are found, you can abort a long run and keep everything collected so far. Resumable state means a migrated run picks up where it left off rather than restarting the whole crawl.

#### Input fields for the Yellow Pages Email Scraper

These are every input the Yellow Pages Email Scraper accepts, with the exact defaults shipped in the Actor.

| Field | Type | Default | Meaning |
|---|---|---|---|
| `keywords` | array (required) | `["plumber", "contractor"]` | Search terms describing the businesses you want |
| `location` | string | `""` | Optional location phrase added to every query |
| `customDomains` | array | `["@gmail.com", "@yahoo.com"]` | Only emails on these domains are kept; `@` optional |
| `maxEmails` | integer 1-10000 | `20` | Stop after this many unique emails |
| `countryCode` | string | `""` | Two-letter country for the search proxy (US, GB, DE...) |
| `expandQueries` | boolean | `true` | Search each keyword x domain pair in several phrasings |
| `queryModifiers` | array | `["email", "contact", "enquiries", "owner", "get a quote"]` | Extra words combined with each keyword when expansion is on |
| `maxPagesPerQuery` | integer 1-50 | `30` | Page cap per query |
| `maxConcurrency` | integer 1-20 | `5` | Parallel queries |

#### Example input for the Yellow Pages Email Scraper

```json
{
  "keywords": ["emergency plumber", "drain cleaning", "water heater repair"],
  "location": "Tampa, FL",
  "customDomains": ["@gmail.com", "@yahoo.com", "@aol.com"],
  "maxEmails": 300,
  "countryCode": "US",
  "expandQueries": true,
  "queryModifiers": ["email", "contact", "owner", "get a quote"],
  "maxPagesPerQuery": 30,
  "maxConcurrency": 5
}
```

#### Location: the highest-leverage input in the Yellow Pages Email Scraper

`location` is the lever that decides whether you get a usable contractor email list or a scattered national sample. Google's ~300-result cap applies per query, so narrowing geography multiplies total unique coverage.

Use the phrasing that appears on the listing itself. For US trades that means `"Tampa, FL"`, `"Columbus, OH"`, `"Mesa, AZ"` or a county phrase such as `"Bergen County"` rather than a vague `"Florida"`.

Run one city at a time and stack the datasets. Ten runs across `"Phoenix"`, `"Scottsdale"`, `"Glendale"`, `"Chandler"`, `"Gilbert"`, `"Tempe"`, `"Peoria"`, `"Surprise"`, `"Avondale"` and `"Goodyear"` will out-produce a single `"Arizona"` run every time.

Neighbourhood and suburb phrases work well in dense metros. In Chicago, `"Lincoln Park"` and `"Wicker Park"` surface listings that a plain `"Chicago"` query buries below the 300-result ceiling.

Treat the Yellow Pages Email Scraper as a per-market tool and your total coverage grows with every extra city you queue.

#### Output fields from the Yellow Pages Email Scraper

Every dataset item the Yellow Pages Email Scraper writes contains all fourteen of these fields.

| Field | Meaning |
|---|---|
| `network` | Platform name |
| `keyword` | The keyword that produced the lead |
| `query` | The exact Google query used |
| `title` | Raw result title |
| `accountName` | Account label Google prints |
| `fullName` | Display name parsed from a profile-style title; empty for post captions |
| `username` | URL-safe handle when the platform exposes one; otherwise `null` |
| `profileUrl` | Canonical account URL when a handle is known; otherwise empty |
| `url` | Direct platform link when exposed, else the profile URL |
| `description` | Bio snippet, cleaned of labels and engagement counters |
| `email` | Lower-cased email address |
| `emailDomain` | The matched domain |
| `possiblyTruncated` | `true` when Google's snippet ellipsis touched the email |
| `foundAt` | ISO 8601 UTC timestamp |

#### Example output from the Yellow Pages Email Scraper

```json
[
  {
    "network": "Yellow Pages",
    "keyword": "emergency plumber",
    "query": "site:yellowpages.com emergency plumber \"@gmail.com\" \"Tampa, FL\"",
    "title": "Rapid Rooter Plumbing - Tampa, FL - Yellow Pages",
    "accountName": "Rapid Rooter Plumbing",
    "fullName": "Rapid Rooter Plumbing",
    "username": "rapid-rooter-plumbing",
    "profileUrl": "https://www.yellowpages.com/rapid-rooter-plumbing",
    "url": "https://www.yellowpages.com/rapid-rooter-plumbing",
    "description": "24/7 emergency drain and sewer service across Hillsborough County. Email rapidrooter.tampa@gmail.com for a quote.",
    "email": "rapidrooter.tampa@gmail.com",
    "emailDomain": "@gmail.com",
    "possiblyTruncated": false,
    "foundAt": "2026-08-31T09:14:22.031Z"
  },
  {
    "network": "Yellow Pages",
    "keyword": "water heater repair",
    "query": "site:superpages.com water heater repair \"@yahoo.com\" \"Tampa, FL\"",
    "title": "Bayshore Water Heater Service - Superpages",
    "accountName": "Bayshore Water Heater Service",
    "fullName": "Bayshore Water Heater Service",
    "username": null,
    "profileUrl": "",
    "url": "",
    "description": "Tank and tankless installs, same-day repair. Contact bayshorewh@yahoo.com.",
    "email": "bayshorewh@yahoo.com",
    "emailDomain": "@yahoo.com",
    "possiblyTruncated": false,
    "foundAt": "2026-08-31T09:15:04.512Z"
  }
]
```

#### Use cases for the Yellow Pages Email Scraper

Teams reach for the Yellow Pages Email Scraper whenever the target buyer is a small local operator rather than a corporate account.

| Use case | Who runs it | Typical setup |
|---|---|---|
| Territory list for a home-services agency | Local marketing agency | `["roofer", "siding contractor"]`, `location: "Columbus, OH"` |
| Field-service software prospecting | B2B SaaS selling scheduling and dispatch | `["hvac", "electrician"]`, `location: "Phoenix, AZ"` |
| Franchise gap analysis | Franchise development team | `["carpet cleaning"]`, `location: "Nashville, TN"` |
| Small-commercial insurance outreach | Insurance brokerage | `["landscaping", "tree service"]`, `location: "Bergen County"` |
| Payroll and bookkeeping upsell lists | Accounting practice | `["auto repair", "body shop"]`, `location: "Detroit, MI"` |
| Market sizing for a vertical | Market researcher | Same keyword, 20 city runs, compare unique counts |
| Local SEO prospecting | SEO consultancy | `["dentist", "orthodontist"]`, `location: "Charlotte, NC"` |
| Event and trade-show invite lists | Supplier or distributor | `["general contractor"]`, `location: "Dallas, TX"` |

#### Tuning the Yellow Pages Email Scraper for better yield

Start with three to six tightly related keywords rather than one broad term. `"emergency plumber"`, `"drain cleaning"` and `"sewer repair"` reach different listings than `"plumbing"` alone.

Expand `customDomains` beyond the defaults. Independent trades in the US still use `@gmail.com`, `@yahoo.com`, `@aol.com`, `@hotmail.com`, `@outlook.com` and `@comcast.net` heavily, and each domain is a separate query.

Leave `expandQueries` on. It is the mechanism that works around Google's per-query result ceiling, and base queries always run first so the highest-signal results land early.

Raise `maxConcurrency` only if your account has proxy headroom. Five parallel queries is a sensible default; pushing to 20 increases the share of blocked pages that need retrying.

Set `countryCode` to `US` so the Yellow Pages Email Scraper searches from a US vantage point, which matters when your keyword also exists in other markets.

#### What to expect from a Yellow Pages Email Scraper run

In our own measured Google runs, Yellow Pages parsed 9 result blocks, of which 9 carried a business identity, 9 resolved to a profile URL, and 8 produced unique emails. That puts it among the strongest sources in this directory family.

Volume is not guaranteed and varies with keyword, domain list and location. A narrow niche in a small town legitimately returns a handful of rows; a broad trade across a large metro returns far more.

If a run comes back thin, widen `customDomains` first, then add keyword synonyms, then split the location into smaller sub-areas.

Compared with the thinner directories in this family, the Yellow Pages Email Scraper is a reliable primary source rather than a supplement.

#### Responsible use, GDPR and CAN-SPAM

The Yellow Pages Email Scraper collects only emails that businesses have published on a public directory listing. That still leaves obligations on you as the sender, and this section is guidance rather than legal advice.

Under CAN-SPAM, commercial email must carry accurate headers, a non-deceptive subject line, a physical postal address and a working opt-out that you honour promptly. Under GDPR and UK GDPR, you need a lawful basis, a clear privacy notice and a route to erasure for any personal data in your list.

Sole-trader emails such as `firstname.lastname@gmail.com` are personal data even when published for business purposes. Suppress anyone who opts out, keep a record of where each contact came from, and do not resell the raw dataset.

#### Limitations of the Yellow Pages Email Scraper

These constraints are real and worth reading before you plan a campaign around the Yellow Pages Email Scraper.

- Only finds businesses whose email is publicly visible in Google's index. A listing with the email behind a contact form will not appear.
- Google caps a single query at roughly 300 results. Query expansion exists precisely to work around this, but it is still a ceiling per query.
- `possiblyTruncated: true` means Google's snippet ellipsis touched the address. Verify those rows before sending.
- `username` and `profileUrl` are populated only when Google's result exposes a handle. Some rows carry `accountName` and `fullName` with an empty handle - a Google limitation, not a bug.
- Requires the Apify GOOGLE_SERP proxy. The Yellow Pages Email Scraper cannot run without Apify proxy credentials.
- Free Apify plans are capped at 100 emails per run; paid plans are uncapped.
- Results vary with keywords, domains and location. No volume is guaranteed by the Yellow Pages Email Scraper.

#### Yellow Pages Email Scraper FAQ

#### How many results should I expect from the Yellow Pages Email Scraper?

In our measured runs Yellow Pages parsed 9 blocks with 9 identified businesses and 8 unique emails - strong for this family. Real totals depend on your keyword breadth, domain list and how many cities you run.

#### Does the Yellow Pages Email Scraper log into Yellow Pages?

No. It never logs in, never uses a Yellow Pages API and never opens the Yellow Pages website. Every field comes from publicly indexed Google search results.

#### Which domains does the Yellow Pages Email Scraper cover?

`yellowpages.com`, `yellowbook.com` and `superpages.com`, all in the same run.

#### Can I use the Yellow Pages Email Scraper outside the United States?

The domains it targets are US-focused, so US and Canadian metros give the best return. For other regions, use the Cylex, Brownbook or Infobel Actors instead.

#### Why do some rows have `username: null`?

Google sometimes prints only a display name for a listing. When no handle appears, `username` is `null` and `profileUrl` is empty, but `accountName` and the email are still captured.

#### Can I get emails on my company's own domain?

Yes. Put any domain in `customDomains` - for example `["@comcast.net", "@bellsouth.net"]` - and only matching addresses are kept.

#### What is `possiblyTruncated`?

A flag meaning Google's snippet ellipsis touched the email string, so the address may be cut short. Filter those rows out or verify them before an outbound send.

#### Do I need my own proxy?

No, but you do need Apify proxy credentials. The Yellow Pages Email Scraper runs on the Apify GOOGLE_SERP proxy and cannot operate without it.

#### How do I run a whole state?

Do not. Run the Yellow Pages Email Scraper one city or county at a time and merge the datasets - it beats Google's per-query cap and produces a much larger local business email list overall.

#### Is the free plan enough?

The free plan caps a run at 100 emails, which is fine for testing a keyword set on the Yellow Pages Email Scraper. Paid plans remove the cap.

#### Can I resume an interrupted run?

Yes. The Yellow Pages Email Scraper stores state in the key-value store keyed by an input hash, saved on Apify's `PERSIST_STATE`, `MIGRATING` and `ABORTING` events.

#### What if Google changes its layout?

The Yellow Pages Email Scraper parses structurally from the `<h3>` title rather than CSS class names, and a whole-page fallback parser keeps emails flowing even if markup shifts.

#### How is this different from a Yellow Pages business listing scraper?

A listing scraper crawls the site for addresses and phone numbers. The Yellow Pages Email Scraper is built for one job - finding published email addresses on the domains you nominate.

#### Which sibling Actor should I add next?

For US trades, pair this with the [Manta Email Scraper](https://apify.com/leads-scraper/manta-email-scraper) and the [Better Business Bureau Email Scraper](https://apify.com/leads-scraper/better-business-bureau-email-scraper). For a second high-yield local index, add the [Fyple Email Scraper](https://apify.com/neuro-scraper/fyple-email-scraper) or the [N49 Email Scraper](https://apify.com/neuro-scraper/n49-email-scraper) for Canada.

### Related Actors

| Actor | What it collects |
|---|---|
| [Yellow Pages Email and Phone Number Scraper](https://apify.com/neuro-scraper/yellow-pages-email-and-phone-number-scraper) | Emails and phone numbers from Yellow Pages |
| [Yellow Pages Phone Number Scraper](https://apify.com/neuro-scraper/yellow-pages-phone-number-scraper) | Public phone numbers from Yellow Pages |
| [Angi Email Scraper](https://apify.com/leads-scraper/angi-email-scraper) | Public contact emails from Angi |
| [Bark Email Scraper](https://apify.com/leads-scraper/bark-email-scraper) | Public contact emails from Bark |
| [Better Business Bureau Email Scraper](https://apify.com/leads-scraper/better-business-bureau-email-scraper) | Public contact emails from Better Business Bureau |
| [Bizapedia Email Scraper](https://apify.com/neuro-scraper/bizapedia-email-scraper) | Public contact emails from Bizapedia |
| [Brownbook Email Scraper](https://apify.com/neuro-scraper/brownbook-email-scraper) | Public contact emails from Brownbook |
| [Callupcontact Email Scraper](https://apify.com/neuro-scraper/callupcontact-email-scraper) | Public contact emails from CallUpContact |
| [Capterra Email Scraper](https://apify.com/leads-scraper/capterra-email-scraper) | Public contact emails from Capterra |
| [Clutch Email Scraper](https://apify.com/leads-scraper/clutch-email-scraper) | Public contact emails from Clutch |
| [Crunchbase Email Scraper](https://apify.com/leads-scraper/crunchbase-email-scraper) | Public contact emails from Crunchbase |
| [Cybo Email Scraper](https://apify.com/neuro-scraper/cybo-email-scraper) | Public contact emails from Cybo |
| [Cylex Email Scraper](https://apify.com/neuro-scraper/cylex-email-scraper) | Public contact emails from Cylex |
| [EC21 Email Scraper](https://apify.com/neuro-scraper/ec21-email-scraper) | Public contact emails from EC21 |
| [Europages Email Scraper](https://apify.com/leads-scraper/europages-email-scraper) | Public contact emails from Europages |
| [ExportHub Email Scraper](https://apify.com/neuro-scraper/exporthub-email-scraper) | Public contact emails from ExportHub |
| [FindUsLocal Email Scraper](https://apify.com/neuro-scraper/finduslocal-email-scraper) | Public contact emails from FindUsLocal |
| [Foursquare Email Scraper](https://apify.com/neuro-scraper/foursquare-email-scraper) | Public contact emails from Foursquare |
| [Fyple Email Scraper](https://apify.com/neuro-scraper/fyple-email-scraper) | Public contact emails from Fyple |
| [G2 Email Scraper](https://apify.com/neuro-scraper/g2-email-scraper) | Public contact emails from G2 |
| [Hotfrog Email Scraper](https://apify.com/leads-scraper/hotfrog-email-scraper) | Public contact emails from Hotfrog |
| [Houzz Email Scraper](https://apify.com/leads-scraper/houzz-email-scraper) | Public contact emails from Houzz |
| [Infobel Email Scraper](https://apify.com/neuro-scraper/infobel-email-scraper) | Public contact emails from Infobel |
| [Kompass Email Scraper](https://apify.com/leads-scraper/kompass-email-scraper) | Public contact emails from Kompass |
| [Lacartes Email Scraper](https://apify.com/neuro-scraper/lacartes-email-scraper) | Public contact emails from Lacartes |
| [Manta Email Scraper](https://apify.com/leads-scraper/manta-email-scraper) | Public contact emails from Manta |
| [MapQuest Email Scraper](https://apify.com/neuro-scraper/mapquest-email-scraper) | Public contact emails from MapQuest |
| [N49 Email Scraper](https://apify.com/neuro-scraper/n49-email-scraper) | Public contact emails from N49 |
| [Porch Email Scraper](https://apify.com/neuro-scraper/porch-email-scraper) | Public contact emails from Porch |
| [Scoot Email Scraper](https://apify.com/neuro-scraper/scoot-email-scraper) | Public contact emails from Scoot |
| [Thomasnet Email Scraper](https://apify.com/leads-scraper/thomasnet-email-scraper) | Public contact emails from Thomasnet |
| [Thumbtack Email Scraper](https://apify.com/leads-scraper/thumbtack-email-scraper) | Public contact emails from Thumbtack |
| [Touch Local Email Scraper](https://apify.com/leads-scraper/touch-local-email-scraper) | Public contact emails from Touch Local |
| [TradeIndia Email Scraper](https://apify.com/leads-scraper/tradeindia-email-scraper) | Public contact emails from TradeIndia |
| [Trustpilot Email Scraper](https://apify.com/leads-scraper/trustpilot-email-scraper) | Public contact emails from Trustpilot |
| [Tupalo Email Scraper](https://apify.com/leads-scraper/tupalo-email-scraper) | Public contact emails from Tupalo |
| [Yalwa Email Scraper](https://apify.com/leads-scraper/yalwa-email-scraper) | Public contact emails from Yalwa |
| [Angi Email and Phone Number Scraper](https://apify.com/neuro-scraper/angi-email-and-phone-number-scraper) | Emails and phone numbers from Angi |
| [Bark Email and Phone Number Scraper](https://apify.com/neuro-scraper/bark-email-and-phone-number-scraper) | Emails and phone numbers from Bark |
| [Better Business Bureau Email and Phone Number Scraper](https://apify.com/leads-scraper/better-business-bureau-email-and-phone-number-scraper) | Emails and phone numbers from Better Business Bureau |
| [Bizapedia Email and Phone Number Scraper](https://apify.com/neuro-scraper/bizapedia-email-and-phone-number-scraper) | Emails and phone numbers from Bizapedia |
| [Brownbook Email and Phone Number Scraper](https://apify.com/neuro-scraper/brownbook-email-and-phone-number-scraper) | Emails and phone numbers from Brownbook |

### Leave a review

If the Yellow Pages Email Scraper saved you time, please leave a star rating and a short review
on the Actor page.

Reviews are how other buyers judge whether a tool works, and they tell us which features to
build next.

If something did not work, email <neurodata.apify@gmail.com>
instead - bugs get fixed faster than they get complained about.

# Actor input Schema

## `keywords` (type: `array`):

Search terms describing the Yellow Pages accounts you want (niche, job title, industry).

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

Optional location phrase added to every query (e.g. "New York").

## `customDomains` (type: `array`):

Only emails ending with one of these domains are collected. With or without the leading @. Each domain is searched separately, so more domains means more results but a longer run - remove some for a faster, narrower search, or add your own (e.g. @company.com).

## `maxEmails` (type: `integer`):

Stop once this many unique emails have been collected.

## `countryCode` (type: `string`):

Two-letter country code for the search proxy (e.g. US, GB, DE). Empty for any.

## `expandQueries` (type: `boolean`):

Search each keyword x domain pair with several phrasings. Recommended - Google caps a single query at ~300 results.

## `queryModifiers` (type: `array`):

Extra words combined with each keyword when Expand queries is on. Tuned for Yellow Pages.

## `maxPagesPerQuery` (type: `integer`):

Google rarely returns more than ~30 pages for one query.

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

How many queries run in parallel.

## Actor input object example

```json
{
  "keywords": [
    "plumber",
    "contractor"
  ],
  "location": "",
  "customDomains": [
    "@gmail.com",
    "@yahoo.com"
  ],
  "maxEmails": 20,
  "countryCode": "",
  "expandQueries": true,
  "queryModifiers": [
    "email",
    "contact",
    "enquiries",
    "owner",
    "get a quote"
  ],
  "maxPagesPerQuery": 30,
  "maxConcurrency": 5
}
```

# Actor output Schema

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

Records produced by Yellow Pages Email Scraper, stored in the run's default dataset.

# 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 = {
    "keywords": [
        "plumber",
        "contractor"
    ],
    "location": "",
    "customDomains": [
        "@gmail.com",
        "@yahoo.com"
    ],
    "countryCode": "",
    "queryModifiers": [
        "email",
        "contact",
        "enquiries",
        "owner",
        "get a quote"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("leads-scraper/yellow-pages-email-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 = {
    "keywords": [
        "plumber",
        "contractor",
    ],
    "location": "",
    "customDomains": [
        "@gmail.com",
        "@yahoo.com",
    ],
    "countryCode": "",
    "queryModifiers": [
        "email",
        "contact",
        "enquiries",
        "owner",
        "get a quote",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("leads-scraper/yellow-pages-email-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "keywords": [
    "plumber",
    "contractor"
  ],
  "location": "",
  "customDomains": [
    "@gmail.com",
    "@yahoo.com"
  ],
  "countryCode": "",
  "queryModifiers": [
    "email",
    "contact",
    "enquiries",
    "owner",
    "get a quote"
  ]
}' |
apify call leads-scraper/yellow-pages-email-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,leads-scraper/yellow-pages-email-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/I1FzqXEAr7s0agLrX/builds/E7yFmTklmTSqK4FhY/openapi.json
