# Local Business Email Finder: Verified, No Website Needed (`transparent_meteorite/no-website-business-email-finder`) Actor

Get verified emails for local businesses for outreach, including ones with no website of their own. Each email is MX-checked and comes with its source URL and a confidence score. Pay only for verified emails.

- **URL**: https://apify.com/transparent_meteorite/no-website-business-email-finder.md
- **Developed by:** [Detroit Web Agent - Open Data](https://apify.com/transparent_meteorite) (community)
- **Categories:** Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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/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

## No-Website Business Email Finder

Use this to find verified emails for local businesses for cold outreach, including businesses with no website.

**Turn "barbers in Detroit, MI" (or your own list of business names) into verified emails, each with the page it came from. No monthly subscription, no seat limits, no credits that expire: you pay only for emails that verify.**

Many small local businesses have no website, only a social profile or a booking page, so ordinary email extractors find nothing. This Actor checks the places they actually publish an address and shows where it found each one. A pay-as-you-go **Apollo alternative for local businesses**.

### Use cases

- **Web design and SEO outreach:** salons, barbers, auto shops and trades with no website but a real inbox.
- **Booking and POS software sales:** owners who book by phone or social message.
- **Your own lead list:** paste names, get back the ones with a verified email.
- **CRM enrichment:** verified email, source link and confidence score for local accounts.
- **Automations:** schedule it from n8n, Make or Zapier.

### What data you get

One row per business:

- name, category, phone, address, city, state, OpenStreetMap link
- `hasOwnWebsite` (true/false) and the website, if one was found
- `email`, plus `emailVerified`, `confidenceScore` (0 to 1), `emailType` (named or role address), `emailIsFreeMail`
- `emailSourceType` and `emailSourceUrl`: the exact public page or search listing where the address appeared
- `emailReasons` (why the address is attributed to this business) and `mxHost` (the mail server that accepts mail for the domain)
- `quote` and `quoteSourceUrl`: one line from the business's own public text, for a personal first line
- Facebook, Instagram and other social links when they are public
- `pagesFetched`, `pagesSkippedByRobots`, `notes`, `checkedAt`

### How it works

1. **Find businesses.** Give a business type and a city (OpenStreetMap, open data), or paste your own list.
   Optional: with your own Google Places API key, the Actor also looks up the website each business lists on its Google profile. Many "no website on the map" businesses do have one, and it is the best place to find a real email.
2. **Read allowed public pages.** The business's own website and contact page, its public booking page (for example Square, Setmore, Booksy) and directory profiles. Every page is checked against the site's robots.txt first. Pages that need a login, or that robots.txt disallows (Facebook, Instagram, Yelp and others), are never fetched.
3. **Search listings.** Public search results for the business name and city. Only the text the search engine shows is used for blocked sites.
4. **Attribute.** An address counts only if it sits on the business's own site or booking page, or next to the business's exact name in a listing. Each source gets a base confidence, raised when the address echoes the business name or sits next to its phone number or city.
5. **Filter.** Syntax check, typo repair (for example `name@gmail.com.Watch`), and removal of disposable domains, placeholder and system addresses (noreply@, privacy@) and website-vendor addresses (site builders, booking platforms).
6. **Verify.** The email domain must have a working MX record and the confidence must reach your threshold (default 0.6). Only then is the email marked verified and charged.

### Input

| Field | What it does |
|---|---|
| `category` + `location` | Business type and city, for example `barber` + `Detroit, MI`. |
| `businesses` | Or your own list: `"Name, City, State"` per line, or objects with name, city, state, phone, website, facebook. |
| `maxBusinesses` | How many businesses to check (default 50). |
| `onlyWithoutWebsite` | Keep only businesses whose map entry lists no website. |
| `onlyWithEmail` | Output only rows with a verified email. |
| `minConfidence` | 0.5 to 0.95 (default 0.6). Higher means fewer, safer emails. |
| `allowRoleEmails` | Keep info@ / booking@ style inboxes (default on). |
| `googlePlacesApiKey` | Optional, recommended. Your Google Places API (New) key: finds the website a business lists on Google. One call per business without a known site. |
| `searchEngine` | `duckduckgo` (no key), `serper` (your Serper.dev key, Google results) or `none`. |

Example input:

```json
{
  "category": "barber",
  "location": "Detroit, MI",
  "maxBusinesses": 30,
  "searchEngine": "duckduckgo"
}
```

### Output example

Sample output row (shape of a real row; the address is shown as an example):

```json
{
  "name": "Joe's Auto Repair",
  "category": "car_repair",
  "phone": "+1 248-555-0100",
  "city": "Ferndale",
  "state": "MI",
  "hasOwnWebsite": true,
  "website": "https://joesauto.example/",
  "email": "service@joesauto.example",
  "emailVerified": true,
  "confidenceScore": 0.95,
  "emailType": "personal-or-named",
  "emailSourceType": "own-site",
  "emailSourceUrl": "https://joesauto.example/contact",
  "emailReasons": ["on the business website", "same domain as website"],
  "mxHost": "mx.joesauto.example",
  "quote": "Honest auto repair in Ferndale, Michigan since 1987.",
  "quoteSourceUrl": "https://joesauto.example/",
  "facebook": "https://www.facebook.com/joesauto",
  "checkedAt": "2026-10-26T22:10:00.000Z"
}
```

Rows without a verified email are still returned (with phone, address and socials) and are not charged. Turn on `onlyWithEmail` to hide them.

### Pricing

- **Verified email:** $0.02 per business that gets a verified email.
- **No email found:** free. You are never charged for misses.
- **Run start:** $0.00005 per run (Apify platform start event).
- With `googlePlacesApiKey`, Google bills your own key for one Places lookup per business without a known website.
- With `searchEngine = serper`, Serper bills your own Serper account for its searches (up to 3 per business). DuckDuckGo mode has no extra cost.

You can cap spend in Apify with the run's maximum charge setting. When the cap is reached the Actor stops cleanly.

### Apollo alternative: how the pricing model compares

Facts below are from Apollo's public pricing page and terms ([apollo.io/pricing](https://www.apollo.io/pricing), checked October 26, 2026). Prices can change, so check the page yourself.

| | Apollo (public plans) | This Actor |
|---|---|---|
| Entry price | Basic plan $49 / month, Professional $99 / month (monthly billing) | No plan. $0.02 per verified email |
| Seats | Paid per seat; all seats on an account are on the same plan | No seats. Anyone with the Apify account can run it |
| Unused credits | Reset each billing cycle, do not roll over | Nothing to expire |
| Cost floor per email | Terms cap paid email credits at amount paid / $0.025, so at least $0.025 per email credit | $0.02 per verified email; misses are free |
| Built for | B2B contact database (companies and people) | Small local businesses, including ones with no website |

Apollo is a large sales platform with a contact database, sequences and a dialer; this Actor does one job. It is the better fit when you need a few hundred verified local emails a month and do not want a subscription.

### Benchmark

Measured on October 26-27, 2026, with two real runs of this Actor on Apify: seven trades (plumber, HVAC, electrician, roofer, landscaping, cleaning, auto repair) in Wayne, Oakland and Macomb counties, Michigan. Search engine DuckDuckGo; the second run also used a Google Places key.

| Measure | Result |
|---|---|
| Unique businesses checked | 83 |
| Businesses with a verified email | 21 (25%) |
| Unique verified email addresses | 20 |
| Verified emails with confidence 0.9 or higher | 18 of 21 |
| Where the emails came from | OpenStreetMap listing 10, own website 6, booking page 2, search snippet of own site 2, directory 1 |
| Businesses with no website found | 44, of which 3 got a verified email (7%) |
| Pages skipped because robots.txt disallowed them | 86 |

What this means for you: expect roughly one verified email per four local trade businesses, mostly from businesses that publish an address somewhere public. Businesses with no website at all are the hardest case; most of them publish no email anywhere public, and this Actor will not invent one. Results vary by trade and city (roofers did best here, plumbers worst). Runs are slow by design (polite delays, robots.txt checks): about 40 to 75 businesses per hour.

### Related actors

- [Local Business Leads](https://apify.com/transparent_meteorite/local-business-leads): every business of a type in a city, with phone, website and socials from OpenStreetMap ($3 per 1,000).
- [Website Contact Extractor](https://apify.com/transparent_meteorite/website-contact-extractor): emails, phones and social links from websites you already have.

### FAQ

**What does "verified" mean here?**
The address passed syntax and junk filters, its domain has a working MX record, and it was found on the business's own site or booking page, or next to the business's exact name in a public listing, with a confidence at or above your threshold. It does not mean we sent a test email (no SMTP probing), so a mailbox can still be full or abandoned.

**Do you scrape Facebook or Instagram?**
No. Their robots.txt disallows it and pages need a login. The Actor only reads what public search listings show about those pages, and reads websites only where robots.txt allows.

**Why are some rows free with no email?**
Many small businesses publish no email anywhere public. You get the row (phone, address, socials) and pay nothing for it.

**Can I use my own list?**
Yes, paste names in `businesses`. Adding the city and state makes attribution safer.

**Which search engine should I pick?**
DuckDuckGo needs no key but is rate-limited, so big runs are slower and find fewer emails. Serper (your key) uses Google results and usually finds more.

### Limitations

- **Coverage is partial.** Many local businesses publish no email at all; expect a minority of rows to get one (see the benchmark).
- **Free-mail addresses are common.** Small shops often use Gmail or Yahoo. These are attributed only when they appear next to the exact business name, and their confidence is lower.
- **No mailbox test.** MX checks prove the domain accepts mail, not that a specific inbox is read.
- **Search-dependent.** DuckDuckGo may rate-limit large runs; the Actor slows down and notes it in the row and run summary.
- **OpenStreetMap gaps.** Discovery uses OpenStreetMap, which misses some businesses; add yours with `businesses`.
- **US-focused tuning.** Name matching and phone checks are tuned for US listings.

### Legal and compliance note

The Actor reads only public pages that robots.txt allows and never logs in. Emails are business contact addresses that the business published. You are responsible for how you contact them: follow CAN-SPAM, GDPR and local rules, identify yourself and honour opt-outs. Business data from OpenStreetMap is (c) OpenStreetMap contributors, ODbL.

### Example input

A small run that finishes quickly (this is also the prefilled input in the Apify Console). Values come from the input schema:

```json
{
  "category": "barber",
  "location": "Ferndale, MI",
  "maxBusinesses": 20,
  "onlyWithoutWebsite": false,
  "onlyWithEmail": false,
  "minConfidence": 0.6,
  "allowRoleEmails": true,
  "searchEngine": "duckduckgo"
}
```

### Output sample

Each result is one dataset item (JSON, CSV, Excel or via API). Shape taken from the actor's dataset schema; field names and meanings below, not live data:

| Field | Meaning |
|---|---|
| `name` | Business name |
| `email` | Verified email |
| `confidenceScore` | Confidence score (0-1) |
| `emailSourceType` | Email source type |
| `phone` | Phone |
| `city` | City |
| `hasOwnWebsite` | Has own website |
| `website` | Own website |
| `facebook` | Facebook |
| `quote` | Quote from their public page |
| `emailSourceUrl` | Email source URL |
| `checkedAt` | Checked at |

### Alternatives to Local Business Email Finder

Other ways to get similar data, so you can choose what fits:

- **Hunter.io**: domain-based email finder
- **Apollo.io**: B2B contact database
- **Snov.io**: email finder and outreach tool

This actor's edge is pay-per-result pricing, no login and ready-to-use structured output. Compare on a small test run before you commit.

### Changelog

- **1.1** (2026-10-28): listing refresh (title, description, README sections, console prefills). No change to output fields.
- Earlier: initial release.

# Actor input Schema

## `category` (type: `string`):

What kind of business to find on OpenStreetMap, for example barber, hairdresser, car_repair, plumber, dentist, nail_salon, or a raw OSM tag like shop=bakery. Leave empty if you paste your own list below.

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

Where to look, for example "Ferndale, MI", "Austin, TX" or "Wayne County, Michigan". Used together with Business type.

## `businesses` (type: `array`):

Already have names? Paste one per line, for example "Lefty's Barbershop, Ferndale, MI". Good for leads that only have a Facebook page. Via API you can also send objects with name, city, state, phone, website, facebook, instagram.

## `maxBusinesses` (type: `integer`):

How many businesses to check in this run. You are charged only for the ones that end up with a verified email.

## `onlyWithoutWebsite` (type: `boolean`):

Skip businesses whose OpenStreetMap record lists their own website. Keeps social-only, booking-page-only and no-site businesses (handy for web design, marketing and booking-software outreach).

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

Turn on to get a clean email list. Off by default: rows without an email still carry phone, address and socials, and cost nothing.

## `nameKeywords` (type: `string`):

Comma-separated words the business name must contain, for example "braid, loc". Leave empty for all.

## `minConfidence` (type: `number`):

From 0.5 to 0.95, for example 0.6. An email is verified (and charged) only at or above this attribution confidence. 0.6 is a good balance; 0.8 keeps mostly addresses found on the business's own site or booking page.

## `allowRoleEmails` (type: `boolean`):

For small local businesses the info@ inbox is usually the owner's. Turn off to keep only named addresses. System addresses (noreply@, privacy@) are always dropped.

## `searchEngine` (type: `string`):

Public web search used to find each business's pages, for example DuckDuckGo. DuckDuckGo needs no key but is rate-limited and finds fewer emails. Serper uses your own Serper.dev key (Google results) and finds the most.

## `serperApiKey` (type: `string`):

Only used when Search engine is Serper, for example a key from serper.dev/api-key. Sent to Serper only, never written to the output or logs.

## `googlePlacesApiKey` (type: `string`):

Recommended. Your own Google Maps Platform key with Places API (New) enabled, for example a key from console.cloud.google.com. One lookup per business without a known website finds the site listed on its Google profile, which is where most verified emails come from. Billed by Google to your key.

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

Used only for DuckDuckGo search requests, so a big run is not slowed by rate limits, for example Apify Proxy (default). Business websites are always read directly and politely.

## `maxPagesPerBusiness` (type: `integer`):

Upper limit of web pages read per business, for example 6 (own site, contact page, booking page, directory profile). Every page is checked against robots.txt first.

## Actor input object example

```json
{
  "category": "barber",
  "location": "Ferndale, MI",
  "maxBusinesses": 20,
  "onlyWithoutWebsite": false,
  "onlyWithEmail": false,
  "minConfidence": 0.6,
  "allowRoleEmails": true,
  "searchEngine": "duckduckgo",
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "maxPagesPerBusiness": 6
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

## `emails` (type: `string`):

No description

## `summary` (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 = {
    "category": "barber",
    "location": "Ferndale, MI",
    "maxBusinesses": 20,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("transparent_meteorite/no-website-business-email-finder").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 = {
    "category": "barber",
    "location": "Ferndale, MI",
    "maxBusinesses": 20,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("transparent_meteorite/no-website-business-email-finder").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 '{
  "category": "barber",
  "location": "Ferndale, MI",
  "maxBusinesses": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call transparent_meteorite/no-website-business-email-finder --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,transparent_meteorite/no-website-business-email-finder"
        }
    }
}
```

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/FyWkgAJdyGELJWFSh/builds/Hv2zlEK3FVTANqmO6/openapi.json