# Chicago Business License Search (City of Chicago open data) (`pennant/chicago-business-licenses`) Actor

Search City of Chicago business licences (BACP): new licences, restaurants, taverns, liquor, tobacco, auto repair, childcare and more, by licence type, activity, ward, community area, ZIP or date. Businesses only; no personal names.

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

## Pricing

from $2.00 / 1,000 business licence 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/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 Business License Search (City of Chicago open data)

**Pennant** — Official public records as clean, tested data feeds.

Search the business licences issued by the **City of Chicago Department of Business Affairs and Consumer Protection (BACP)**, published on the Chicago Data Portal and updated daily. Most businesses that operate from a Chicago address need a City licence, so this is a broad list of **new, renewing and existing Chicago businesses**: restaurants and food shops, taverns and liquor stores, tobacco retailers, auto repair shops, salons, childcare centres, manufacturers, garages and more. Each result is **one licence** with the legal and DBA name, licence type, business activities, status, issue, start and expiry dates, ZIP, ward, precinct, police district and community area.

This is not an official verification service. Confirm a licence with BACP before relying on it.

**Source:** Chicago Data Portal, BACP *Business Licenses* (`r5kz-chrr`), City of Chicago Data Terms of Use · updated daily. The City's required disclaimer and full credit are in the "Source, licence and disclaimer" section below.

### Who it's for

POS, payments, insurance, payroll and bookkeeping vendors looking for **newly licensed Chicago businesses**, food and beverage distributors who want new restaurants and liquor licences by community area, compliance and renewal services tracking **upcoming expirations**, commercial cleaning, signage and fit-out suppliers, and market researchers counting openings by licence type or ward.

**Use cases**

- A weekly feed of newly issued Chicago business licences (`applicationTypes: ["ISSUE"]`).
- Active taverns and liquor stores in chosen community areas, for beverage distributors.
- A renewal watch list of auto repair or retail food licences expiring next month.
- Hair, nail or tattoo businesses in one ward, using the business-activity search.

### Input examples

New retail food licences issued last month:

```json
{ "licenseDescriptions": ["Retail Food Establishment"], "applicationTypes": ["ISSUE"], "issuedFrom": "2026-10-01", "issuedTo": "2026-10-31", "maxItems": 500 }
```

Every new licence issued this week, any type:

```json
{ "applicationTypes": ["ISSUE"], "issuedFrom": "2026-11-09", "issuedTo": "2026-11-15", "maxItems": 1000 }
```

Active taverns and package-goods (liquor store) licences in Logan Square and Lake View:

```json
{ "licenseDescriptions": ["Tavern", "Package Goods"], "communityAreas": ["Logan Square", "Lake View"] }
```

Active auto repair licences expiring in December:

```json
{ "licenseDescriptions": ["Motor Vehicle Services License"], "expiresFrom": "2026-12-01", "expiresTo": "2026-12-31", "sort": "expiringSoon" }
```

Hair and nail businesses in ward 1:

```json
{ "businessActivityContains": "hair", "wards": ["1"] }
```

The first example at a glance:

| Field | Example value | What it does |
|---|---|---|
| `licenseDescriptions` | `["Retail Food Establishment"]` | One licence type |
| `applicationTypes` | `["ISSUE"]` | New licences only |
| `issuedFrom` / `issuedTo` | `2026-10-01` / `2026-10-31` | Issued last month |
| `maxItems` | `500` | Stop after 500 licences |

### Input

