# New Business Leads Scraper - 7 US Markets (`maydit/us-business-licenses-scraper`) Actor

New business leads scraper for 7 US city & statewide registries. Export newly registered businesses with address, phone & email to CSV/JSON.

- **URL**: https://apify.com/maydit/us-business-licenses-scraper.md
- **Developed by:** [Brandt May](https://apify.com/maydit) (community)
- **Categories:** Lead generation, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## New Business Leads Scraper - 7 US City & Statewide Registries

> Turn public new-business registrations from 7 major US markets into one fresh, ready-to-call lead list.

### What it does

This is a **new business leads scraper** that pulls **newly registered businesses** from 7 official US registries in a single actor: Chicago, New York City, San Francisco, Seattle, Los Angeles, and the statewide registries of Connecticut and Colorado. Instead of running one scraper per city or one query per state, you get consolidated **new business registrations data** across all 7 markets in one export. It isolates freshly issued licenses (for example, Chicago `ISSUE`-type records) so you target brand-new businesses, and several sources return **phone and email** alongside the registration - fields that most **business license scraper** tools never expose. Results export straight to CSV or JSON for your CRM.

### Who it's for

- **B2B sales and lead-generation teams** building lists of new businesses to prospect
- **Marketing agencies** offering local lead lists to clients
- **Data providers and list brokers** enriching or reselling business registration feeds
- **Franchise, insurance, and banking sales reps** targeting newly opened companies
- **Commercial services** (POS, payroll, signage, cleaning, insurance) that sell to businesses in their first weeks

### What you get / Output

Each record contains the following fields (availability varies by source):

| Field | Description |
|---|---|
| `businessName` | Legal name of the registered business |
| `dbaName` | "Doing business as" / trade name, when provided |
| `industry` | Business category or license type |
| `naicsCode` | NAICS industry classification code |
| `address` | Street address of the business |
| `city` | City of the registered business |
| `zip` | ZIP / postal code |
| `phone` | Contact phone number (available on some sources) |
| `email` | Contact email (available on some sources) |
| `registeredDate` | Date the license / registration was issued |
| `expirationDate` | License expiration date, when provided |
| `status` | Current record status |
| `recordId` | Unique source record identifier (for deduping) |
| `ownerOrAgent` | Owner or registered agent name, when provided |
| `latitude` | Geographic latitude |
| `longitude` | Geographic longitude |

### Input / How to query

Configure the run with these inputs:

- **Sources** - pick any combination of the 7 markets: Chicago, NYC, San Francisco, Seattle, Los Angeles, Connecticut (statewide), Colorado (statewide)
- **Registered date range** - limit results to a start/end window to pull only recently registered businesses
- **Business name** - filter to matching business names
- **Industry** - narrow to a specific business category or license type
- **Newly-issued mode** - isolate freshly issued licenses (e.g. Chicago `ISSUE`-type records) so you get first-time registrations rather than renewals

### Example use cases

1. **Fresh outbound lists** - An insurance agent pulls all new registrations in Los Angeles and Chicago from the last 30 days, filters by industry, and works the ones with a `phone` and `email`.
2. **Agency lead product** - A marketing agency schedules weekly runs across all 7 markets and delivers a de-duplicated new-business list to each local client.
3. **Franchise / banking prospecting** - A business-banking rep monitors Connecticut and Colorado statewide registrations to reach owners before competitors do.
4. **Data enrichment feed** - A data provider ingests `businessName`, `naicsCode`, `address`, and `recordId` to append new records to an existing registry database.
5. **Territory targeting** - A local services company filters by `city` and `zip` (plus `latitude`/`longitude`) to build a route-ready list of newly opened businesses nearby.

### Recurring use / scheduling

Set the actor on an Apify **schedule** (daily or weekly) to run automatically and capture new registrations as they appear. Use a narrow **registered date range** on each run so you only fetch recent records. Because every record carries a unique `recordId`, you can de-duplicate across runs - key on `recordId` in your CRM or downstream pipeline so the same business is never imported twice. This turns the actor into a standing **new business registrations** monitor across all 7 markets.

### FAQ

#### How do I get a list of newly registered businesses?
Choose your target markets, set a recent **registered date range**, enable the newly-issued mode, and run the actor. You get a downloadable list of newly registered businesses with names, addresses, industry, and (on supported sources) phone and email.

#### Where can I find new business leads for my area?
This actor covers Chicago, NYC, San Francisco, Seattle, Los Angeles, plus statewide Connecticut and Colorado. Select the market(s) that match your area and filter by `city`, `zip`, or industry.

#### How can I scrape business license data by city?
Pick one or more of the 7 supported city/state sources in the input, then filter by date range, business name, or industry. Results include the license/registration details for each city you select.

#### How do I get new business registrations with phone and email?
Several of the included sources return `phone` and `email` fields alongside the registration. Availability varies by source, so filter your export to records where those fields are populated.

#### What is the best way to find newly opened businesses for sales?
Enable the newly-issued mode to isolate first-time licenses (not renewals), set a short registered date range, and schedule the run to repeat - so you're always working the freshest new-business leads.

#### Can I export new business license data to CSV?
Yes. Every run's dataset exports to CSV, JSON, Excel, and other formats directly from Apify, ready to import into your CRM or spreadsheet.

#### How do I get daily new business registration leads?
Put the actor on a daily Apify schedule with a rolling registered date range and de-dupe on `recordId`. Each run captures the latest registrations across your selected markets.

#### Which cities and states have public new business license data I can scrape?
This actor scrapes 7 public registries: Chicago, New York City, San Francisco, Seattle, and Los Angeles (city-level), plus Connecticut and Colorado (statewide).

### Data source & notes

Data comes from the official public business-license and registration registries of Chicago, New York City, San Francisco, Seattle, Los Angeles, the State of Connecticut, and the State of Colorado. These are publicly available government records. Field coverage varies by source - not every record includes `dbaName`, `phone`, `email`, `expirationDate`, or `ownerOrAgent`, and `phone`/`email` are only present on the sources that publish them. Always use the data in compliance with applicable outreach and privacy regulations.

# Actor input Schema

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

Which cities/states to scrape. Connecticut and Colorado are STATEWIDE registries.
## `registeredSince` (type: `string`):

Only businesses registered/licensed on or after this date (YYYY-MM-DD). THE key filter for fresh leads — e.g. last 30 days.
## `registeredUntil` (type: `string`):

Only businesses registered on or before this date (YYYY-MM-DD).
## `businessNameContains` (type: `string`):

Only businesses whose legal or DBA name contains this text (case-insensitive). Leave empty for all.
## `industryContains` (type: `string`):

Only businesses whose industry/license type contains this text (case-insensitive), e.g. 'food', 'construction', 'LLC'. Leave empty for all.
## `maxResultsPerSource` (type: `integer`):

Upper bound on records per source per run.
## `socrataAppToken` (type: `string`):

Optional free Socrata app token for higher rate limits on scheduled runs.

## Actor input object example

```json
{
  "sources": [
    "chicago",
    "new_york",
    "san_francisco",
    "seattle",
    "los_angeles",
    "connecticut",
    "colorado"
  ],
  "registeredSince": "2026-06-01",
  "maxResultsPerSource": 500
}
````

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("maydit/us-business-licenses-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("maydit/us-business-licenses-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 '{}' |
apify call maydit/us-business-licenses-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "New Business Leads Scraper - 7 US Markets",
        "description": "New business leads scraper for 7 US city & statewide registries. Export newly registered businesses with address, phone & email to CSV/JSON.",
        "version": "1.0",
        "x-build-id": "fA6VJ3fZhVbUO8sHl"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/maydit~us-business-licenses-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-maydit-us-business-licenses-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/maydit~us-business-licenses-scraper/runs": {
            "post": {
                "operationId": "runs-sync-maydit-us-business-licenses-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/maydit~us-business-licenses-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-maydit-us-business-licenses-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": "Sources",
                        "type": "array",
                        "description": "Which cities/states to scrape. Connecticut and Colorado are STATEWIDE registries.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "chicago",
                                "new_york",
                                "san_francisco",
                                "seattle",
                                "los_angeles",
                                "connecticut",
                                "colorado"
                            ],
                            "enumTitles": [
                                "Chicago, IL (new licenses)",
                                "New York, NY (new licenses)",
                                "San Francisco, CA (registrations)",
                                "Seattle, WA (license certificates)",
                                "Los Angeles, CA (active businesses)",
                                "Connecticut (statewide registry)",
                                "Colorado (statewide registry)"
                            ]
                        },
                        "default": [
                            "chicago",
                            "new_york",
                            "san_francisco",
                            "seattle",
                            "los_angeles",
                            "connecticut",
                            "colorado"
                        ]
                    },
                    "registeredSince": {
                        "title": "Registered since",
                        "type": "string",
                        "description": "Only businesses registered/licensed on or after this date (YYYY-MM-DD). THE key filter for fresh leads — e.g. last 30 days."
                    },
                    "registeredUntil": {
                        "title": "Registered until",
                        "type": "string",
                        "description": "Only businesses registered on or before this date (YYYY-MM-DD)."
                    },
                    "businessNameContains": {
                        "title": "Business name contains",
                        "type": "string",
                        "description": "Only businesses whose legal or DBA name contains this text (case-insensitive). Leave empty for all."
                    },
                    "industryContains": {
                        "title": "Industry contains",
                        "type": "string",
                        "description": "Only businesses whose industry/license type contains this text (case-insensitive), e.g. 'food', 'construction', 'LLC'. Leave empty for all."
                    },
                    "maxResultsPerSource": {
                        "title": "Max results per source",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Upper bound on records per source per run.",
                        "default": 500
                    },
                    "socrataAppToken": {
                        "title": "Socrata app token (optional)",
                        "type": "string",
                        "description": "Optional free Socrata app token for higher rate limits on scheduled 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
