# Chicago New Business License Radar (`lukehunter/chicago-new-business-license-radar`) Actor

New Chicago business licenses as opening leads, refreshed daily from the City's official dataset: restaurants, liquor, retail, salons, and auto. Grouped by category and classified as new business, new location, or relocation. Businesses only - individuals are excluded. No account or API key needed.

- **URL**: https://apify.com/lukehunter/chicago-new-business-license-radar.md
- **Developed by:** [Luke Hunter](https://apify.com/lukehunter) (community)
- **Categories:** Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$10.00 / 1,000 new 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

## Chicago New Business License Radar

**For POS/payments providers, food and beverage distributors, commercial insurance brokers and local marketing agencies who want to reach a business in its first weeks.** One run returns a clean, priced list of new City of Chicago business licenses — restaurants, bars, salons, shops, auto shops — with new-business, new-location and relocation classification.
Pay-per-result: **$0.01 per license — 100 leads = $1.00.**
Try it free with Apify's monthly platform credit.

This Actor calls Chicago's own business-license dataset (`data.cityofchicago.org`, dataset `r5kz-chrr`, public and keyless) and turns the raw license feed into a clean, priced lead list: which business just got licensed, what kind of business it is, whether it's a brand-new opening or an existing operator adding a location, and where.

### Quick start (2 minutes)

1. Open the **Input** tab (no account or API key needed — the source is public).
2. Use this prefill for new food and liquor licenses in the last two weeks:

```json
{
  "sinceDays": 14,
  "categoryGroups": ["FOOD", "LIQUOR"],
  "openingTypes": ["NEW_BUSINESS"],
  "maxItems": 200
}
```

3. Click **Start**. Export the resulting lead list to CSV/JSON, or pull it via API into your CRM or dialer.

### Use cases

- **POS, payments and merchant-services vendors** reaching new restaurants and retailers before they've locked in a provider.
- **Food/beverage distributors and commercial insurance brokers** prospecting brand-new openings in their delivery or coverage area.
- **Local marketing, signage and linen/waste service vendors** targeting businesses in their first weeks, when vendor decisions are still open.
- **Franchise and territory researchers** tracking new-location vs. new-business openings by category and community area.

### Run it weekly

1. Set your `categoryGroups`/`openingTypes`/geography filters, then click **Schedule** on the run page (or create one under **Schedules** in the Apify Console).
2. Run it weekly, or daily with a short `sinceDays` window (e.g. 7), so each run mostly returns licenses you haven't seen yet.
3. Keep `recordId` as your dedupe key in your CRM/spreadsheet — it's stable across runs.
4. The City publishes with a 1–2 business day lag (see Limitations), so a weekly cadence with `sinceDays: 14` is a safer default than a very tight daily window.

### Chicago new business license list, new restaurants opening in Chicago

If you have ever wanted a "Chicago new business license list" or a feed of "new restaurants opening in Chicago" without paging through the City's data portal by hand, this is that list, refreshed on demand:

- **New business licenses** issued in the last 1–90 days, grouped into food, liquor, retail, personal services (hair/nails/spa/tattoo/fitness), auto, and temporary events.
- **New-business vs. new-location vs. relocation** classification, built from each account's full license history — a restaurant collecting food, liquor and patio licenses in the same few weeks reads as one opening, not three.
- **Businesses only.** Individual-type licenses (peddlers, pharmaceutical reps) and home-based businesses are excluded, and every delivered row's legal name is checked for a business-entity suffix (LLC, Inc., Corp., ...) — see **Privacy filtering** below.

### Example input

```json
{
  "sinceDays": 14,
  "categoryGroups": ["FOOD", "LIQUOR"],
  "openingTypes": ["NEW_BUSINESS"],
  "maxItems": 200
}
```

### Example output

Real output from a live run against `data.cityofchicago.org` on 2026-09-24 — a brand-new restaurant's opening-day license:

```json
{
  "recordId": "3086685-20260922",
  "licenseId": "3086685",
  "accountNumber": "527632",
  "legalName": "Wok the Wave LLC",
  "doingBusinessAs": "MiMi Dao",
  "licenseDescription": "Retail Food Establishment",
  "businessActivity": "Preparation of Food and Dining on Premises With Seating",
  "applicationType": "ISSUE",
  "dateIssued": "2026-09-22",
  "licenseStatus": "AAI",
  "address": "1516 E HARPER CT 1ST FLOOR",
  "city": "CHICAGO", "state": "IL", "zip": "60615",
  "communityAreaName": "HYDE PARK",
  "categoryGroup": "FOOD",
  "openingType": "NEW_BUSINESS",
  "accountFirstLicenseDate": "2026-09-22",
  "daysSinceIssued": 2,
  "sourceUrl": "https://data.cityofchicago.org/d/r5kz-chrr",
  "retrievedAt": "2026-09-24T06:24:07.774Z"
}
```

No field above is invented — it is a genuine record from the City's dataset. (The full schema has 30 fields; see **Output fields** below.)

| Field | Value |
|---|---|
| `legalName` | `Wok the Wave LLC` |
| `doingBusinessAs` | `MiMi Dao` |
| `licenseDescription` | `Retail Food Establishment` |
| `dateIssued` | `2026-09-22` |
| `address` | `1516 E HARPER CT 1ST FLOOR` |
| `communityAreaName` | `HYDE PARK` |
| `categoryGroup` | `FOOD` |
| `openingType` | `NEW_BUSINESS` |
| `daysSinceIssued` | `2` |

### Privacy filtering — businesses only, fail-closed

This Actor is built to return B2B leads, not personal data, and it errs toward excluding a row whenever that is ambiguous:

1. **Individual-type license categories are dropped outright**, whatever the legal name says: Peddler License (including Street Performer and senior variants), Pharmaceutical Representative, and Shared Housing Unit Operator. These are licenses issued to a person, not an entity.
2. **Home-based businesses are dropped** (`business_activity` containing "home-based"), even when the legal name carries an entity suffix.
3. **Every remaining row's `legal_name` must end in a recognized business-entity suffix** (LLC, PLLC, LLP, LP, Inc., Corp., Co., Ltd., PC, PLC, NFP, LWCA, ...), derived from 7,367 real legal names on the City's own license history. A blank name, or a name that looks like a person's (e.g. "JOHN SMITH", sole proprietors), is **dropped, not guessed at**.

**The honest trade-off:** on a real 30-day capture (2026-09-24, 665 raw new-license rows), this filter kept **508 rows (76%)** and excluded 24% — 63 individual-type licenses, 33 home-based businesses, and 61 rows whose legal name did not carry a recognizable business suffix. That last group includes some real businesses lost to conservative filtering: sole-proprietor businesses (a legitimate but unincorporated business run under a person's own name), and a small number of rows (well under 1% in our sample) where the City's own `legal_name` field embeds a "DBA" clause after the entity name (e.g. `"RECIPE LLC DBA CACHE"`) or truncates the suffix. We accept this false-negative rate deliberately: a fail-open filter that occasionally leaked a private individual's name would be worse than under-covering the market.

### Input

| Field | Default | Meaning |
|---|---:|---|
| `sinceDays` | 14 | Licenses issued in the last 1–90 days |
| `categoryGroups` | all | Any of `FOOD`, `LIQUOR`, `RETAIL`, `PERSONAL_SERVICES`, `AUTO`, `EVENT`, `OTHER` |
| `openingTypes` | all | Any of `NEW_BUSINESS`, `NEW_LOCATION`, `EXISTING_LOCATION`, `RELOCATION` (needs `includeChangeOfLocation`), `TEMPORARY_EVENT` |
| `includeChangeOfLocation` | false | Also return licenses re-issued because a business moved address |
| `communityAreas` | `[]` (citywide) | Chicago community areas, by name or number |
| `zipCodes` | `[]` (citywide) | 5-digit ZIP codes |
| `maxItems` | 500 | Hard cap on licenses delivered and charged this run (newest-issued first) |

### Output fields

| Field | Meaning |
|---|---|
| `recordId`, `licenseId`, `licenseNumber`, `accountNumber`, `siteNumber` | The City's own record and account identifiers |
| `legalName`, `doingBusinessAs` | Legal entity name and trade name |
| `licenseDescription`, `businessActivity`, `applicationType` | What kind of license, what the business does, and whether it's a new issue (`ISSUE`) or a location change (`C_LOC`) |
| `dateIssued`, `licenseStartDate`, `expirationDate`, `applicationCreatedDate` | Key dates |
| `licenseStatus`, `conditionalApproval` | Current status and whether it's a conditional approval |
| `address`, `city`, `state`, `zip`, `ward`, `communityArea`, `communityAreaName`, `neighborhood`, `latitude`, `longitude` | Location |
| `categoryGroup` | Derived: `FOOD`, `LIQUOR`, `RETAIL`, `PERSONAL_SERVICES`, `AUTO`, `EVENT`, or `OTHER` |
| `openingType` | Derived: see the table above; `null` if it could not be classified |
| `accountFirstLicenseDate`, `siteFirstLicenseDate` | Derived: the earliest license date on record for this account and this site, across its whole history |
| `daysSinceIssued` | Derived: days between `dateIssued` and when this run fetched it |
| `sourceUrl`, `retrievedAt` | The dataset this came from and when it was fetched |

### Limitations — read before you build automation on this

- **New-business classification depends on account history, not a birth-date field.** An account is `NEW_BUSINESS` if its earliest license of any kind was issued within 90 days of this one. A business whose very first Chicago license predates the dataset's practical lookback, or whose licenses are spread further apart than 90 days across a genuine single opening, may classify as `EXISTING_LOCATION` instead.
- **The City publishes with a lag of about 1–2 business days.** A `sinceDays` window of 1 can occasionally return nothing on that account; the Actor treats zero rows across 7+ days as a likely source outage and fails loudly rather than reporting a quiet, wrong success.
- **`RELOCATION` (`C_LOC`) rows are off by default.** Turn on `includeChangeOfLocation` to include them; they represent an existing business moving, not a fresh opening.
- **Fail-closed privacy filtering under-covers real businesses** — see **Privacy filtering** above. This is a deliberate trade-off, not a defect.
- **Categories are keyword-derived** from `license_description`/`business_activity` text, not an official City taxonomy field; an unusual combination could land in `OTHER`.

### Pricing and cost control

Pay-per-event: **$0.01 per delivered new business license.** Benchmarked against the closest live comparables on the Apify Store: `automation-lab/chicago-business-licenses` ($0.011), `rook-data-tools/new-food-service-license-leads` ($0.005), `parseforge`'s Chicago license feed ($0.021), and our own `chicago-contract-expiration-radar` ($0.015). $0.01 sits in the middle of that range — priced above the bare-feed comparables because of the category grouping and opening-type classification, and below the richer ones because those add no privacy filtering.

- `maxItems` is a hard cap on both delivered rows and total charge for the run.
- Delivered rows always equal charged rows: if your run's "Maximum cost per run" budget runs out mid-run, the Actor stops, finishes `SUCCEEDED`, and its status message says exactly how many licenses were delivered and that only those were charged — never a silent under-charge or a failed run.
- If the Actor is not monetized (e.g. running it yourself), every matching license is delivered free.

### FAQ

**Do I need a City of Chicago account or API key?** No. `data.cityofchicago.org` is public and keyless.

**Does this cover suburbs or all of Illinois?** No — this is the City of Chicago's own business-license dataset, city limits only.

**Why didn't a business I know about show up?** Either it licensed outside your `sinceDays` window, its license type is one of the excluded individual categories, its address reads as home-based, or its legal name didn't carry a recognizable business-entity suffix (see **Privacy filtering**). Widen `sinceDays` (up to 90) and re-run.

**Can I get sole proprietors too?** No, by design. This Actor only delivers rows whose legal name reads as a registered business entity — see **Privacy filtering**.

**Can I get everything since a specific date?** `sinceDays` covers up to 90 days per run; for a longer backfill, run it repeatedly with different windows, or schedule it daily and store the results yourself — `recordId` is stable, so de-duplication is straightforward.

**What does `openingType: null` mean?** The row's account had no other license on record at all (rare) and could not be classified as new-business vs. existing; it is left blank rather than guessed at.

### Related Actors

Other data tools from the same developer, built to the same standard: official or public sources, hard cost caps, and honest documentation of limits.

- **[Federal Register Rule Effective-Date Radar](https://apify.com/lukehunter/federal-rule-effective-date-radar)**: final federal rules about to take effect, with citations, dockets and urgency.
- **[Chicago Contract Recompete & Extension Radar](https://apify.com/lukehunter/chicago-contract-expiration-radar)**: expiring City of Chicago contracts with extension history, for recompete prospecting.
- **[Bank Branch Closings & Merger Radar (FDIC)](https://apify.com/lukehunter/bank-branch-merger-radar)**: new US bank branch closings, openings and mergers from the FDIC.
- **[NYC FDNY Contractor Leads & Hearing Radar](https://apify.com/lukehunter/fdny-violation-radar)**: fresh NYC fire-code summonses routed by remediation trade, with hearing dates.
- **[RCRA Enforcement Response Leads](https://apify.com/lukehunter/rcra-enforcement-radar)**: new EPA hazardous-waste (RCRA) enforcement actions and penalties, by state.
- **[Emerging Federal Contractor Radar](https://apify.com/lukehunter/emerging-federal-contractor-radar)**: companies that just won their first federal contracts, from USAspending.gov.
- **[Hospital Price Transparency Enforcement Leads](https://apify.com/lukehunter/hospital-price-transparency-enforcement-leads)**: hospitals with recent CMS price transparency warning notices, CAP requests and CMP notices.
- **[Hospital Ownership Change Radar](https://apify.com/lukehunter/hospital-chow-radar)**: hospitals that just changed owner, with buyer, seller and effective date from CMS filings.
- **[New Healthcare Organization NPI Radar](https://apify.com/lukehunter/new-healthcare-organization-npi-radar)**: newly registered healthcare organizations from CMS's weekly NPI file, by provider type.
- **[County Multifamily Building Permits Surge Radar](https://apify.com/lukehunter/county-multifamily-permit-surge-radar)**: U.S. counties where 5+ unit apartment permits are surging year over year.
- **[Zillow ZIP Code Property Search Scraper](https://apify.com/lukehunter/zillow-zip-scraper)**: for-sale listings by ZIP code with prices, price cuts and days on Zillow.
- **[Walmart Category Scraper](https://apify.com/lukehunter/walmart-category-scraper)**: product names, prices, was-prices and ratings from Walmart category pages.

# Actor input Schema

## `sinceDays` (type: `integer`):

Return licenses the City issued in this many days (1-90). The City publishes with a lag of about 1-2 business days.

## `categoryGroups` (type: `array`):

Only these kinds of business. Leave empty for all. EVENT = special-event food/liquor, pop-up retail and raffles (temporary).

## `openingTypes` (type: `array`):

Only these kinds of opening. Leave empty for all. NEW\_BUSINESS = the account's first-ever Chicago license was issued within 90 days of this one. NEW\_LOCATION = an established business's first license at this site. EXISTING\_LOCATION = an extra license at a site that already had one. RELOCATION needs 'Include change of location' on.

## `includeChangeOfLocation` (type: `boolean`):

Also return licenses re-issued because a business moved to a new address (application type C\_LOC).

## `communityAreas` (type: `array`):

Only these Chicago community areas, by name (e.g. WEST TOWN, LOOP) or number (e.g. 24, 32). Leave empty for the whole city. Rows without a community area are excluded when this is set.

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

Only these 5-digit ZIP codes. Leave empty for all.

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

Hard cap on licenses delivered (and charged) per run, 1-5000, default 500. Newest first.

## Actor input object example

```json
{
  "sinceDays": 14,
  "categoryGroups": [],
  "openingTypes": [],
  "includeChangeOfLocation": false,
  "communityAreas": [],
  "zipCodes": [],
  "maxItems": 20
}
```

# Actor output Schema

## `dataset` (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 = {
    "sinceDays": 14,
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("lukehunter/chicago-new-business-license-radar").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 = {
    "sinceDays": 14,
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("lukehunter/chicago-new-business-license-radar").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 '{
  "sinceDays": 14,
  "maxItems": 20
}' |
apify call lukehunter/chicago-new-business-license-radar --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,lukehunter/chicago-new-business-license-radar"
        }
    }
}
```

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/aMrTdRy91Vms6ab7v/builds/ooUcibzvK5P3NPeBV/openapi.json