# New Business License Feed: Fresh Openings by City (`fayoussef/business-license-feed`) Actor

Every business, food, liquor and trade license newly issued in Chicago, Los Angeles, New York, Seattle and New Orleans, filtered to the trades you sell to, with only what you have not already seen. Official city open data, no key needed.

- **URL**: https://apify.com/fayoussef/business-license-feed.md
- **Developed by:** [Youssef Farhan](https://apify.com/fayoussef) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.80 / 1,000 new license records

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/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 License Feed: Fresh Openings by City

New business license leads from official city registers: every business, food, liquor and trade license newly issued in Chicago, Los Angeles, New York, Seattle and New Orleans. Filter to the trades you sell to, schedule it weekly, and each run returns only the openings you have not already been sent.

A newly issued license is about the highest intent signal a local sales team can get. Somebody just committed money and now needs a point of sale, an insurance policy, a sign, a linen contract, a payroll provider. That signal decays in days, which is why this is a feed and not an export.

### Two things that break every other new-business feed

**Future-dated licenses.** Every one of these registers contains licenses dated years ahead. Chicago holds rows starting in 2028, Seattle in 2029. So the obvious query for a "newest licenses" feed, sort by start date descending, does not return new businesses at all: it returns the same handful of pre-dated records every single run. The window here is bounded at **both** ends, so what you get is genuinely new.

**Three different date formats.** Chicago, New York and Los Angeles publish Socrata timestamps, Seattle stores `YYYYMMDD` as text, New Orleans a plain `YYYY-MM-DD` string. One comparison style silently returns nothing for two of the five cities, and nothing looks exactly like a quiet week. Each city is queried in its own format and every date comes back normalised to `YYYY-MM-DD`.

### Cities covered

| City | Typical new licenses per month | Notes |
|---|---|---|
| Chicago, IL | about 2,200 | License type and business activity, ward, coordinates |
| Los Angeles, CA | about 1,000 | NAICS description, council district |
| Seattle, WA | about 370 | NAICS, ownership type, phone |
| New Orleans, LA | about 190 | Business type, owner name, phone |
| New York City, NY | published in batches | DCWP licenses. The newest rows can run a few weeks behind the other cities |

Every source is official municipal open data. No API key, no account, no proxy.

Want a city that is not here? [Suggest it](https://automationbyexperts.com/apify).

### Filter to the businesses you actually sell to

The `keywords` field matches against the license type, category or NAICS description, so you can cut a general feed down to your own market:

- Restaurant and food service: `restaurant`, `food`, `caterer`, `mobile food`
- Bars and liquor: `liquor`, `tavern`, `alcohol`
- Personal care: `salon`, `barber`, `cosmetology`, `spa`
- Trades: `contractor`, `plumbing`, `electrical`, `hvac`
- Retail: `retail`, `grocery`, `tobacco`
- Care: `day care`, `child care`, `home health`

Leave it empty for every new license in the window.

### What you get back

| Field | What it is |
|---|---|
| `businessName` | The trading name, falling back to the legal name |
| `legalName` | The registered owner or legal entity, where published |
| `licenseType` | What the license is for |
| `businessActivity` | Chicago's more detailed activity description |
| `issueDate` | Normalised to `YYYY-MM-DD` across all five cities |
| `address`, `city`, `sourceState`, `postalCode` | Where they are |
| `phone` | Where the city publishes one |
| `licenseNumber`, `naicsCode` | For matching into your own systems |
| `sourceCity`, `sourceUrl` | Which register this came from |

Two ready-made views: **New licenses** for the full record, and **Call sheet** trimmed to name, trade, address and phone.

### Input

| Field | Type | What it does |
|---|---|---|
| `cities` | array | Which city registers to read |
| `lookbackDays` | integer | How far back to reach. Match it to your schedule: 7 for weekly, 30 for monthly |
| `keywords` | array | Only these kinds of business. Empty means all |
| `onlyNewSinceLastRun` | boolean | Skip licenses already sent. On by default, and what makes this a feed |
| `watchlistName` | string | One memory per feed, so "restaurants" and "contractors" stay separate |
| `maxResults` | integer | Cap per run, split evenly between the selected cities |
| Alerts | strings | Slack, Discord, Telegram or a webhook, all optional |

#### Example input

```json
{
    "cities": ["chicago", "la", "seattle", "neworleans"],
    "lookbackDays": 7,
    "keywords": ["restaurant", "food", "liquor"],
    "onlyNewSinceLastRun": true,
    "watchlistName": "restaurants"
}
```

#### Example output

```json
{
    "businessName": "HEM CAFE",
    "licenseType": "Limited-Service Restaurants",
    "naicsCode": "722513",
    "issueDate": "2026-09-19",
    "address": "3004 LAKE WASHINGTON BLVD",
    "city": "SEATTLE",
    "sourceState": "WA",
    "postalCode": "98144",
    "licenseNumber": "1234567",
    "sourceCity": "Seattle, WA",
    "sourceUrl": "https://data.seattle.gov/d/wnbq-64tb"
}
```

### Common questions

**How do I find new businesses that just opened?**
Schedule this weekly with `lookbackDays` set to 7 and `onlyNewSinceLastRun` on. Each run gives you the openings since the last one.

**Can I get only new restaurants or new bars?**
Yes. Put `restaurant`, `food` or `liquor` in `keywords` and the feed is filtered to those license types.

**Does it include phone numbers?**
Seattle, New Orleans and New York publish a phone number on many records. Chicago and Los Angeles do not, so those rows carry name and address only.

**Will I get the same business twice?**
Not while `onlyNewSinceLastRun` is on and the watchlist name stays the same. Licenses are remembered by city and license id.

**Why did New York return nothing?**
New York publishes DCWP licenses in batches rather than daily, so a short window can genuinely be empty there while the other cities are busy. Widen `lookbackDays` to see them.

**Is this the same as building permits?**
No. A building permit means construction. A business license means a business is opening or has opened, which is a different and usually later signal.

### Pricing

This Actor is billed per event, plus whatever your Apify plan covers. The events are:

| Event | What triggers it |
|---|---|
| Actor start | Each run starts |
| License record | Each new license returned |
| Notification sent | Each Slack, Discord, Telegram or webhook delivery |

The current rates are shown on this Actor's Store page. Free-plan runs return a small sample so you can see the output shape before subscribing; an [Apify plan](https://apify.com/pricing?fpr=youssef) lifts the cap.

### Limits worth knowing

- Five cities, not the whole country. Each one is covered from its official register rather than a scraped aggregator.
- Cities refresh their open data on their own schedules, so a license issued today may appear in a day or two.
- New Orleans publishes currently active licenses, so a business that has since closed drops out of the file.
- The memory of what has been sent holds the most recent 200,000 license ids per watchlist, which is far more than any lookback window can reach.

### Need something else?

Another city, county permits, health inspections, or this delivered straight into your CRM: youssefarhan24@gmail.com

# Actor input Schema

## `cities` (type: `array`):

Which city business-license registers to pull from. Each one is an official municipal open-data file and needs no account or key.

## `lookbackDays` (type: `integer`):

How far back to reach for newly issued licenses. Match it to how often you run this: 7 for a weekly schedule, 30 for a monthly one. The window is closed at today's date on purpose, because every one of these registers contains licenses pre-dated years into the future and they are not new businesses.

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

Optional. Filter by what the license is for, matched against the license type, category or NAICS description. For example restaurant, food, liquor, tavern, retail, salon, tobacco, day care, contractor. Leave empty for every new license in the window.

## `onlyNewSinceLastRun` (type: `boolean`):

The point of running this on a schedule. Licenses already returned by an earlier run are skipped, so a weekly run gives you this week's openings rather than the same list again. The first run returns the whole window and remembers it.

## `watchlistName` (type: `string`):

The name of the memory this run uses to skip licenses it has already sent you. Use a different name per feed, for example "restaurants" and "contractors", and each keeps its own history. Changing this name starts fresh, so the next run returns the whole window again.

## `maxResults` (type: `integer`):

A cap on how many licenses one run returns. With several cities selected the budget is split evenly between them, so one busy city cannot crowd out the rest.

## `slackWebhookUrl` (type: `string`):

Optional. Post the new openings to a Slack channel. Nothing is sent when there are none, so a quiet channel means a quiet week.

## `discordWebhookUrl` (type: `string`):

Optional. Post the same digest to a Discord channel.

## `telegramChatId` (type: `string`):

Optional. The chat to send the digest to. Fill this in together with the bot token below.

## `telegramBotToken` (type: `string`):

Optional. Your own bot's token, used only to deliver the digest to the chat above.

## `webhookUrl` (type: `string`):

Optional. Receive the new licenses as JSON, for your CRM, Zapier, Make or n8n.

## Actor input object example

```json
{
  "cities": [
    "chicago",
    "la",
    "seattle",
    "neworleans"
  ],
  "lookbackDays": 30,
  "keywords": [
    "restaurant",
    "food",
    "liquor"
  ],
  "onlyNewSinceLastRun": true,
  "watchlistName": "default",
  "maxResults": 1000
}
```

# Actor output Schema

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

Every newly issued license in the window that this feed has not sent you before, newest first.

## `contacts` (type: `string`):

The same openings reduced to a call sheet: name, what the license is for, address and phone.

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

The window that was read, how many licenses fell inside it, and how many were new.

# 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 = {
    "keywords": [
        "restaurant",
        "food",
        "liquor"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("fayoussef/business-license-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 = { "keywords": [
        "restaurant",
        "food",
        "liquor",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("fayoussef/business-license-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 '{
  "keywords": [
    "restaurant",
    "food",
    "liquor"
  ]
}' |
apify call fayoussef/business-license-feed --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,fayoussef/business-license-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/ObKhNG1bNhogfducO/builds/R8QYAWV7atsFMjbca/openapi.json