| Field | Type | Notes |
|---|---|---|
| `status` | `active` (default), `cancelledOrRevoked`, `all` | Active = issued (`AAI`) and expiry date today or later (Chicago time). `all` includes expired terms. |
| `licenseDescriptions` | string list | Licence type names (case-insensitive), e.g. `Retail Food Establishment`, `Tavern`, `Package Goods`, `Tobacco`, `Limited Business License`. |
| `licenseCodes` | string list | Numeric licence codes, e.g. `1010`, `1006`. |
| `businessActivityContains` | string | Text in the business activity, e.g. `hair`, `tattoo`, `repair`. |
| `applicationTypes` | string list | `ISSUE` (new licence), `RENEW`, `C_LOC` (moved), `C_CAPA`, `C_EXPA`, `C_SBA`. |
| `zipCodes` | string list | 5-digit ZIPs. |
| `wards` | string list | `1`-`50`. |
| `communityAreas` | string list | Chicago community area names, e.g. `Lake View`, `Logan Square`, `Near North Side`. |
| `nameContains` | string | Case-insensitive substring of the legal or DBA name. Only matches names that are returned. |
| `licenseNumbers` / `accountNumbers` | string lists | Public licence numbers or BACP account numbers. |
| `issuedFrom` / `issuedTo` | YYYY-MM-DD | Inclusive issue-date range (new-licence feed with `applicationTypes: ["ISSUE"]`). |
| `expiresFrom` / `expiresTo` | YYYY-MM-DD | Inclusive expiry-date range (renewal feed). |
| `sort` | `newest` (default), `oldest`, `expiringSoon`, `name`, `licenseNumber` | Date sorts skip records without that date. |
| `maxItems` | integer | Default 100. Each licence is one billable event. |
| `includeStreetAddress` | boolean | **Default off.** Adds the street line for business-named rows only. |
| `includeCoordinates` | boolean | **Default off.** Adds latitude/longitude for business-named rows only. |
| `requestDelayMs`, `maxRetries` | integers | Politeness delay (default 1,100 ms) and retries. |

**One result per licence.** The source has one record per licence term or change (new issue, each renewal, moves, activity changes): 1,211,708 records since 2002. Every sort ends with the licence number and newest record first, so the Actor returns the **latest record it meets for each licence number** and skips older records of the same licence. Licences, not owner accounts, are the unit because type, activity and expiry belong to the licence; use `accountNumbers` to see all licences of one business account.

Size on 2026-11-16 (source, before the privacy filter; changes daily): 52,150 active licence records covering 51,635 licence numbers and 35,869 business accounts. New licences (`ISSUE`) per month in 2026: 377 (Jan) to 714 (Jun), about 600-700 a month since April. Largest active types: Limited Business License 15,497, Retail Food Establishment 11,014, Regulated Business License 7,345, Consumption on Premises 2,804, Tobacco 1,774, Motor Vehicle Services 1,511. In a 1,000-record sample of active licences, 845 were returned after the privacy filter (104 with the legal name hidden, 84 with the DBA hidden) and 155 were skipped.

### Sample output (one item per licence)

Street address and coordinates are omitted under the default privacy setting:

```json
{
  "licenseNumber": "2017",
  "licenseId": "3100792",
  "accountNumber": "397",
  "siteNumber": "1",
  "legalName": "1555 CLUB, INC.",
  "dbaName": "WEEDS TAVERN",
  "legalNameHidden": false,
  "licenseCode": "1006",
  "licenseDescription": "Retail Food Establishment",
  "businessActivities": ["Retail Sales of Perishable Foods"],
  "businessActivityIds": ["775"],
  "applicationType": "RENEW",
  "licenseStatus": "AAI",
  "licenseStatusLabel": "Issued",
  "isCurrent": true,
  "licenseStatusChangeDate": null,
  "applicationCreatedDate": null,
  "applicationRequirementsComplete": "2026-09-15",
  "paymentDate": "2026-11-12",
  "conditionalApproval": false,
  "licenseStartDate": "2026-11-16",
  "expirationDate": "2028-11-15",
  "approvedForIssuanceDate": "2026-11-12",
  "dateIssued": "2026-11-13",
  "businessAddress": { "street": null, "city": "CHICAGO", "state": "IL", "zip": "60642" },
  "location": null,
  "ward": "2",
  "precinct": "12",
  "policeDistrict": "18",
  "communityArea": "8",
  "communityAreaName": "NEAR NORTH SIDE",
  "neighborhood": "RIVER NORTH",
  "specialServiceArea": null,
  "issuingAgency": "City of Chicago Department of Business Affairs and Consumer Protection (BACP)",
  "jurisdiction": "Chicago, IL",
  "sourceDataset": "https://data.cityofchicago.org/d/r5kz-chrr",
  "sourceRecordUrl": "https://data.cityofchicago.org/resource/r5kz-chrr.json?id=2017-20261116",
  "retrievedAt": "2026-11-16T14:55:56.706Z"
}
```

`licenseStatus` codes: `AAI` issued, `AAC` cancelled during its term, `REV` revoked, `REA` revocation appealed. `isCurrent` is true when the status is `AAI` and the expiry date is today or later.

**Example output as a table** (fictional rows, key columns only; street fields are null by default and not shown):

