# Building Permit Leads Scraper - Contractor Phone & Email (`intelscrape/building-permit-scraper`) Actor

Turn building permits into scored contractor leads. Owner + contractor name, phone, email & license across 60+ US cities (any city via auto-discovery). HOT/WARM/COLD lead scoring, new-leads-only incremental mode, dedupe.

- **URL**: https://apify.com/intelscrape/building-permit-scraper.md
- **Developed by:** [IntelScrape](https://apify.com/intelscrape) (community)
- **Categories:** Lead generation, Real estate, Business
- **Stats:** 65 total users, 24 monthly users, 94.4% runs succeeded, 2 bookmarks
- **User rating**: 1.00 out of 5 stars

## Pricing

from $5.00 / 1,000 permits

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## Building Permit Scraper — Construction Leads

Generate hyper-targeted commercial and residential construction leads by scraping recently issued building permits directly from city and county government databases.

### 🚀 Who is this for?

If your business sells to contractors, homeowners, or real estate developers, building permits are the ultimate intent signal.
- **Roofing & HVAC Companies:** Reach out to homeowners right after a permit is filed.
- **B2B Suppliers:** Sell materials to contractors who just won massive commercial projects.
- **Lenders:** Offer project financing to real estate developers.

### 🎯 Features

- **Multi-City Support:** Automatically searches across hundreds of available US municipal databases.
- **Advanced Filtering:** Filter by Permit Type (e.g., New Construction, Roofing, Electrical) and Minimum Project Cost to ensure you only get high-value leads.
- **Contractor Enrichment:** Turn on "Skip Trace PRO" to automatically look up the contractor's phone number, email, and website based on the business name listed on the permit.
- **Incremental Mode:** Run the bot daily. It will remember past runs and only extract brand new permits filed in the last 24 hours.

### 🛠️ How to Use

1. Enter your target City or State.
2. Select your Permit Type and Time Period (e.g., "Last 7 days").
3. Set your Minimum Project Cost (e.g., "$10,000" to weed out small jobs).
4. Turn on Contractor Enrichment to get phone numbers.
5. Click **Start** and get your fresh construction leads!

# Actor input Schema

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

Enter a US city name (e.g., Dallas, Chicago, Miami). Leave empty to search entire state or nationwide.
## `extractTop100` (type: `boolean`):

Bypass manual search and autonomously scan all 100 largest municipal databases sequentially using the Universal Discovery Core.
## `extractStateMatrix` (type: `boolean`):

Execute sequentially across all 50 US States autonomously extracting Socrata instances and injecting Walled-Garden targets. Extremely intensive.
## `state` (type: `string`):

Select a US State. Highly recommended for finding smaller cities.
## `permitType` (type: `string`):

What kind of permits are you looking for?
## `timePeriod` (type: `string`):

How far back do you want to search?
## `minCost` (type: `integer`):

Only show permits with estimated cost above this amount.
## `maxResults` (type: `integer`):

Maximum number of permit records to return.
## `addressFilter` (type: `string`):

Filter by street name (e.g., Broadway, Main St).
## `incrementalMode` (type: `boolean`):

If enabled, the scraper remembers past runs and only returns newly discovered permits.
## `enrichContractors` (type: `boolean`):

Automatically find contractor phone, email, and website by searching the web for their business. Falls back to Skip Trace PRO for personal name lookups. Adds additional PPE charges.
## `webhookUrl` (type: `string`):

Optional webhook URL to POST results to when the run completes.
## `csvUrl` (type: `string`):

Provide a link to a raw CSV file (e.g. Google Sheets Export) containing 'City' or 'Location' headers to process huge lists automatically.
## `maxCities` (type: `integer`):

When searching all cities: how many city portals to query.
## `maxPerCity` (type: `integer`):

Maximum records to fetch from each city portal.

## Actor input object example

```json
{
  "city": "Chicago",
  "extractTop100": false,
  "extractStateMatrix": false,
  "state": "All States",
  "permitType": "All Types",
  "timePeriod": "Last 30 days",
  "maxResults": 100,
  "incrementalMode": false,
  "enrichContractors": false,
  "maxCities": 50,
  "maxPerCity": 50
}
````

# Actor output Schema

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

City name where the permit was issued

## `state` (type: `string`):

US state abbreviation

## `permitNumber` (type: `string`):

Official permit reference number

## `address` (type: `string`):

Property street address

## `permitType` (type: `string`):

Classified permit category (NEW\_CONSTRUCTION, RENOVATION, DEMOLITION, etc.)

## `estimatedValueFormatted` (type: `string`):

Dollar-formatted project cost estimate

## `status` (type: `string`):

Current permit status

## `issueDate` (type: `string`):

Date the permit was issued

## `contractor` (type: `string`):

Contractor or applicant name

## `zipCode` (type: `string`):

Property zip code

## `source` (type: `string`):

Source portal identifier

## `description` (type: `string`):

Permit work 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 = {
    "city": "Chicago"
};

// Run the Actor and wait for it to finish
const run = await client.actor("intelscrape/building-permit-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 = { "city": "Chicago" }

# Run the Actor and wait for it to finish
run = client.actor("intelscrape/building-permit-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 '{
  "city": "Chicago"
}' |
apify call intelscrape/building-permit-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Building Permit Leads Scraper - Contractor Phone & Email",
        "description": "Turn building permits into scored contractor leads. Owner + contractor name, phone, email & license across 60+ US cities (any city via auto-discovery). HOT/WARM/COLD lead scoring, new-leads-only incremental mode, dedupe.",
        "version": "2.0",
        "x-build-id": "l9oqAGkVYO7aJzxrW"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/intelscrape~building-permit-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-intelscrape-building-permit-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/intelscrape~building-permit-scraper/runs": {
            "post": {
                "operationId": "runs-sync-intelscrape-building-permit-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/intelscrape~building-permit-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-intelscrape-building-permit-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",
                "properties": {
                    "city": {
                        "title": "City",
                        "type": "string",
                        "description": "Enter a US city name (e.g., Dallas, Chicago, Miami). Leave empty to search entire state or nationwide."
                    },
                    "extractTop100": {
                        "title": "Extract Top-100 USA Cities (Mass Execution)",
                        "type": "boolean",
                        "description": "Bypass manual search and autonomously scan all 100 largest municipal databases sequentially using the Universal Discovery Core.",
                        "default": false
                    },
                    "extractStateMatrix": {
                        "title": "National Scan (2,500 Cities)",
                        "type": "boolean",
                        "description": "Execute sequentially across all 50 US States autonomously extracting Socrata instances and injecting Walled-Garden targets. Extremely intensive.",
                        "default": false
                    },
                    "state": {
                        "title": "State",
                        "enum": [
                            "All States",
                            "AL",
                            "AK",
                            "AZ",
                            "AR",
                            "CA",
                            "CO",
                            "CT",
                            "DE",
                            "FL",
                            "GA",
                            "HI",
                            "ID",
                            "IL",
                            "IN",
                            "IA",
                            "KS",
                            "KY",
                            "LA",
                            "ME",
                            "MD",
                            "MA",
                            "MI",
                            "MN",
                            "MS",
                            "MO",
                            "MT",
                            "NE",
                            "NV",
                            "NH",
                            "NJ",
                            "NM",
                            "NY",
                            "NC",
                            "ND",
                            "OH",
                            "OK",
                            "OR",
                            "PA",
                            "RI",
                            "SC",
                            "SD",
                            "TN",
                            "TX",
                            "UT",
                            "VT",
                            "VA",
                            "WA",
                            "WV",
                            "WI",
                            "WY"
                        ],
                        "type": "string",
                        "description": "Select a US State. Highly recommended for finding smaller cities.",
                        "default": "All States"
                    },
                    "permitType": {
                        "title": "Permit type",
                        "enum": [
                            "All Types",
                            "New Construction",
                            "Renovation / Remodel",
                            "Demolition",
                            "Roofing",
                            "Solar / Photovoltaic",
                            "Electrical",
                            "Plumbing",
                            "HVAC / Mechanical",
                            "Fire Protection",
                            "Addition / ADU",
                            "Commercial",
                            "Sign"
                        ],
                        "type": "string",
                        "description": "What kind of permits are you looking for?",
                        "default": "All Types"
                    },
                    "timePeriod": {
                        "title": "Time period",
                        "enum": [
                            "Last 7 days",
                            "Last 30 days",
                            "Last 90 days",
                            "Last 6 months",
                            "Last year",
                            "Last 2 years",
                            "All time"
                        ],
                        "type": "string",
                        "description": "How far back do you want to search?",
                        "default": "Last 30 days"
                    },
                    "minCost": {
                        "title": "Minimum project cost ($)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only show permits with estimated cost above this amount."
                    },
                    "maxResults": {
                        "title": "How many results",
                        "minimum": 10,
                        "maximum": 50000,
                        "type": "integer",
                        "description": "Maximum number of permit records to return.",
                        "default": 100
                    },
                    "addressFilter": {
                        "title": "Street name filter",
                        "type": "string",
                        "description": "Filter by street name (e.g., Broadway, Main St)."
                    },
                    "incrementalMode": {
                        "title": "Incremental Mode (New Permits Only)",
                        "type": "boolean",
                        "description": "If enabled, the scraper remembers past runs and only returns newly discovered permits.",
                        "default": false
                    },
                    "enrichContractors": {
                        "title": "Enrich Contractor Contacts (Skip Trace PRO)",
                        "type": "boolean",
                        "description": "Automatically find contractor phone, email, and website by searching the web for their business. Falls back to Skip Trace PRO for personal name lookups. Adds additional PPE charges.",
                        "default": false
                    },
                    "webhookUrl": {
                        "title": "Webhook URL (Make.com / Zapier)",
                        "type": "string",
                        "description": "Optional webhook URL to POST results to when the run completes."
                    },
                    "csvUrl": {
                        "title": "📄 Bulk CSV Upload (URL)",
                        "type": "string",
                        "description": "Provide a link to a raw CSV file (e.g. Google Sheets Export) containing 'City' or 'Location' headers to process huge lists automatically."
                    },
                    "maxCities": {
                        "title": "Max cities to scan (advanced)",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "When searching all cities: how many city portals to query.",
                        "default": 50
                    },
                    "maxPerCity": {
                        "title": "Max results per city (advanced)",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum records to fetch from each city portal.",
                        "default": 50
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
