# Local Business Contact Enricher — Name, Role & Email (`scrapersdelight/local-business-enricher`) Actor

Turn a local business website into the owner/pastor/manager contact: name, role, and email (incl. gmail/generic mailboxes), with MX validation. Reads plain-HTML about/staff/contact pages, not just corporate team pages. No login, no paid API.

- **URL**: https://apify.com/scrapersdelight/local-business-enricher.md
- **Developed by:** [Scrapers Delight](https://apify.com/scrapersdelight) (community)
- **Categories:** Lead generation, Automation, Agents
- **Stats:** 7 total users, 5 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$10.00 / 1,000 per business contact enricheds

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

## Local Business Email Finder — the affordable Clay & Apollo alternative 📇

**Give it a list of local-business websites. Get back the real contact person's name, role, and email — one you can actually send to.**

You have a list of local businesses and all you've got is a website. No name. No email. No way to reach a human. And the "team page" enrichment tools you pay **$150–$800/month** for come back empty on small, local businesses — because a plumber, a dealership, a clinic, a diner, or a church doesn't have a structured team page, a JSON-LD `Person` block, or a LinkedIn-shaped org chart.

This is the pay-per-result, zero-setup **alternative to Clay, Apollo, ZoomInfo, Hunter, and Instantly** for one specific job: turning a list of local-business websites into **named contacts + real, observed emails**. No subscription. No credits to hoard. No table-building or waterfall config. You paste a list, you get contacts, and you pay ~1¢ only for the ones it finds.

It works on **any** local business — car dealers, churches, trades, restaurants, clinics, shops, agencies, gyms, salons — the exact long-tail that corporate enrichment tools completely miss.

***

### 📊 The proof (real run — nothing inflated)

We ran it on a real list of **2,168 local businesses**, each with just a website:

| Metric | Result |
|---|---|
| Businesses processed | **2,168** |
| Contact **name** found | **1,341** |
| Real **email** found | **1,149** |
| Had **both** name + email | **979** |
| Previously-blank names filled | **1,323** |
| Emails that are pattern-guesses | **0** |

**Every single email is *observed*** — a real address found on the business's own website — never a `firstname@domain.com` pattern-guess that bounces and burns your sending reputation.

On the **same list**, a leading corporate email finder managed roughly **1 hit in 20**. This got **~10× more** — because it's built for exactly the small/local businesses those tools (which need tidy "team" pages and JSON-LD) were never designed to read.

***

### 🆚 Why this instead of Clay / Apollo / ZoomInfo / Hunter?

This is **not** a full GTM platform, and that's the point. It's a focused, single-purpose **email finder + contact enrichment** actor for one job: **local-business websites → named contacts + real emails.** It beats the big tools *at that specific job*, on price and simplicity.

| | This actor | Clay / Apollo / ZoomInfo / Hunter |
|---|---|---|
| **Pricing** | **$0.01 per verified contact** | $150–$800+/month subscription |
| **Misses cost you** | **$0** — pay only for hits | Credits burn regardless |
| **Setup** | **Paste a list. Run.** | Tables, credits, waterfall config |
| **Local / small business** | **Built for it ✅** | Built for corporate rosters ❌ |
| **Emails** | **Observed on the real page** | Often pattern-guessed / stale |
| **Commitment** | None — per-result | Monthly seats & credit hoarding |

> **Honest framing:** this is an *alternative to* Clay/Apollo for one job — not a clone of them and not affiliated with them. If you need a full multi-source GTM platform with intent data, waterfalls, and CRM sync, keep Clay. If you have a list of local-business sites and just need **named contacts + real emails without a subscription**, this is cheaper, simpler, and hits far more often on local data.

***

### 📥 What you get (per business)

| Field | What it is |
|---|---|
| `contact_name` | Full name of the contact person |
| `first_name` / `last_name` | Split name parts |
| `role` | Their title/role (owner, GM, office manager…) |
| `email` | The best real, **observed** email |
| `email_source` | How it was found (`observed`) |
| `all_emails[]` | Every address discovered on the site |
| `phone` | Business phone |
| `socials` | Facebook / Instagram / LinkedIn found on-site |
| `confidence` | `high` / `medium` / `low` |
| `mx_valid` | Whether the domain's mail server accepts mail |
| `source_url` | The exact page the email came from |
| `id` | **Your own id, echoed back** — results merge straight into your CSV/CRM |

***

### ⚙️ How it works (real crawl → real emails)

For each business, it actually **crawls the live website** — the homepage plus the pages that matter: **about, contact, staff, team, and meet-the-owner** pages. It reads the page like a person would, pulls the human's name and role, and grabs the email that's *printed on the site*. Then it MX-checks the domain so what comes back can actually receive mail.

Because the email is lifted from the real page, it's a real address — not a `j.smith@` guess that bounces.

***

### ⏱️ Why it takes a little time (this is a feature, not a flaw)

It spends about **30–40 seconds per business** because it's genuinely reading each website. A ~2,000-business list runs in roughly **1–2 hours** (faster if you split it into parallel runs).

**That wait is the point.** A fake pattern-guess is instant *and* bounces. These emails are slower because they're **real** — found on the page, MX-checked, safe to send. Pattern-guess emails bounce, get you spam-flagged, and damage your domain reputation. Observed emails land.

> 💡 In a hurry? Split your list across several parallel runs — you keep the observed-email quality and cut the wall-clock time to well under an hour.

***

### 💰 Pricing

- **$0.01 per enriched contact** (pay-per-result).
- **$0 for any business where nothing is found** — you only pay for hits.
- No subscription. No monthly minimum. No credits to buy or expire.

Enrich the whole 2,168-business list from our proof run and you'd pay for the **~1,149 real emails you actually got** — about **$11** — not for a seat, and not for the misses. Compare that to a $150–$800/month platform where credits burn whether or not you get a usable contact.

***

### 👥 Who it's for

- **Sales & SDR teams** turning a scraped site list into named, emailable contacts.
- **Local lead-gen & marketing agencies** prospecting SMB clients (web, SEO, PR).
- **List builders & data resellers** enriching blank-contact rows at scale.
- **Home-services & trades, auto/dealership, recruiters & staffing** reaching local owners/managers.
- **Anyone with a list of websites** (Google Maps, Yelp, a directory export) and no contact behind them — including **Clay / Apollo users** who want a cheap per-result fallback for the local businesses those tools miss.

***

### 📝 Input example

Give it a list of businesses — a website is all that's required (Facebook/Instagram optional). Add your own `id` to merge results back into your data.

```json
{
  "businesses": [
    {
      "id": "1042",
      "website": "https://www.smithfamilydental.com",
      "facebook": "https://facebook.com/smithfamilydental"
    },
    { "id": "1043", "website": "riversideautosales.com" },
    { "id": "1044", "website": "https://gracechurch-austin.org" }
  ]
}
```

Each result comes back with your `id` echoed, so it drops straight into your CSV or CRM.

***

### ❓ FAQ

**Is this really a Clay alternative?**
For the specific job of turning local-business websites into named contacts + real emails — yes, and a cheaper, zero-setup one. It is **not** a full GTM platform like Clay, and it is **not affiliated with Clay**. If you need multi-source waterfalls, intent data, and CRM sync, use Clay. If you need real local-business contacts without a $150–$800/month subscription, this beats the big tools *at this job, on local data, on price* — for ~1¢ a hit.

**Why does it take ~30–40 seconds per business instead of being instant?**
Because it crawls each real website (home + about/contact/team pages) to find a real, observed email instead of guessing a pattern. Instant tools guess `firstname@domain.com` and hope. Real emails don't bounce or wreck your sender reputation. Speed it up by running parallel batches.

**Are the emails guessed or real?**
Real. Every email is **observed** on the business's own website, with the exact `source_url` returned so you can verify it, and the domain's mail server is **MX-checked** (`mx_valid`). Zero pattern-guesses.

**What if it can't find anything for a business?**
You pay **$0** for that business. You're only charged the $0.01 for actual hits.

**Will it work on any local business?**
It's built for exactly the small/local businesses corporate tools miss — dealers, trades, restaurants, clinics, churches, shops, agencies. Any business with a real website; no structured team page or JSON-LD required. For big structured enterprise directories, a corporate tool may match it.

**Can I merge results with my existing list?**
Yes — pass your own `id` per business and it's echoed back on every result for a clean join into your CSV/CRM.

***

*Stop paying a subscription for tools that come back empty on local businesses. Paste your list of websites → get named contacts + real, observed emails → pay a penny per hit. The honest, affordable Clay & Apollo alternative for local email enrichment.*

# Actor input Schema

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

One object per business. Each needs a website OR domain; the rest are optional and improve results. Fields: id (echoed back so you can merge on your CSV), company, website, domain, facebook, instagram, linkedin. Example: {"id":"row1","company":"Bethel Baptist Church","website":"https://bethelbaptist.ca","facebook":"https://facebook.com/..."}.

## `domains` (type: `array`):

Optional shortcut instead of the objects above: just a list of websites or domains, e.g. "bethelbaptist.ca", "https://avonmennonite.com". No id / socials merge — use "businesses" for that.

## `maxContactsPerBusiness` (type: `integer`):

How many contacts to return per business. 1 (default) = the single best contact (recommended for list enrichment). Increase to also return additional named people found.

## `useSocials` (type: `boolean`):

If a Facebook URL is provided and the website yielded no name, fetch the public Facebook page/about for a contact email + phone. Best-effort — Facebook may block; the row never fails.

## `useGoogleFallback` (type: `boolean`):

If the site and socials give no name, search Google for "{company}" (pastor|owner|founder|director) to find one. Best-effort, paced, needs a residential proxy. Off by default so runs stay fast and reliable.

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

Overall cap on billed contact records this run. 0 = no cap.

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

Proxy settings. Local business sites are arbitrary domains (some behind Cloudflare/WAF), so residential is the default for clean IP reputation. Override if you prefer.

## `requestConcurrency` (type: `integer`):

How many businesses to enrich in parallel.

## `diagnose` (type: `boolean`):

Dev only. Enriches the first business, logs the parsed contact rows, then exits.

## Actor input object example

```json
{
  "businesses": [
    {
      "id": "1",
      "company": "Avon Mennonite Church",
      "website": "https://www.avonmennonite.com/",
      "facebook": "https://www.facebook.com/AvonChurchStratford"
    },
    {
      "id": "2",
      "company": "Berean Baptist Church",
      "website": "https://bereanbaptistlondon.org/"
    }
  ],
  "maxContactsPerBusiness": 1,
  "useSocials": true,
  "useGoogleFallback": false,
  "maxItems": 0,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  },
  "requestConcurrency": 5,
  "diagnose": false
}
```

# Actor output Schema

## `contacts` (type: `string`):

The dataset of enriched contacts (one best contact per business: name, role, email, source, confidence, MX).

# 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 = {
    "businesses": [
        {
            "id": "1",
            "company": "Avon Mennonite Church",
            "website": "https://www.avonmennonite.com/",
            "facebook": "https://www.facebook.com/AvonChurchStratford"
        },
        {
            "id": "2",
            "company": "Berean Baptist Church",
            "website": "https://bereanbaptistlondon.org/"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapersdelight/local-business-enricher").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 = { "businesses": [
        {
            "id": "1",
            "company": "Avon Mennonite Church",
            "website": "https://www.avonmennonite.com/",
            "facebook": "https://www.facebook.com/AvonChurchStratford",
        },
        {
            "id": "2",
            "company": "Berean Baptist Church",
            "website": "https://bereanbaptistlondon.org/",
        },
    ] }

# Run the Actor and wait for it to finish
run = client.actor("scrapersdelight/local-business-enricher").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 '{
  "businesses": [
    {
      "id": "1",
      "company": "Avon Mennonite Church",
      "website": "https://www.avonmennonite.com/",
      "facebook": "https://www.facebook.com/AvonChurchStratford"
    },
    {
      "id": "2",
      "company": "Berean Baptist Church",
      "website": "https://bereanbaptistlondon.org/"
    }
  ]
}' |
apify call scrapersdelight/local-business-enricher --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

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