| licenseNumber | licenseDescription | dbaName | dateIssued | expirationDate | communityAreaName | zip |
|---|---|---|---|---|---|---|
| 2990001 | Retail Food Establishment | Lakeview Taqueria | 2026-10-08 | 2028-10-15 | LAKE VIEW | 60657 |
| 2990002 | Tavern | North Branch Tap | 2026-10-15 | 2028-10-15 | LOGAN SQUARE | 60647 |
| 2990003 | Motor Vehicle Services License | Westside Auto Care | 2026-10-22 | 2028-10-15 | AUSTIN | 60644 |

### Privacy (always on)

Many Chicago licences are held by sole proprietors under their own name. This Actor **never outputs a person's name**:

- A legal name that looks like a person (no business word, a trust or estate, a professional title such as CPA or MD, or a "First Last LLC" style name) is hidden. If the licence has a business-style DBA that does not repeat the person's name, the row is returned with `legalName: null` and `legalNameHidden: true`; otherwise the row is skipped.
- A DBA that looks like a person or a street address is returned as `null`.
- When any name is hidden, the BACP **account number** (which links to the City's separate Business Owners dataset) and the raw-record link are also left out.
- Rows with a hidden legal name never get a street address or map point, even with the opt-in switches on, because a sole proprietor's licensed address can be a home.
- The source has no phone or email columns. The City's **Business Owners** dataset (owner and officer names) is never used.
- A name search only matches names that are returned.

The filter is conservative: some real businesses with two-word names are skipped, and trade names can still contain a surname (for example "Example Plumbing Inc").

### Source, licence and disclaimer

Data: City of Chicago, Department of Business Affairs and Consumer Protection, "Business Licenses", Chicago Data Portal dataset [`r5kz-chrr`](https://data.cityofchicago.org/d/r5kz-chrr), used under the [City of Chicago Data Terms of Use](https://www.chicago.gov/city/en/narr/foia/data_disclaimer.html). Modified by this tool: one result per licence number, personal names left out, street and map point opt-in only, activities split into a list, dates reformatted.

Disclaimer required by the City of Chicago:

> This site provides applications using data that has been modified for use from its original source, www.cityofchicago.org, the official website of the City of Chicago. The City of Chicago makes no claims as to the content, accuracy, timeliness, or completeness of any of the data provided at this site. The data provided at this site is subject to change at any time. It is understood that the data provided at this site is being used at one’s own risk.

BACP is the authoritative source; data may be updated or corrected at any time. robots.txt `Crawl-delay: 1` and `/resource/` not disallowed; the Actor waits at least 1.1 seconds between pages and identifies itself. Not affiliated with or endorsed by the City of Chicago. The same notice is saved with every run as `SOURCE_NOTICE`.

### Pricing

Pay per event, billed by Apify:

| Event | Price |
|---|---|
| Run start (`apify-actor-start`) | $0.005 per run |
| Each licence returned (`result`) | $0.002 per licence |

**Worked example:** one run that returns 200 licences costs $0.005 + 200 × $0.002 = **$0.405**. A run of 1,000 licences costs **$2.005**.

To control spend, set `maxItems` (the Actor never returns more), and set a maximum cost per run in Apify. The Actor stops cleanly when it reaches the caller's max charge, and the licences already returned are kept.

### FAQ

**What does it cover, and what doesn't it?**

Business licences issued by the City of Chicago's BACP, one result per licence number. It does not cover suburbs, State of Illinois licences, or the City's separate Business Owners dataset, which this Actor never uses.

**What happens to personal names and addresses?**

The Actor never outputs a person's name. Legal names that look personal are hidden, and the row is kept only with a business-style DBA; otherwise it is skipped. When any name is hidden, the account number and raw-record link are left out too. Street address and map point are off by default and never returned for rows with a hidden legal name.

**Is this official data or a scrape?**

Official open data. The Actor reads each government portal's documented Socrata API, at a polite pace (at least 1.1 seconds between pages). It does not log in anywhere or scrape a private website.

**How do I cap the cost of a run?**

Set `maxItems`; each returned record is one billable result. The default is 100. You can also set a maximum cost per run in Apify, and the Actor stops cleanly when it reaches it.

**How fresh is the data?**

The City updates the dataset daily, and every run reads it live.

**Is Pennant affiliated with the source?**

No. Pennant is not affiliated with or endorsed by the City of Chicago or BACP. The source agency is the authoritative record; confirm anything important with it.

**Where do I get help?**

Email 51wrw1aj@mail.grokbot.com. For a bad or unexpected record, include the run ID and the record's ID or licence number.

### For AI agents

- **Purpose:** list or search City of Chicago business licences by type, activity, status, ward, community area, ZIP, issue or expiry date, or name.
- **Call when:** the user wants newly licensed Chicago businesses (a new-licence feed), restaurants, bars, liquor or tobacco licences in an area, upcoming licence expirations, or a lookup by licence or account number.
- **Minimal input:** `{}` (active licences, newest issued first, all types).
- **Cost control:** one `result` event per licence; set `maxItems`.

# Actor input Schema

## `status` (type: `string`):

Active = status AAI (issued) and expiration date today or later (Chicago time). 'All records' includes expired terms; one result per licence number either way.

## `licenseDescriptions` (type: `array`):

Exact licence type names, case-insensitive, e.g. Retail Food Establishment, Tavern, Package Goods, Tobacco, Motor Vehicle Services License, Children's Services Facility License, Limited Business License. Empty = all.

## `licenseCodes` (type: `array`):

Numeric licence type codes, e.g. 1010 (Limited Business License), 1006 (Retail Food Establishment).

## `businessActivityContains` (type: `string`):

Case-insensitive text in the business activity, e.g. hair, tattoo, liquor, repair (at least 3 characters).

## `applicationTypes` (type: `array`):

ISSUE (new licence), RENEW, C_LOC (moved), C_CAPA, C_EXPA, C_SBA. Use ISSUE with an issue-date range for a new-licence feed.

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

5-digit ZIPs of the licensed address.

## `wards` (type: `array`):

Chicago wards 1 to 50.

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

Chicago community area names, case-insensitive, e.g. Lake View, Logan Square, Near North Side, Loop, Lower West Side.

## `nameContains` (type: `string`):

Case-insensitive substring of the legal or DBA name (at least 2 characters). Only matches names that are returned.

## `licenseNumbers` (type: `array`):

Public licence numbers, e.g. 1694769.

## `accountNumbers` (type: `array`):

BACP account numbers (all licences of one business account).

## `issuedFrom` (type: `string`):

YYYY-MM-DD, inclusive (date the licence record was issued).

## `issuedTo` (type: `string`):

YYYY-MM-DD, inclusive.

## `expiresFrom` (type: `string`):

YYYY-MM-DD, inclusive. Use with expiresTo for upcoming renewals.

## `expiresTo` (type: `string`):

YYYY-MM-DD, inclusive.

## `sort` (type: `string`):

Result order. Date sorts skip records without that date.

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

Hard cap on results (each result is one billable event).

## `includeStreetAddress` (type: `boolean`):

If on, the street line of the licensed address is returned for business-named rows. Never returned for rows whose legal name is hidden.

## `includeCoordinates` (type: `boolean`):

If on, the source's latitude/longitude is returned for business-named rows (same rule as street).

## `requestDelayMs` (type: `integer`):

Politeness delay between API pages (robots.txt Crawl-delay: 1).

## `maxRetries` (type: `integer`):

Retries on timeouts, HTTP 408/429/5xx with exponential backoff and Retry-After.

## Actor input object example

```json
{
  "status": "active",
  "licenseDescriptions": [
    "Retail Food Establishment"
  ],
  "sort": "newest",
  "maxItems": 100,
  "includeStreetAddress": false,
  "includeCoordinates": false,
  "requestDelayMs": 1100,
  "maxRetries": 4
}
```

# Actor output Schema

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

No description

## `runSummary` (type: `string`):

No description

## `sourceNotice` (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 = {
    "licenseDescriptions": [
        "Retail Food Establishment"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("pennant/chicago-business-licenses").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 = { "licenseDescriptions": ["Retail Food Establishment"] }

# Run the Actor and wait for it to finish
run = client.actor("pennant/chicago-business-licenses").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 '{
  "licenseDescriptions": [
    "Retail Food Establishment"
  ]
}' |
apify call pennant/chicago-business-licenses --silent --output-dataset

```

## MCP server setup

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

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/muAdEeReoAVbxf2l3/builds/ymQpMxd73TZnIcICT/openapi.json
