# Local Business Leads — Emails, Phones & Website Status (`teamkamkod/local-business-leads`) Actor

Query local businesses by country, city and industry, keep only those with a contact email, and see which have no website at all. No scraping, no rate limit — the index ships inside the Actor image. Image is maintained Daily

- **URL**: https://apify.com/teamkamkod/local-business-leads.md
- **Developed by:** [Team Kamkod](https://apify.com/teamkamkod) (community)
- **Stats:** 2 total users, 1 monthly users, 83.3% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 business leads

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## Local Business Leads — No Website & Dead Site Filter

**Query an exhaustive local-business index. No scraping, no API key, no rate limit.**

This Actor answers the one question every Google Maps based lead scraper cannot:
*"give me **every** business in this area, this industry, that has **no real website or a dead one**"* —
not the first 120 results a Maps query happens to return.

The index is built from the open **Overture Maps** places dataset (release `2026-09-23.0`) and ships
**inside the Actor image**, so every run is answered locally with DuckDB. Nothing is fetched at run
time unless you ask for website verification.

### What you get

- **30.4 million** businesses that have a contact email
- Country, city, region and **industry keyword** filters
- **Web presence filter** — no real website (none, social page, free builder, dead site) / any
- Optional **live website check**: alive · dead · free page · undetermined
- Phone numbers, all known emails, social profiles, operating status
- A hard `limit` cap and a `max_verifications` cap so the cost of a run is predictable

### Two levels: the source field, then the live check

**Level 1 — no network call.** A business whose "website" is a Facebook page, an Instagram profile,
a Linktree, a `wixsite.com` / `wordpress.com` / `blogspot` subdomain, a booking page or a directory
profile — or that has none at all — counts as **having no real website**. On the current index that is
**10.6 million businesses**, decided instantly, before any outbound request.

**Level 2 — `verify_sites`.** Remaining domains are fetched from Apify infrastructure and classified:

| `site_state` | Meaning |
|---|---|
| `alive` | Answers and serves real content |
| `dead` | DNS lookup fails, 404/410, connection refused, or a parked-domain page |
| `free_page` | Redirects to a social page, a free builder subdomain or a directory |
| `undetermined` | HTTP 403/429/5xx or timeout — **a WAF blocking a datacenter IP is never reported as a dead site** |

Measured on 300 random US/CA/GB businesses that the source declared as having a website:
**66 % alive, 20.7 % dead, 1 % free builder, 12.3 % undetermined.** Checking runs at **13 domains per
second**, costs about **$0.01 per 1 000 websites**, and 400 domains take ~30 seconds.

### Typical use cases

**Find businesses that need a website** (web agencies, SEO, hosting, site rebuilds) — filter
`web_presence = No real website` on any city and industry, and get the whole segment in one run
instead of a sample.

**Find businesses with a broken site** — `verify_sites = true` plus `site_state = dead`: these already
had a website and let it die, which is the warmest list a web agency can call.

**Build a callable B2B list** — `phone_required = true` plus an industry keyword.

**Feed a CRM or an AI agent** — flat JSON, one row per business, ready for HubSpot/Pipedrive/Sheets or
for an agent through Apify's MCP server.

### Input

- `country` — ISO-2 country code (`US`, `CA`, `BR`, `ZA`…), optional
- `city` — partial, case-insensitive city match (`Tampa`, `Mississauga`)
- `region` — partial region/state match (`FL`, `Ontario`)
- `category` — partial industry keyword (`roofing`, `plumb`, `dentist`, `real_estate`)
- `web_presence` — `any` · `no_real_website` · `no_website` · `has_website`
- `verify_sites` — fetch the remaining domains and classify each one (charged per verified lead)
- `site_state` — keep only `no_real_website` · `dead` · `free_page` · `alive` · `undetermined`
- `max_verifications` — hard cap on outbound checks (default 1 000, max 20 000)
- `phone_required` — keep only businesses with a phone number
- `limit` — max rows returned (default 100, max 200 000)
- `offset` — page through a large segment

### Output (one row per business)

```json
{
  "name": "SUNRISE ROOFING LLC",
  "category": "roofing_service",
  "category_bucket": "roofing",
  "postal_code": "33607", "city": "Tampa", "region": "FL", "country": "US",
  "email": "office@sunriseroofing.example",
  "emails": ["office@sunriseroofing.example"],
  "phone": "+1 813 555 0134",
  "phones": ["+1 813 555 0134"],
  "website": "https://www.instagram.com/sunriseroofing",
  "website_missing": false,
  "site_state": "free_page",
  "site_verified": false,
  "social_profiles": [],
  "operating_status": null,
  "source_release": "2026-09-23.0"
}
```

### Use it from an AI agent (MCP)

```
https://mcp.apify.com?tools=teamkamkod/local-business-leads
```

### Set it on a schedule

Run it weekly on a rotating territory, or monthly after each dataset release, and keep a rolling feed
of businesses that just became contactable in your segment.

### Good to know

- **Coverage is not uniform.** Email coverage per business is roughly 35 % in the US, 40-46 % in
  Canada / Mexico / Brazil, above 50 % in South Africa and Colombia. The index only contains
  businesses that have an email.
- **`operating_status` is mostly empty in the source** (≈22 % of records). It is exposed as
  information, never used as a default filter; null means "the source says nothing".
- **Emails are delivered as the source publishes them.** This Actor does not claim to verify
  deliverability.
- **Emails and phone numbers are personal data in many jurisdictions** — it is your responsibility to
  have a lawful basis for the outreach you run.

# Actor input Schema

## `country` (type: `string`):

Two-letter country code, e.g. US, CA, BR, ZA. Leave empty for all countries in the index.

## `city` (type: `string`):

Partial, case-insensitive match on the city name (e.g. Tampa, Mississauga).

## `region` (type: `string`):

Partial, case-insensitive match on the region or state (e.g. FL, Ontario).

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

Partial, case-insensitive match on the business category (e.g. roofing, plumb, dentist, real\_estate).

## `web_presence` (type: `string`):

A Facebook or Instagram page, a free builder subdomain (wixsite, wordpress.com, blogspot...), a Linktree or a directory profile does NOT count as a company website. Decided from the source field itself, with no network call.

## `verify_sites` (type: `boolean`):

Fetch the remaining domains and classify each one: alive, dead (DNS failure, 404, refused, parked domain), free\_page (redirects to a social page or a free builder) or undetermined (WAF block, timeout). A blocked request is never reported as a dead site.

## `site_state` (type: `string`):

Filter on the website state. The dead, free\_page and alive values need verify sites live to be meaningful.

## `max_verifications` (type: `integer`):

Hard cap on outbound checks, so the cost of a run stays predictable. 1 000 websites take about 1 minute and cost roughly $0.01.

## `phone_required` (type: `boolean`):

Keep only businesses that also have a phone number.

## `limit` (type: `integer`):

Hard cap on rows returned.

## `offset` (type: `integer`):

Skip the first N matching rows — use it to page through a large segment.

## Actor input object example

```json
{
  "country": "US",
  "category": "roofing",
  "web_presence": "any",
  "verify_sites": false,
  "site_state": "any",
  "max_verifications": 1000,
  "phone_required": false,
  "limit": 100,
  "offset": 0
}
```

# Actor output Schema

## `leads` (type: `string`):

One row per business: name, industry, address, all known emails and phones, website, and etat\_site (sans\_site, gratuit, vivant, mort, indetermine).

## `no_real_website` (type: `string`):

Same rows filtered to the businesses whose website is missing, a social page, a free builder subdomain, or dead.

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("teamkamkod/local-business-leads").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("teamkamkod/local-business-leads").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 '{}' |
apify call teamkamkod/local-business-leads --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,teamkamkod/local-business-leads"
        }
    }
}
```

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/NYeYmxe69KwSz3zn7/builds/y0bNUDWzFymPFcfsC/openapi.json