# Business license leads scraper (US and Canada) (`mangudai/business-license-leads-scraper`) Actor

Build local B2B lead lists from official city, county and state business license registers across 18 US and Canadian jurisdictions. Business name, trade name, licence type, activity, address, phone and issue date. Public open data, no API key.

- **URL**: https://apify.com/mangudai/business-license-leads-scraper.md
- **Developed by:** [Mangudäi](https://apify.com/mangudai) (community)
- **Categories:** Lead generation, Open source, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.01 / 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/docs.md):

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

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

## Business license leads scraper (US and Canada)

Turn official government business licence registers into a clean lead list. This Actor pulls live records from 18 city, county and state open data portals across the United States and Canada, normalizes wildly different column names into one shared schema, and hands you a table you can import straight into a CRM.

Every source is a public government dataset. No API key, no account, no cookies, no captcha.

### Why licence data sells

A newly issued business licence is one of the strongest buying signals there is. A restaurant that just got its food licence needs a POS, an accountant, insurance, signage, a supplier, a website. A new roofing contractor needs a truck wrap and lead flow. Filter by issue date, get the businesses that appeared this month, and you are talking to them before anyone else.

### What you get per record

| Field | Description |
| --- | --- |
| `businessName` | Legal entity name on the licence |
| `tradeName` | DBA or trading name |
| `businessActivity` | What the business actually does, as recorded by the city |
| `licenseType` | Licence category |
| `licenseStatus` | Active, issued, renewal due, and similar |
| `naicsCode`, `naicsDescription` | Industry classification where the register carries it |
| `ownerName` | Owner or applicant, where published |
| `phone`, `email` | Contact details, where published |
| `address`, `city`, `state`, `zip`, `fullAddress` | Business location |
| `latitude`, `longitude` | Coordinates, where published |
| `issueDate`, `expirationDate` | Licence dates, normalized to `YYYY-MM-DD` |
| `licenseNumber` | Licence or account number |
| `sourceName`, `source`, `country`, `portalUrl` | Which register the row came from |

Not every register publishes every field. Phone numbers come through on New York City, Seattle, New Orleans and Gainesville. Emails come through on Gainesville. Coordinates come through on most of the bigger cities.

### Jurisdictions covered

United States: Chicago IL, New York City NY, Seattle WA, Los Angeles CA, San Francisco CA, New Orleans LA, Denver CO, Kansas City MO, Berkeley CA, Marin County CA, Norfolk VA, Providence RI, Gainesville FL, Everett WA, and the state of Delaware.

Canada: Calgary AB, Edmonton AB, Winnipeg MB.

### Input

