# New Business Licenses Feed: 12 US & Canada Cities (`moment-data/city-new-business-licenses-feed`) Actor

Daily feed of new business licences from official open data: Chicago, San Francisco, Los Angeles, Seattle, Philadelphia, New Orleans, Baton Rouge, Norfolk, Delaware, Marin County, Calgary and Edmonton. Companies only: name, activity/NAICS, address, dates. Filters + 'new since last run'.

- **URL**: https://apify.com/moment-data/city-new-business-licenses-feed.md
- **Developed by:** [Luke Miller](https://apify.com/moment-data) (community)
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 business licenses

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## New Business Licenses Feed: 12 US & Canada Cities

A daily feed of **newly issued business licences and newly opened business locations** in **Chicago, San Francisco, Los Angeles, Seattle, Philadelphia, New Orleans, Baton Rouge, Norfolk (VA), Delaware (statewide), Marin County (CA), Calgary and Edmonton**, taken directly from each government's **official open-data portal**. One clean, normalised schema across all twelve sources, with a **"New since last run"** mode for daily schedules.

New licences are the earliest public signal that a business is opening: a restaurant applying before its launch, a contractor setting up in town, a salon, clinic, studio or shop getting ready to open its doors.

### Who it's for

- **B2B sales and local lead generation.** Reach new restaurants, bars, retailers, salons, clinics and contractors in their first weeks, when they buy POS systems, insurance, payroll, signage, fit-out, marketing, web, uniforms, cleaning and supplies.
- **Commercial real estate, brokers and franchise developers.** Track who is opening where, by ZIP, district and activity.
- **Agencies and brand-activation teams.** Spot new venues and retail openings for partnerships, launches and events.
- **Market researchers and economic developers.** Measure new-business formation by city, ZIP and NAICS sector.
- **AI agents.** Ask "which new restaurants got a licence in Chicago this week?" through the Apify API or MCP server.

### What you get

- `sourceCity`, `eventType` (`newBusinessLicense`), `eventDate` (issue / location start / opened date).
- `businessName` (trade name when it is a real brand, else legal name), `legalName`, `dbaName`, `entityType` (`llc`, `corporation`, `partnership`, `limited-company`, `company`, `public-or-nonprofit`, `trade-name`), `ownershipType` (Seattle, Baton Rouge, Philadelphia).
- `licenseType`, `businessActivity`, `naicsCode` (SF, LA, Seattle, Baton Rouge), `naicsDescription`, `licenseNumber`, `licenseId`, `licenseStartDate`, `expirationDate`.
- Business premises: `address` (apartment numbers removed; blank for home-based businesses), `city`, `state`, `zip`, `district` (ward / council / supervisor district), `neighborhood`, `latitude`, `longitude`, `homeBased`.
- `country` (`US` / `CA`), `datasetUrl`, `sourceDataset`, `retrievedAt`.

**Companies only, privacy by design.** Sole proprietors, individual licensees and person-named companies ("JOHN SMITH LLC") are dropped. Phone numbers, e-mails, owner / officer / contact names and mailing addresses are never read or output.

*Calgary and Edmonton* publish only a trade name (no legal name or owner). Their records are kept only for commercial (non-home) premises or names with a legal-form suffix, and only when the trade name does not read like a personal name (for example "KEN'S CLEANING" is dropped). Those records have `entityType` `trade-name` and `legalName` empty. Set `entityTypes` without `trade-name` if you want registered legal entities only.

| City | Official dataset (source link) | "New" means | Licence | Typical volume (companies) |
|---|---|---|---|---|
| Chicago, IL | [Business Licenses `r5kz-chrr`](https://data.cityofchicago.org/d/r5kz-chrr), application type ISSUE | new licence issued | City of Chicago Data Portal terms (free reuse) | ~100-150 / week |
| San Francisco, CA | [Registered Business Locations `g8m3-pdis`](https://data.sf.gov/d/g8m3-pdis) | new location registered for SF business tax (some outside SF) | DataSF (PDDL / public domain) | ~80 / week |
| Los Angeles, CA | [Active Businesses `6rrh-rzua`](https://data.lacity.org/d/6rrh-rzua) | new business tax registration (location start) | City of LA open data (free reuse) | ~50 / week |
| Seattle, WA | [Active Business License Tax Certificates `wnbq-64tb`](https://data.seattle.gov/d/wnbq-64tb) | licence start date | City of Seattle open data (public domain) | ~90 / week |
| Philadelphia, PA | [L\&I Business Licenses](https://opendataphilly.org/datasets/licenses-and-inspections-business-licenses/) (Carto API, rental / vacant-property licences excluded) | initial issue date | City of Philadelphia License (OpenDataPhilly terms of use) | ~50 / week |
| New Orleans, LA | [Occupational Business Licenses `hjcd-grvu`](https://data.nola.gov/d/hjcd-grvu) | business start date | City of New Orleans open data (free reuse) | ~5-10 / week |
| Baton Rouge, LA | [Businesses Registered with EBR Parish `xw6s-bcqm`](https://data.brla.gov/d/xw6s-bcqm) | business open date (open accounts) | Public domain | ~20 / week |
| Norfolk, VA | [Business Licenses `dpi6-sct5`](https://data.norfolk.gov/d/dpi6-sct5) | business opened date | City of Norfolk open data (free reuse) | ~5-10 / week |
| Delaware (statewide) | [Delaware Business Licenses `5zy2-grhr`](https://data.delaware.gov/d/5zy2-grhr) | licence valid-from date (Jan 1 renewals excluded) | Public domain | ~15-40 / week |
| Marin County, CA | [Active Business Licenses `jfy7-shxv`](https://data.marincounty.gov/d/jfy7-shxv) (unincorporated county) | licence issue date | ODbL (County of Marin) | ~2-5 / week (updated every few weeks) |
| Calgary, AB | [Calgary Business Licences `vdjc-pybd`](https://data.calgary.ca/d/vdjc-pybd) | first issue date (commercial premises) | Open Government Licence - City of Calgary | ~60-70 / week |
| Edmonton, AB | [City of Edmonton - Business Licences `qhi4-bdpu`](https://data.edmonton.ca/d/qhi4-bdpu) | original issue date | Open Government Licence - City of Edmonton | ~120 / week |

### Quick start

Run with the defaults (`{}`) to get the **36 newest company licences** (3 per city) from each city's latest 7 days of data. Takes about 10-20 seconds.

New restaurants, bars and cafés in the last two weeks:

```json
{ "keywords": ["restaurant", "bar", "cafe", "food", "brew"], "daysBack": 14, "maxItems": 200 }
```

New construction contractors in Seattle and LA (NAICS 23):

```json
{ "sources": ["seattle", "losAngeles"], "naicsPrefixes": ["23"], "daysBack": 30, "maxItems": 300 }
```

**Daily feed:** create a Schedule (e.g. every morning) with

```json
{ "mode": "sinceLastRun", "stateKey": "my-feed", "maxItems": 1000 }
```

Each run then delivers only licences you have not received before (the last 14 days are re-checked, because cities publish with a few days' lag). Use a different `stateKey` per saved search.

### Input

| Field | Meaning |
|---|---|
| `mode` | `window` (default, stateless) or `sinceLastRun` (only new records per `stateKey`) |
| `sources` | Cities: `chicago`, `sanFrancisco`, `losAngeles`, `seattle`, `norfolk`, `newOrleans`, `philadelphia`, `batonRouge`, `delaware`, `marin`, `calgary`, `edmonton` (default all) |
| `daysBack` | Window length in days, ending at each city's newest published date (default 7; 14 in sinceLastRun) |
| `date` | Optional YYYY-MM-DD window end for backfills |
| `keywords` | Any of these words in the name, trade name, licence type or activity |
| `naicsPrefixes` | NAICS code prefixes (SF, LA, Seattle, Baton Rouge only) |
| `zipCodes` | 5-digit ZIP codes |
| `entityTypes` | Restrict to LLCs, corporations, nonprofits, ... (`trade-name` = Calgary/Edmonton trade-name-only records) |
| `maxItems` | Cap per run (also caps your spend), default 36 |
| `stateKey` | Saved-state name for `sinceLastRun` |

### Sample output

```json
{
  "source": "chicago",
  "sourceCity": "Chicago",
  "sourceState": "IL",
  "eventType": "newBusinessLicense",
  "eventDate": "2026-10-29",
  "businessName": "TAVOLA PIENA",
  "legalName": "TAVOLA PIENA LLC",
  "dbaName": "TAVOLA PIENA",
  "entityType": "llc",
  "ownershipType": null,
  "licenseId": "3108871",
  "licenseNumber": "3108871",
  "licenseType": "Pop-Up Retail User",
  "businessActivity": "61-90 Day Retail Pop Up Vendor (Sale of General Merchandise)",
  "naicsCode": null,
  "naicsDescription": null,
  "homeBased": false,
  "address": "1821 W CHICAGO AVE 1ST",
  "city": "Chicago",
  "state": "IL",
  "zip": "60622",
  "district": "Ward 36",
  "neighborhood": "West Town",
  "latitude": 41.8958669323,
  "longitude": -87.6730484057,
  "licenseStartDate": "2026-10-29",
  "expirationDate": "2027-02-05",
  "datasetUrl": "https://data.cityofchicago.org/d/r5kz-chrr",
  "sourceDataset": "City of Chicago - Business Licenses (new issuances)",
  "retrievedAt": "2026-11-01T07:06:16.679Z"
}
```

See `sample-output.json` for more records. A run summary (per-city windows, rows read, records dropped by the company-only screen, errors) is saved as the `OUTPUT` record.

### Data sources and licences

All data comes from official government open-data portals without keys: the public Socrata SODA API (Chicago, DataSF, Los Angeles, Seattle, Norfolk, New Orleans, Open Data BR, Delaware Open Data, Marin County, Calgary, Edmonton) and the City of Philadelphia's public Carto SQL API (OpenDataPhilly). Licences are listed per source in the table above; all allow free reuse (Calgary and Edmonton data: Contains information licensed under the Open Government Licence - City of Calgary / City of Edmonton). The Actor identifies itself in its User-Agent and makes about 2 small requests per source per run. Data has been processed by this Actor (filtered to companies, normalised, deduplicated, apartment numbers removed). Not affiliated with any city. Licence "issue" or "start" dates are as published by each city; a few cities publish future-dated start dates, which are ignored until they arrive.

### Pricing

Pay per event. You pay only for records delivered.

| Event | Price | Charged |
|---|---|---|
| Actor start | $0.005 | once per run |
| Business record | $0.003 | per new business licence delivered to the dataset |

No separate platform-usage charges: compute is included in the event prices.

Example: the default run (36 records) costs $0.113. A daily all-city sinceLastRun schedule (about 80 new company licences per day) costs about $0.245 per day (about $7.35 per month). `maxItems` and Apify's *max cost per run* cap your spend; the Actor stops delivering when your budget is reached.

### FAQ

**Why not every licence?** Licences held by individuals and sole proprietors are dropped on purpose (privacy). Each record is an LLC, corporation, partnership, nonprofit or public body. A name screen also drops companies named after a person; it is heuristic, so a few brand names that look like personal names may be dropped too.

**Why are there no phone numbers or e-mails?** Some city datasets contain them, but this feed never reads them. Use the business name and address with your own enrichment tools.

**How fresh is it?** Chicago, San Francisco, Seattle, Los Angeles, Philadelphia, New Orleans, Baton Rouge, Delaware, Calgary and Edmonton refresh daily or near-daily; Norfolk a few times a week; Marin County every few weeks. The window always ends at each city's newest published date, so a run never comes back empty because a city has not published today yet.

**Why are New York City, Winnipeg or Kansas City not included?** Their licence datasets currently lag by a month or more (NYC DCWP since August, Winnipeg monthly, Kansas City since January), so they are not a useful daily signal. Berkeley and Cincinnati publish no usable issue date / business name. More cities may be added; ask in the Issues tab.

**Is this the same as new company registrations?** No. Secretary of State filings show new legal entities; city licences show businesses actually opening a location in a specific city, with an address and activity.

# Actor input Schema

## `mode` (type: `string`):

window (default): licences in the latest N days of each city's data, no saved state. sinceLastRun: only licences not delivered before for this State key; use for daily schedules.

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

Official city/county/state datasets to read (default: all 12).

## `daysBack` (type: `integer`):

Window length in calendar days, ending at the newest date published by each city (cities publish with 0-3 days lag). sinceLastRun uses 14 if not set.

## `date` (type: `string`):

Optional YYYY-MM-DD window end for backfills.

## `keywords` (type: `array`):

Any of these words in the business name, trade name, licence type or activity, e.g. restaurant, salon, construction, cannabis.

## `naicsPrefixes` (type: `array`):

e.g. 722 (restaurants & bars), 238 (specialty trade contractors), 5415 (IT services). Only SF, LA, Seattle and Baton Rouge publish NAICS codes, so this filter skips the other cities' records.

## `zipCodes` (type: `array`):

Only these 5-digit ZIP codes.

## `entityTypes` (type: `array`):

Empty = all. Calgary and Edmonton publish only trade names, so their records without a legal-form suffix are typed trade-name; leave it out to get legal entities only.

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

Maximum records per run (also caps your spend), split evenly between cities (default 36 = 3 per city).

## `stateKey` (type: `string`):

Separate saved state per saved search in sinceLastRun mode.

## Actor input object example

```json
{
  "mode": "window",
  "sources": [
    "chicago",
    "sanFrancisco",
    "losAngeles",
    "seattle",
    "norfolk",
    "newOrleans",
    "philadelphia",
    "batonRouge",
    "delaware",
    "marin",
    "calgary",
    "edmonton"
  ],
  "daysBack": 7,
  "keywords": [],
  "naicsPrefixes": [],
  "zipCodes": [],
  "entityTypes": [],
  "maxItems": 36,
  "stateKey": "default"
}
```

# Actor output Schema

## `licenses` (type: `string`):

One record per new licence / business location.

## `summary` (type: `string`):

Per-city windows, rows read, filters, errors and notes.

# 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("moment-data/city-new-business-licenses-feed").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("moment-data/city-new-business-licenses-feed").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{}' |
apify call moment-data/city-new-business-licenses-feed --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,moment-data/city-new-business-licenses-feed"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/NcCnxHQ9K2mam2T1k/builds/WidrgEell8OW5zo45/openapi.json