# Local Business Lead Scraper - Website Emails & Socials (`renzomacar/b2b-leads-finder`) Actor

Industry + city in, ready-to-send leads out: company name, address, phone, website, emails found on the company own site, LinkedIn/Facebook/Instagram profiles and tech stack. Scraped live at run time, never resold from a database. $8 per 1,000 leads - pay per lead, no seats, no subscription.

- **URL**: https://apify.com/renzomacar/b2b-leads-finder.md
- **Developed by:** [Renzo Madueno](https://apify.com/renzomacar) (community)
- **Categories:** Lead generation, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $7.44 / 1,000 leads

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

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

## B2B Leads Finder — Apollo & ZoomInfo Alternative with Emails

**Type an industry and a city, get complete B2B leads: company, website, phone, address, emails and social profiles — for $8 per 1,000 leads, no subscription, no seats, no credits that expire.** Built for agencies, freelancers and SDRs who need targeted local and niche business lists *today* without committing to a $49–$99/month platform they'll use twice.

Every lead is discovered live (not pulled from a stale database) and enriched by actually visiting the company's website to extract emails, extra phone numbers, LinkedIn/Facebook/Instagram/Twitter profiles, and the site's tech stack.

### What you get per lead

| Field | Example |
|---|---|
| `name` | Bayfront Dental Studio |
| `category` | Dentist |
| `address`, `city`, `country` | 120 SE 2nd Ave, Miami, United States |
| `phone` | +1 305-555-0134 |
| `website` | bayfrontdental.com |
| `email` + `emails[]` | smile@bayfrontdental.com |
| `socialProfiles` | linkedin, facebook, instagram, twitter |
| `websitePhones[]` | extra numbers found on the site |
| `techStack[]` | WordPress, Google Analytics |
| `rating`, `reviewsCount` | 4.8, 312 |
| `placeUrl` | Google Maps link for verification |

### How it works

1. **Discover** — searches the live web (Google Maps business index) for your industry + location and collects every matching company with its name, category, address, phone, rating and website.
2. **Enrich** — visits each company's actual website (homepage, /contact, /about…) and extracts emails, additional phones, social profiles and technology stack.
3. **Deliver** — one clean, consolidated row per company. Export to CSV, Excel, JSON, or pipe into your CRM via API.

Typical run: 50 leads in ~3–5 minutes.

### Honest comparison vs Apollo and ZoomInfo

| | **This Actor** | Apollo.io | ZoomInfo |
|---|---|---|---|
| Pricing | **$8 / 1,000 leads, pay as you go** | from $49/user/month | ~$15,000+/year contracts |
| Subscription / seats | **None** | Required | Required |
| Data freshness | **Scraped live at run time** | Database (can be stale) | Database |
| Local & niche businesses | **Excellent** (any niche, any city) | Weak for local SMBs | Weak for local SMBs |
| Contact-person data (names, job titles, direct dials) | Not included | **Excellent** | **Excellent** |
| Corporate org charts, intent data | Not included | Partial | **Excellent** |
| Emails | Company emails from the business's own website | Person-level emails | Person-level emails |

**Be clear about the fit:** this Actor is a *business discovery and contact extraction* engine — ideal for local businesses and niche B2B segments (dentists, HVAC, gyms, agencies, restaurants, clinics, law firms…). If you need person-level data on employees inside Fortune-500 companies (titles, direct dials, org charts), Apollo or ZoomInfo are the right tool. If you need fresh, verified SMB leads with real emails at 1/50th the cost — this is.

### Who uses this

- **Marketing agencies** — build prospect lists of local businesses per city + niche, at scale, per client.
- **Cold email / outreach** — feed Instantly, Smartlead, Lemlist or Woodpecker with fresh company emails.
- **SDRs & founders** — territory research: every competitor or prospect in a region, with contacts, in minutes.
- **Data teams** — enrich CRM records with websites, socials and tech stack via the Apify API.
- **Web designers / SEO consultants** — the `techStack` field finds businesses on outdated platforms (your pitch: "your site runs on X, I can do better").

### Pricing

Pay per event, no subscription:

- **$0.008 per lead** delivered ($8 per 1,000)
- $0.01 one-time Actor start fee

A 500-lead list costs about **$4**. The same list on Apollo requires a paid plan; on ZoomInfo, a sales call and an annual contract.

### Example input

```json
{
  "industry": "dentists",
  "location": "Miami, FL",
  "maxResults": 50,
  "maxPagesPerSite": 2
}
```

Advanced: pass `searchQueries` (e.g. `["dentists in Miami, FL", "dentists in Tampa, FL"]`) to cover several cities in one run.

### Covering a whole state or region, not one city

`location: "Texas"` does not give you Texas. A map search is anchored to one place, and it stops feeding results at roughly 120 companies, so a state-wide query silently returns the biggest metro plus noise. Cover a region by enumerating it in `searchQueries` instead — one line per city, all in the same run:

```json
{
  "searchQueries": [
    "HVAC contractors in Houston, TX",
    "HVAC contractors in San Antonio, TX",
    "HVAC contractors in Dallas, TX",
    "HVAC contractors in Austin, TX",
    "HVAC contractors in Fort Worth, TX",
    "HVAC contractors in El Paso, TX"
  ],
  "maxResults": 120
}
```

Rules of thumb that hold up in practice:

- **Go by population, not by map area.** The top 10–15 cities in a US state usually cover most of the addressable SMB market; adding the next 50 towns multiplies run time for a thin tail.
- **In a big metro, drop to suburb level.** "in Phoenix, AZ" and "in Scottsdale, AZ" return substantially different sets, and each gets its own result budget.
- **Duplicates are handled.** Companies are keyed by their Maps place across every query in the run, so overlapping city boundaries cost you nothing — one row, one charge.
- **Every row keeps its `searchQuery`,** so a 40-query state sweep can still be split by city afterwards for territory assignment.
- **Non-English markets:** set `language` and use the local term (`fontanero`, `Klempner`, `plombier`), not the English one — the search index is the local Maps index.

### What "verified" means here, and how to actually verify before sending

Lead vendors use "verified" for two very different things, and it matters for your bounce rate:

- **Published, not guessed.** Every address here was found printed on the company's own website — the contact page, the footer, a team page. It is not `firstname@domain` constructed from a pattern, which is what most cheap lists are. A published address is one the business chose to expose because it wants to be contacted there, so it is far likelier to be live and monitored.
- **Not SMTP-checked.** No mailbox is probed at scrape time. A published address can still be an abandoned inbox, a role account nobody reads, or a domain that has since changed hands.

So the honest answer: these are real, current, published business addresses, not verified mailboxes. If you are loading them into a cold-email tool and your sender domain matters, run the `email` column through a verification step first — [Email Verifier](https://apify.com/renzomacar/email-verifier) checks syntax, MX and disposable domains on a list before you send. On a list of a few thousand it costs a fraction of the scrape, and it is the difference between a warm sender reputation and a burned one.

### FAQ

**Is this a database like Apollo or ZoomInfo?**
No — and that's the point. Databases go stale; this Actor discovers businesses live at run time, so phones, websites and emails reflect what's published *right now*.

**Where do the emails come from?**
From each company's own website (homepage, contact, about pages). That makes them the emails the business actually wants to be reached at — typically far fewer bounces than database emails.

**Does every lead include an email?**
No. Roughly 40–70% of businesses with a website publish an email (varies by niche). Every lead includes the `emailFound` flag; enable `onlyWithWebsite` to skip companies that can never yield one. You pay the same low per-lead price either way, so filter downstream by `emailFound` if you only want emailable leads.

**Can I get employee names and job titles?**
Not from this Actor — it extracts company-level contacts. For person-level data, combine it with an email-finder tool using the domains this Actor gives you.

**How many leads can one run produce?**
Up to ~120 companies per search query (the practical ceiling of a single map search). Add more queries — one per city or per niche variation — to build lists of thousands.

**Is scraping this data legal?**
The Actor collects publicly available business information (the same data anyone sees in a search) and emails that businesses publish on their own websites. Comply with GDPR/CAN-SPAM in how you *use* the data, especially for outreach in the EU.

**Can I schedule it or use it via API?**
Yes — run it on a schedule (e.g. weekly per territory) or call it from the Apify API / SDK and read the dataset programmatically. Works with Zapier and Make too.

**What if a run finds nothing?**
Overly narrow searches can return zero results; the run still succeeds and you're only charged the $0.01 start fee. Broaden the industry term or use a bigger city.

### Related tools by the same author

- [Website Contact Finder](https://apify.com/renzomacar/website-contact-finder) — already have the websites? Extract emails and socials in bulk.
- [Email Verifier](https://apify.com/renzomacar/email-verifier) — verify MX/syntax/disposable before sending.
- [Company Enrichment API](https://apify.com/renzomacar/company-enrichment) — domain to tech stack and contacts.

# Actor input Schema

## `industry` (type: `string`):

What kind of companies you want, e.g. 'dentists', 'HVAC contractors', 'marketing agencies', 'SaaS companies'.

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

City, region or country to search in, e.g. 'Miami, FL', 'Austin, TX', 'London, UK'.

## `searchQueries` (type: `array`):

Full searches, one per line (e.g. 'dentists in Miami, FL'). When set, these override Industry + Location. Use several queries to cover multiple cities in one run.

## `maxResults` (type: `integer`):

Maximum number of companies to find per search. One search typically yields up to ~120 companies.

## `maxPagesPerSite` (type: `integer`):

How many pages to check on each company website when hunting for emails (homepage, /contact, /about...). More pages = more emails found, slightly slower run.

## `onlyWithWebsite` (type: `boolean`):

Drop companies that have no website (they can never have an email). You are not charged for dropped companies.

## `includeGenericEmails` (type: `boolean`):

Keep addresses like info@, hello@, contact@. Disable to keep only personal/role emails (fewer results).

## `language` (type: `string`):

Language code for the discovery search (e.g. 'en', 'es', 'fr', 'de').

## Actor input object example

```json
{
  "industry": "dentists",
  "location": "Miami, FL",
  "maxResults": 5,
  "maxPagesPerSite": 1,
  "onlyWithWebsite": false,
  "includeGenericEmails": true,
  "language": "en"
}
```

# Actor output Schema

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

Complete B2B leads (company, website, phone, address, emails, social profiles), one item per lead in the 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 = {
    "industry": "dentists",
    "location": "Miami, FL",
    "maxResults": 5,
    "maxPagesPerSite": 1
};

// Run the Actor and wait for it to finish
const run = await client.actor("renzomacar/b2b-leads-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 = {
    "industry": "dentists",
    "location": "Miami, FL",
    "maxResults": 5,
    "maxPagesPerSite": 1,
}

# Run the Actor and wait for it to finish
run = client.actor("renzomacar/b2b-leads-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 '{
  "industry": "dentists",
  "location": "Miami, FL",
  "maxResults": 5,
  "maxPagesPerSite": 1
}' |
apify call renzomacar/b2b-leads-finder --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,renzomacar/b2b-leads-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/h3DlnDUH52Esb6B7Y/builds/4oN8Z0naxrETwExSM/openapi.json