```json
{
    "sources": ["chicago", "new-york-city", "seattle"],
    "searchTerm": "restaurant",
    "issuedSince": "2026-06-01",
    "maxItems": 500,
    "sortNewestFirst": true
}
````

- **sources** picks the registers to read. Leave it alone for a solid default across five large cities.
- **searchTerm** is a full text search over every column of the register. Good values: `restaurant`, `salon`, `roofing`, `daycare`, `contractor`, `tobacco`, `liquor`, `landscaping`, or a company name.
- **issuedSince** keeps licences issued on or after that date. This is the new-business filter.
- **sortNewestFirst** orders each register by issue date and drops blank or future-dated records.
- **includeRawRecord** adds the untouched source record under `raw` if you want columns this Actor does not map.

### How it works

The Actor talks to each portal's Socrata Open Data API, pages through results 1,000 rows at a time, applies the keyword and date filters server side, and retries with backoff on rate limits. It waits a quarter second between pages so it stays a polite client. Dates arrive in at least four different formats across these portals and all of them come out as `YYYY-MM-DD`. Phone numbers arrive as raw digit strings and come out formatted, with placeholder numbers like `0000000000` dropped.

### Good uses

- Local B2B prospecting: insurance, accounting, POS, payroll, signage, web design, commercial cleaning
- Franchise and site selection research
- Competitive tracking in a city or trade
- Market sizing by activity type or NAICS code
- Enriching an existing CRM with licence status and expiry dates

### Notes

All data is published by the issuing government under its own open data terms and is already public. The Actor only reads published datasets and does not touch anything behind a login.

Some registers refresh nightly, others weekly or monthly, so the freshest issue date varies by city. Registers without an issue date column (Denver, Kansas City, Berkeley) return their natural order and ignore the date filter.

# Actor input Schema

## `sources` (type: `array`):

Official open data portals to pull from. Each one is a government business licence or business tax register.

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

Full text search across every column of the source register. Use it for a trade or licence type, for example restaurant, salon, roofing, daycare, contractor, cannabis, tobacco, or for a company name.

## `issuedSince` (type: `string`):

Keep only licences issued on or after this date. Set it to the last 30 days to get newly licensed businesses, which are the strongest leads. Registers without an issue date column ignore this filter.

## `maxItems` (type: `integer`):

Maximum number of business records to return across every selected jurisdiction.

## `maxItemsPerSource` (type: `integer`):

Optional per-jurisdiction cap. Leave empty to split the max results evenly across the jurisdictions you picked.

## `sortNewestFirst` (type: `boolean`):

Sort each register by issue date, newest first, and skip records with a blank or future-dated issue date. Turn this off to read a register in its natural order.

## `includeRawRecord` (type: `boolean`):

Add a raw field to every row holding the untouched record from the source portal, including columns this Actor does not map.

## Actor input object example

```json
{
  "sources": [
    "chicago",
    "new-york-city",
    "seattle",
    "los-angeles",
    "san-francisco"
  ],
  "searchTerm": "restaurant",
  "issuedSince": "2026-06-01",
  "maxItems": 200,
  "sortNewestFirst": true,
  "includeRawRecord": false
}
```

# Actor output Schema

## `results` (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 = {
    "sources": [
        "chicago",
        "new-york-city",
        "seattle",
        "los-angeles",
        "san-francisco"
    ],
    "maxItems": 200
};

// Run the Actor and wait for it to finish
const run = await client.actor("mangudai/business-license-leads-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 = {
    "sources": [
        "chicago",
        "new-york-city",
        "seattle",
        "los-angeles",
        "san-francisco",
    ],
    "maxItems": 200,
}

# Run the Actor and wait for it to finish
run = client.actor("mangudai/business-license-leads-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 '{
  "sources": [
    "chicago",
    "new-york-city",
    "seattle",
    "los-angeles",
    "san-francisco"
  ],
  "maxItems": 200
}' |
apify call mangudai/business-license-leads-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Business license leads scraper (US and Canada)",
        "description": "Build local B2B lead lists from official city, county and state business license registers across 18 US and Canadian jurisdictions. Business name, trade name, licence type, activity, address, phone and issue date. Public open data, no API key.",
        "version": "0.0",
        "x-build-id": "sgF5jHGnLEktaYS9f"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/mangudai~business-license-leads-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-mangudai-business-license-leads-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/mangudai~business-license-leads-scraper/runs": {
            "post": {
                "operationId": "runs-sync-mangudai-business-license-leads-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/mangudai~business-license-leads-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-mangudai-business-license-leads-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": {
                    "sources": {
                        "title": "Jurisdictions",
                        "type": "array",
                        "description": "Official open data portals to pull from. Each one is a government business licence or business tax register.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "chicago",
                                "new-york-city",
                                "seattle",
                                "los-angeles",
                                "san-francisco",
                                "new-orleans",
                                "denver",
                                "kansas-city-mo",
                                "berkeley-ca",
                                "marin-county-ca",
                                "norfolk-va",
                                "providence-ri",
                                "gainesville-fl",
                                "everett-wa",
                                "delaware",
                                "calgary",
                                "edmonton",
                                "winnipeg"
                            ],
                            "enumTitles": [
                                "Chicago, IL",
                                "New York City, NY",
                                "Seattle, WA",
                                "Los Angeles, CA",
                                "San Francisco, CA",
                                "New Orleans, LA",
                                "Denver, CO",
                                "Kansas City, MO",
                                "Berkeley, CA",
                                "Marin County, CA",
                                "Norfolk, VA",
                                "Providence, RI",
                                "Gainesville, FL",
                                "Everett, WA",
                                "Delaware (statewide)",
                                "Calgary, AB",
                                "Edmonton, AB",
                                "Winnipeg, MB"
                            ]
                        },
                        "default": [
                            "chicago",
                            "new-york-city",
                            "seattle",
                            "los-angeles",
                            "san-francisco"
                        ]
                    },
                    "searchTerm": {
                        "title": "Keyword filter",
                        "type": "string",
                        "description": "Full text search across every column of the source register. Use it for a trade or licence type, for example restaurant, salon, roofing, daycare, contractor, cannabis, tobacco, or for a company name."
                    },
                    "issuedSince": {
                        "title": "Issued on or after (YYYY-MM-DD)",
                        "type": "string",
                        "description": "Keep only licences issued on or after this date. Set it to the last 30 days to get newly licensed businesses, which are the strongest leads. Registers without an issue date column ignore this filter."
                    },
                    "maxItems": {
                        "title": "Max results",
                        "minimum": 1,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Maximum number of business records to return across every selected jurisdiction.",
                        "default": 200
                    },
                    "maxItemsPerSource": {
                        "title": "Max results per jurisdiction",
                        "minimum": 1,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Optional per-jurisdiction cap. Leave empty to split the max results evenly across the jurisdictions you picked."
                    },
                    "sortNewestFirst": {
                        "title": "Newest licences first",
                        "type": "boolean",
                        "description": "Sort each register by issue date, newest first, and skip records with a blank or future-dated issue date. Turn this off to read a register in its natural order.",
                        "default": true
                    },
                    "includeRawRecord": {
                        "title": "Include the raw source record",
                        "type": "boolean",
                        "description": "Add a raw field to every row holding the untouched record from the source portal, including columns this Actor does not map.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
