# Plumber Lead Scraper (`automation-lab/plumber-lead-scraper`) Actor

Build plumber lead lists from Google Maps with names, phones, websites, addresses, ratings, reviews, and optional public email/social enrichment.

- **URL**: https://apify.com/automation-lab/plumber-lead-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (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.
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 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

## Plumber Lead Scraper

Find plumber business leads from public Google Maps search results by location.

### What does Plumber Lead Scraper do?

Plumber Lead Scraper helps you build local plumbing business lead lists from public Google Maps results. Add one or more locations, choose a plumber-related search term, and the actor saves business names, phone numbers, websites, addresses, ratings, review counts, categories, and Google Maps URLs.

### Who is it for?

- 🧰 Local SEO agencies building prospect lists for plumbing contractors.
- 📞 B2B sales teams selling software, ads, answering services, or financing to plumbers.
- 🏠 Home-service SaaS vendors researching plumbing businesses by market.
- 📊 Analysts comparing plumber coverage, reputation, and website adoption across cities.
- ✉️ Outreach teams that need a repeatable way to collect public business contact data.

### Why use this actor?

Plumber searches are a narrow, high-intent subset of local business data. Instead of scraping every Google Maps category and filtering later, this actor starts with plumber-focused queries and outputs a clean lead table.

### What data can you extract?

| Field | Description |
| --- | --- |
| `name` | Business name shown on Google Maps |
| `category` | Business category when available |
| `address` | Public street/local address |
| `phone` | Public phone number |
| `website` | Listed business website |
| `rating` | Average star rating |
| `reviewCount` | Number of public reviews |
| `hoursStatus` | Visible open/closed text when available |
| `googleMapsUrl` | Direct Maps listing URL |
| `placeId` | Place/CID token parsed from the Maps URL when available |
| `emails` | Optional public emails found on the business website homepage |
| `socialUrls` | Optional public social links found on the business website homepage |

### How much does it cost to scrape plumber leads?

The actor uses pay-per-event pricing: a small start fee plus a per-lead charge. Your final cost depends on the number of leads saved and whether you enable website email enrichment. Keep the first run small, then scale after you confirm the fields match your workflow.

### How to get started

1. Open the actor on Apify.
2. Enter one or more target locations.
3. Keep the default search term `plumbers` or use a more specific term.
4. Set the maximum leads per location.
5. Run the actor.
6. Download results from the dataset as JSON, CSV, Excel, XML, or HTML.

### Input options

#### Locations

Use city, state, region, or country names. Examples:

- `Austin, TX`
- `Phoenix, AZ`
- `Manchester, UK`
- `Toronto, Canada`

#### Search term

Default: `plumbers`.

Other useful options:

- `emergency plumber`
- `plumbing contractor`
- `drain cleaning service`
- `water heater repair`

#### Maximum leads per location

Controls how many Google Maps listings are saved from each location. Start with 10-25 leads while testing.

#### Extract emails from websites

When enabled, the actor visits each listed business website homepage and extracts public email addresses and social profile URLs. This can improve outreach lists but increases run time.

#### Proxy configuration

Google Maps can limit automated access. For larger or repeated runs, use Apify Proxy settings appropriate for your account and budget.

### Output example

```json
{
  "searchTerm": "plumbers",
  "location": "Austin, TX",
  "position": 1,
  "name": "Example Plumbing Co.",
  "category": "Plumber",
  "address": "123 Main St, Austin, TX",
  "phone": "+1 555-123-4567",
  "website": "https://exampleplumbing.com",
  "googleMapsUrl": "https://www.google.com/maps/place/...",
  "placeId": "...",
  "rating": 4.8,
  "reviewCount": 127,
  "hoursStatus": "Open",
  "emails": ["info@exampleplumbing.com"],
  "socialUrls": ["https://facebook.com/exampleplumbing"],
  "scrapedAt": "2026-05-30T09:00:00.000Z"
}
````

### Tips for best results

- ✅ Use specific locations instead of very broad countries.
- ✅ Keep test runs small before scaling.
- ✅ Try multiple search terms for different plumbing niches.
- ✅ Enable email enrichment only when you need website-level contact data.
- ✅ Review outputs before importing them into a CRM.

### Common plumber prospecting workflows

#### City-by-city outreach

Run one city per row in the `locations` input, then group results by `location` in your CRM.

#### Niche service research

Use search terms such as `water heater repair` or `drain cleaning service` to find specialized plumbing providers.

#### Reputation analysis

Sort by `rating` and `reviewCount` to identify highly reviewed businesses or lower-rated companies that may need marketing help.

#### Website gap analysis

Filter rows where `website` is missing to find businesses that may need web design or local SEO services.

### Integrations

- 🔁 Send CSV exports to Google Sheets.
- 🧾 Import leads into HubSpot, Salesforce, Pipedrive, or Airtable.
- ⚙️ Use Apify integrations to trigger runs from Make or Zapier.
- 🧠 Feed lead lists into enrichment, deduplication, or scoring workflows.

### API usage

#### Node.js

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/plumber-lead-scraper').call({
  locations: ['Austin, TX'],
  searchTerm: 'plumbers',
  maxResultsPerLocation: 10
});
console.log(run.defaultDatasetId);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/plumber-lead-scraper').call(run_input={
    'locations': ['Austin, TX'],
    'searchTerm': 'plumbers',
    'maxResultsPerLocation': 10,
})
print(run['defaultDatasetId'])
```

#### cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~plumber-lead-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"locations":["Austin, TX"],"searchTerm":"plumbers","maxResultsPerLocation":10}'
```

### MCP usage

Use Apify MCP with Claude tools:

`https://mcp.apify.com/?tools=automation-lab/plumber-lead-scraper`

#### Claude Code setup

```bash
claude mcp add apify-plumber-leads https://mcp.apify.com/?tools=automation-lab/plumber-lead-scraper
```

#### Claude Desktop JSON config

```json
{
  "mcpServers": {
    "apify-plumber-leads": {
      "url": "https://mcp.apify.com/?tools=automation-lab/plumber-lead-scraper"
    }
  }
}
```

Example prompts:

- "Run plumber lead scraper for Austin and summarize businesses without websites."
- "Find 25 emergency plumbers in Phoenix and return a CSV-ready table."
- "Compare review counts for plumbers in Dallas and Fort Worth."

### Data quality notes

The actor extracts data visible during the run. Google Maps layouts and availability can vary by country, language, listing type, and anti-bot responses. Some businesses may not publish phones, websites, or addresses.

### Legality and responsible use

This actor collects publicly visible business listing information. You are responsible for using the data lawfully, respecting applicable privacy, marketing, platform, and anti-spam rules, and honoring opt-out requests in your outreach workflows.

### FAQ

#### Why did my run return fewer leads than requested?

The selected location may have fewer visible results, Google Maps may have limited the session, or the query may be too narrow. Try a broader location or search term.

#### Why are emails missing?

Emails are only extracted when `includeWebsiteEmails` is enabled and when a public email appears on the business website homepage.

#### Why do some fields show null?

Not every business publishes every detail. Fields such as website, phone, hours, rating, and category depend on what Google Maps displays.

### Related scrapers

- https://apify.com/automation-lab/google-maps-reviews-scraper
- https://apify.com/automation-lab/google-search-results-scraper
- https://apify.com/automation-lab/business-lead-scraper

### Changelog

#### 0.1

Initial plumber lead extraction from Google Maps search results with optional website email/social enrichment.

### Support

If a run fails or returns unexpected output, include your input, run URL, and a short description of what you expected.

### Privacy

Do not upload sensitive data as input. The actor only needs locations and a public search term.

### Scaling guidance

For large market research projects, split runs by location, keep enrichment off during discovery, and enable enrichment only for shortlisted cities.

### Export formats

Apify datasets support JSON, CSV, Excel, XML, RSS, and HTML exports.

### Deduplication

Use `googleMapsUrl`, `placeId`, phone, or website as deduplication keys when merging multiple runs.

### CRM mapping

Map `name` to company name, `phone` to business phone, `website` to website, `address` to street address, and `location` to territory.

# Actor input Schema

## `locations` (type: `array`):

Cities, regions, or freeform areas to search for plumber businesses.

## `searchTerm` (type: `string`):

Google Maps search phrase. Use values like 'plumbers', 'emergency plumber', or 'plumbing contractor'.

## `maxResultsPerLocation` (type: `integer`):

How many plumber leads to save from each location.

## `includeWebsiteEmails` (type: `boolean`):

Visit each listed business website and extract public email addresses and social profile URLs from the homepage. This costs more time and bandwidth.

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

Optional Apify proxy settings. Google Maps may require high-quality proxies for larger runs.

## Actor input object example

```json
{
  "locations": [
    "Austin, TX"
  ],
  "searchTerm": "plumbers",
  "maxResultsPerLocation": 10,
  "includeWebsiteEmails": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": []
  }
}
```

# Actor output Schema

## `overview` (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 = {
    "locations": [
        "Austin, TX"
    ],
    "searchTerm": "plumbers",
    "maxResultsPerLocation": 10,
    "includeWebsiteEmails": false,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": []
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/plumber-lead-scraper").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 = {
    "locations": ["Austin, TX"],
    "searchTerm": "plumbers",
    "maxResultsPerLocation": 10,
    "includeWebsiteEmails": False,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": [],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/plumber-lead-scraper").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 '{
  "locations": [
    "Austin, TX"
  ],
  "searchTerm": "plumbers",
  "maxResultsPerLocation": 10,
  "includeWebsiteEmails": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": []
  }
}' |
apify call automation-lab/plumber-lead-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/plumber-lead-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Plumber Lead Scraper",
        "description": "Build plumber lead lists from Google Maps with names, phones, websites, addresses, ratings, reviews, and optional public email/social enrichment.",
        "version": "0.1",
        "x-build-id": "ARWoSaLrTZSNR8TcV"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~plumber-lead-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-plumber-lead-scraper",
                "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/automation-lab~plumber-lead-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-plumber-lead-scraper",
                "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/automation-lab~plumber-lead-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-plumber-lead-scraper",
                "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": [
                    "locations"
                ],
                "properties": {
                    "locations": {
                        "title": "Locations",
                        "type": "array",
                        "description": "Cities, regions, or freeform areas to search for plumber businesses.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchTerm": {
                        "title": "Search term",
                        "type": "string",
                        "description": "Google Maps search phrase. Use values like 'plumbers', 'emergency plumber', or 'plumbing contractor'.",
                        "default": "plumbers"
                    },
                    "maxResultsPerLocation": {
                        "title": "Maximum leads per location",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "How many plumber leads to save from each location.",
                        "default": 25
                    },
                    "includeWebsiteEmails": {
                        "title": "Extract emails from websites",
                        "type": "boolean",
                        "description": "Visit each listed business website and extract public email addresses and social profile URLs from the homepage. This costs more time and bandwidth.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional Apify proxy settings. Google Maps may require high-quality proxies for larger runs."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```