# Local Lead Finder | $2/1K | Businesses Without Websites (`apivault_labs/apify-actor-local-leads`) Actor

Scrape YellowPages by category and location. Find local businesses without a website — hottest leads for web agencies, SEO, and digital marketing. Get phone numbers, addresses, ratings, reviews. Filter by "no website" flag. $2 per 1,000 results.

- **URL**: https://apify.com/apivault\_labs/apify-actor-local-leads.md
- **Developed by:** [Apivault Labs](https://apify.com/apivault_labs) (community)
- **Categories:** Lead generation, Jobs
- **Stats:** 9 total users, 4 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

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

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

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

## Local Business Lead Finder — YellowPages Scraper for Web Agencies

Find local businesses that don't have a website. Scrape **YellowPages** by category and location, get phone numbers, addresses, ratings, and reviews. Automatically flags businesses without a website — the hottest leads for web design, SEO, and digital marketing agencies.

> **$2 per 1,000 results** · filter businesses without websites · up to 300 leads per run

### Why Businesses Without a Website = Hottest Leads

| Signal | What It Means |
|--------|---------------|
| No website | They NEED your web design / development services |
| Listed on YellowPages | They're actively trying to get customers |
| Phone number available | You can call them directly |
| Physical address | Local business, easy to visit in person |
| Has reviews but no site | Established business that just needs online presence |
| Category listed | You know exactly what industry they're in |

A plumber with 50 reviews and no website is losing customers every day to competitors who rank on Google. That's your pitch. That's your lead.

### Pricing

| Component | Cost |
|-----------|------|
| Actor start | **$0.00005** (one-time per run) |
| Per result | **$0.002** per business |
| 1,000 results | **~$2** |
| 10,000 results | **~$20** |

### Features

- 🔍 **Any category, any US city** — plumbers, restaurants, dentists, lawyers, you name it
- 🎯 **"No website" filter** — show ONLY businesses without a website (hottest leads)
- 📞 **Full contact data** — phone, address, city, state, email (when available)
- ⭐ **Ratings & reviews** — see how established the business is
- 📄 **Multi-page scraping** — up to 10 pages (~300 businesses per run)
- 🏷️ **Business details** — category, hours of operation, years in business
- 🔗 **Listing URLs** — direct link to YellowPages profile
- ⚡ **Parallel scraping** — multiple pages scraped simultaneously

### Input Parameters

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| `category` | string | ✅ | — | Business type: plumbers, restaurants, dentists, lawyers, etc. |
| `location` | string | ✅ | — | City + state: "New York NY", "Miami FL", "Los Angeles CA" |
| `pages` | integer | ❌ | 1 | Pages to scrape, ~30 businesses per page (max: 10) |
| `onlyWithoutWebsite` | boolean | ❌ | false | Only return businesses that have NO website |
| `maxConcurrency` | integer | ❌ | 3 | Parallel pages (1–5) |
| `timeout` | integer | ❌ | 120 | Timeout per page in seconds |

### Example Input

#### Find plumbers without websites in New York

```json
{
    "category": "plumbers",
    "location": "New York NY",
    "pages": 3,
    "onlyWithoutWebsite": true
}
````

#### Find all restaurants in Miami (with and without websites)

```json
{
    "category": "restaurants",
    "location": "Miami FL",
    "pages": 5
}
```

#### Find dentists without websites in Los Angeles

```json
{
    "category": "dentists",
    "location": "Los Angeles CA",
    "pages": 10,
    "onlyWithoutWebsite": true
}
```

### Output Example

Each result contains:

```json
{
    "Business Name": "Local Plumbing NYC",
    "Phone": "(718) 508-4834",
    "Address": "1 Chase Manhattan Plz, New York, NY 10005",
    "City": "New York",
    "State": "NY",
    "Rating": 4.5,
    "Reviews Count": 12,
    "Category": "Plumbers",
    "Website": "",
    "Email": "",
    "Hours": "Mon-Fri 8am-6pm",
    "Years in Business": "15",
    "Listing URL": "https://www.yellowpages.com/...",
    "hasWebsite": false
}
```

### Output Fields

| Field | Description |
|-------|-------------|
| `Business Name` | Name of the business |
| `Phone` | Phone number for direct outreach |
| `Address` | Full street address |
| `City` | City name |
| `State` | State abbreviation |
| `Rating` | Average customer rating (1–5) |
| `Reviews Count` | Number of customer reviews |
| `Category` | Business category on YellowPages |
| `Website` | Website URL (empty if none) |
| `Email` | Email address if available |
| `Hours` | Business hours of operation |
| `Years in Business` | How long they've been operating |
| `Listing URL` | Direct link to YellowPages profile |
| `hasWebsite` | `true` / `false` — easy filtering |

### Use Cases

#### 🌐 Web Design & Development Agencies

Find businesses that don't have a website and offer to build one. A plumber with 50 reviews and no website is losing leads to competitors every day. You solve that problem.

#### 📈 SEO & Digital Marketing Services

Businesses listed on YellowPages but missing a website are perfect for SEO packages. They already want customers — they just need to be found on Google.

#### 📱 Social Media Management

Local businesses without websites often rely on Facebook or Instagram. Offer social media management as a stepping stone to full online presence.

#### 🛒 Online Ordering & Booking Systems

Restaurants, salons, and service businesses without websites can't take online orders or bookings. Offer them a simple booking page or online menu.

#### 📍 Google Business Profile Optimization

Many businesses without websites also have unoptimized Google profiles. Offer GBP setup and optimization as an easy entry service.

#### 🏗️ Cold Outreach & Sales Teams

Build targeted call lists by industry and city. Phone numbers are included — your sales team can start calling immediately.

### How It Works

1. You provide a business category and location
2. Actor searches YellowPages for matching businesses
3. Multiple pages are scraped in parallel for speed
4. Each business is checked for website presence (`hasWebsite` flag)
5. If `onlyWithoutWebsite` is enabled, businesses with websites are filtered out
6. Clean, structured data is saved to your Apify dataset

### Popular Categories to Search

| Category | Why It Works |
|----------|-------------|
| Plumbers | High-value services, local SEO is critical |
| Electricians | Emergency services, need to be found fast |
| Restaurants | Online menus and ordering are essential |
| Dentists | Patients search online before booking |
| Lawyers | High-value clients, competitive market |
| Auto Repair | Local trust-based business |
| Landscaping | Seasonal demand, need online visibility |
| Cleaning Services | Growing market, low online competition |
| HVAC | Emergency services, local search dominant |
| Real Estate Agents | Online presence is everything |

### Tips for Best Results

- **Start with high-value categories** — plumbers, lawyers, dentists have the highest ROI for web services
- **Use `onlyWithoutWebsite: true`** — focus on the hottest leads only
- **Scrape multiple cities** — run the actor for each target city separately
- **Use 3+ pages** — first page has the most established businesses, later pages have newer ones
- **Combine with email finder** — some listings include email, for others use an email lookup tool

### FAQ

#### How many businesses can I get per run?

Each page returns ~30 businesses. With `pages: 10`, you get up to 300 businesses per run. Run multiple times with different categories or cities for larger datasets.

#### Does it work outside the US?

YellowPages.com covers US businesses. For other countries, check if they have a local YellowPages equivalent.

#### How accurate is the "no website" detection?

The actor checks the YellowPages listing for a website link. If the business hasn't added a website to their listing, `hasWebsite` will be `false`. Some businesses may have a website but haven't listed it — these are still good leads since their online presence is weak.

#### Can I search for multiple categories at once?

Currently one category per run. Run the actor multiple times with different categories and merge the results.

#### How often should I run this?

New businesses are added to YellowPages regularly. Running weekly or monthly keeps your lead list fresh.

#### Is the data real-time?

Yes — data is scraped live from YellowPages at the time of the run. You always get the latest listings.

### Integration Ideas

- **CRM import** — push leads to HubSpot, Salesforce, Pipedrive, or Close
- **Cold calling** — export phone numbers for your sales team
- **Email outreach** — combine with email finder for automated campaigns
- **Google Sheets** — export to spreadsheets for team collaboration
- **Zapier / Make** — automate your lead pipeline with no-code workflows
- **Slack alerts** — get notified when new businesses without websites are found

# Actor input Schema

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

Type of business to search for. Examples: plumbers, restaurants, dentists, auto-repair, lawyers, hair-salons.

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

City and state. Examples: 'New York NY', 'Los Angeles CA', 'Chicago IL', 'Miami FL'.

## `pages` (type: `integer`):

Number of result pages to scrape (each page ~30 businesses).

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

If true, only return businesses that don't have a website (hot leads for web agencies).

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

Number of pages to scrape in parallel.

## `timeout` (type: `integer`):

Maximum time to wait for each page.

## Actor input object example

```json
{
  "category": "plumbers",
  "location": "New York NY",
  "pages": 1,
  "onlyWithoutWebsite": false,
  "maxConcurrency": 3,
  "timeout": 120
}
```

# 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": "plumbers",
    "location": "New York NY"
};

// Run the Actor and wait for it to finish
const run = await client.actor("apivault_labs/apify-actor-local-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 = {
    "category": "plumbers",
    "location": "New York NY",
}

# Run the Actor and wait for it to finish
run = client.actor("apivault_labs/apify-actor-local-leads").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 '{
  "category": "plumbers",
  "location": "New York NY"
}' |
apify call apivault_labs/apify-actor-local-leads --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Local Lead Finder | $2/1K | Businesses Without Websites",
        "description": "Scrape YellowPages by category and location. Find local businesses without a website — hottest leads for web agencies, SEO, and digital marketing. Get phone numbers, addresses, ratings, reviews. Filter by \"no website\" flag. $2 per 1,000 results.",
        "version": "0.0",
        "x-build-id": "eaA0Nyhuunnu5XC6O"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/apivault_labs~apify-actor-local-leads/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-apivault_labs-apify-actor-local-leads",
                "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/apivault_labs~apify-actor-local-leads/runs": {
            "post": {
                "operationId": "runs-sync-apivault_labs-apify-actor-local-leads",
                "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/apivault_labs~apify-actor-local-leads/run-sync": {
            "post": {
                "operationId": "run-sync-apivault_labs-apify-actor-local-leads",
                "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": [
                    "category",
                    "location"
                ],
                "properties": {
                    "category": {
                        "title": "Business Category",
                        "type": "string",
                        "description": "Type of business to search for. Examples: plumbers, restaurants, dentists, auto-repair, lawyers, hair-salons."
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "City and state. Examples: 'New York NY', 'Los Angeles CA', 'Chicago IL', 'Miami FL'."
                    },
                    "pages": {
                        "title": "Pages to Scrape",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Number of result pages to scrape (each page ~30 businesses).",
                        "default": 1
                    },
                    "onlyWithoutWebsite": {
                        "title": "Only Without Website",
                        "type": "boolean",
                        "description": "If true, only return businesses that don't have a website (hot leads for web agencies).",
                        "default": false
                    },
                    "maxConcurrency": {
                        "title": "Max Concurrency",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Number of pages to scrape in parallel.",
                        "default": 3
                    },
                    "timeout": {
                        "title": "Timeout (seconds)",
                        "minimum": 30,
                        "maximum": 300,
                        "type": "integer",
                        "description": "Maximum time to wait for each page.",
                        "default": 120
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
