# US Liquor License Monitor — New Bar & Restaurant Leads (`tegusdev/us-liquor-license-monitor`) Actor

Daily new liquor-license applications and issuances from state/city public records, normalized and deduplicated. Monitor mode emits only filings not seen in previous runs.

- **URL**: https://apify.com/tegusdev/us-liquor-license-monitor.md
- **Developed by:** [HENRY AGUILAR](https://apify.com/tegusdev) (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 $8.00 / 1,000 one normalized license record (backfill/search)s

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

## US Liquor License Monitor — New Bar & Restaurant Leads (CA, NY, TX, MO, OR, Chicago)

A liquor-license application is the earliest public footprint of a new bar or restaurant — typically 3–8 weeks before
a health permit, a Google listing or a job post. This Actor reads the official state and city license records every
time it runs, normalizes them into one schema, classifies each filing as **on-premise** (bar / restaurant / tavern) or
off-premise (stores), deduplicates across days and sources, and — in **monitor mode** — emits **only the filings it
has not emitted before**. Point a schedule at it and you get a clean "new since last run" feed.

### What it does

| Jurisdiction | Source (public record) | Signal | Update cadence |
|---|---|---|---|
| **California** | ABC "New Applications" daily report | pending applications (types 41/47/48 = restaurants & bars) | daily, Mon–Fri |
| **New York** | NY SLA "Current Pending Licenses" (data.ny.gov) | pending applications | daily |
| **Texas** | TABC License Information (data.texas.gov) | **newly issued** permits (MB, BG, BE, private clubs) | daily |
| **Missouri** | ATC "New Liquor Licenses" (data.mo.gov) | newly issued (Retail by Drink etc.) | weekly, rolling 3 weeks |
| **Oregon** | OLCC "Liquor Applications Received" (data.oregon.gov) | pending applications (Full/Limited On-Premises) | daily |
| **Chicago, IL** | BACP Business Licenses (data.cityofchicago.org) | issued Consumption-on-Premises / Tavern | daily |
| **Colorado** | DOR "Recently Approved Liquor Licenses" (data.colorado.gov) | approved licenses | monthly (~5-week lag) |

Each record carries the business name, legal entity, premises address, city, county, ZIP, license type code + label,
`on_premise` flag, status, filing/issue date, event type (`new_application`, `issued`, `transfer`) and a link to the source.

### Who it's for

- **POS / payments resellers** (Toast, Square, Clover, SpotOn partners): reach the owner before the first terminal is bought.
- **Food & beverage distributors**: open the account while the menu is still being written.
- **Restaurant insurance, payroll, linen, signage, furniture, pest-control vendors**: one list, filtered to your counties.
- **n8n / Make / Zapier users and AI agents**: schedule monitor mode and route each new filing to a CRM, Slack channel or
  enrichment step. The Actor is exposed through Apify's MCP server, so an agent can call it as a tool ("find new restaurant
  liquor applications in Los Angeles County this week").

### Input

| Field | Type | Default | Notes |
|---|---|---|---|
| `states` | array | CA, NY, TX, MO, OR, IL | IL = Chicago. CO is monthly. |
| `license_classes` | `on_premise` / `off_premise` / `all` | `on_premise` | on-premise = bar/restaurant style consumption |
| `mode` | `monitor` / `backfill` | `monitor` | monitor keeps a `SEEN` map in the Actor's default key-value store |
| `days_back` | integer 1–60 | 7 | look-back window; CA = one polite request per day |
| `counties` | array of `ST:County` | \[] | e.g. `CA:Los Angeles`, `TX:Harris`; empty = all |
| `geocode` | boolean | false | fill lat/lon + county FIPS via the US Census geocoder (charged per enriched record) |
| `max_records` | integer | 5000 | cost guard |

```json
{ "states": ["CA", "NY", "TX"], "license_classes": "on_premise", "mode": "monitor", "days_back": 7 }
```

### Output (dataset)

```json
{
  "state": "CA", "jurisdiction": "CA ABC (new applications)", "application_id": "683224",
  "status": "PEND", "license_type_code": "47", "license_type_label": "On-Sale General - Eating Place",
  "on_premise": true, "business_name": "TEQUILA RANCH ARCADIA", "legal_entity": "TEQUILA RANCH ARCADIA INC",
  "address": "103 E SANTA CLARA ST", "city": "ARCADIA", "county": "Los Angeles", "zip": "91006",
  "lat": null, "lon": null, "filed_date": "2026-10-02",
  "source_url": "https://www.abc.ca.gov/licensing/licensing-reports/new-applications/?RPTTYPE=2&DATEOFFSET=0#report-2026-10-02",
  "first_seen_at": "2026-10-06T03:10:00+00:00", "event_type": "transfer", "is_new": true
}
```

Monitor runs also write `RUN_SUMMARY` (counts, requests, anti-bot events) to the key-value store. To reset the monitor,
delete the `SEEN` record from the Actor's default key-value store (or run with a fresh task).

### Pricing (pay per event)

| Event | Price | When |
|---|---|---|
| `actor-start` | $0.005 | once per run |
| `new-filing-detected` | $0.03 | monitor mode: a filing never emitted before by this Actor |
| `license-record` | $0.008 | backfill mode: every record in the window |
| `enriched-record` | $0.02 | optional geocoding (lat/lon + county FIPS) |

Typical: monitoring CA + NY + TX daily, on-premise only, ≈ 40–60 new filings/day → **$1.2–1.8/day**. A 30-day on-premise
backfill of one large state ≈ 250–300 records → **≈ $2–2.5**. Set `max_records` or the run's "maximum total charge" to cap cost.

### Limitations and honesty notes

- **Texas publishes issued permits, not pending applications** — still weeks before opening, but later than CA/NY/OR.
- **Colorado** is monthly with a ~5-week lag and some malformed rows upstream (we drop them).
- **Washington** is intentionally excluded: the LCB list page states the records may not be used for commercial purposes (RCW 42.56.070(8)).
- Oregon records have no county (single address string); enable `geocode` if you need county filters there.
- Sources occasionally publish late or change layout; the run summary shows per-source counts and request totals.
- No personal data enrichment: we drop phone and mailing-address columns that some agencies publish. Legal-entity names
  of sole proprietors appear exactly as in the public record.
- Politeness: ≥1 s between API calls, ≥2 s for the CA ABC site, browser-style user agent, no login, no CAPTCHA solving.

### Data-source attribution

California Department of Alcoholic Beverage Control · New York State Liquor Authority (Open NY) · Texas Alcoholic Beverage
Commission (Texas Open Data Portal) · Oregon Liquor and Cannabis Commission (Oregon Open Data) · Colorado Department of
Revenue Liquor Enforcement Division (Colorado Information Marketplace, public domain) · Missouri Division of Alcohol and
Tobacco Control (data.mo.gov) · City of Chicago Department of Business Affairs & Consumer Protection (Chicago Data Portal,
see its Terms of Use). This Actor summarizes public records and links back to them; it is not affiliated with any agency.

### Using it from an agent / MCP

Add Apify's hosted MCP server to your agent (Claude Desktop, Cursor, VS Code, etc.) with this Actor pre-loaded as a tool:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=tegusdev/us-liquor-license-monitor",
      "headers": { "Authorization": "Bearer <YOUR_APIFY_API_TOKEN>" }
    }
  }
}
```

The agent then calls the Actor with the input described above (pay-per-event charges apply to the account whose token is used). Recommended prompt shape:
"Run us-liquor-license-monitor in monitor mode for states CA and TX, on_premise only, days_back 7, and summarize new filings by county."
Each dataset item is a flat JSON object, so downstream tools can filter on `county`, `license_type_code` or `event_type` directly.

### Scheduling

Create a Task with your input, schedule it daily (07:00 in your timezone works well; CA publishes the previous day's report
overnight), and add an integration (webhook → n8n/Make/Zapier, or Slack) on *run succeeded* that reads the default dataset.

# Actor input Schema

## `states` (type: `array`):

Which jurisdictions to pull. IL = City of Chicago business licenses. CO is monthly with a ~5-week lag.

## `license_classes` (type: `string`):

on_premise = bars/restaurants/taverns (the 'opening soon' signal). off_premise = stores. all = everything incl. unknown types.

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

backfill: every filing in the date range. monitor: only filings not emitted by a previous run of this Actor (state kept in the Actor's key-value store under SEEN).

## `days_back` (type: `integer`):

Look-back window in days (CA: one request per day, 2 s apart).

## `counties` (type: `array`):

Optional filter, 'ST:County' strings, e.g. 'CA:Los Angeles'. Empty = all counties. Requires county data (CA, NY, TX, MO, IL have it natively; enable geocode for OR/CO).

## `geocode` (type: `boolean`):

Fill lat/lon and county from the US Census geocoder for records missing them. Charged per enriched record.

## `max_records` (type: `integer`):

Stop after emitting this many records (cost guard).

## Actor input object example

```json
{
  "states": [
    "CA",
    "NY",
    "TX"
  ],
  "license_classes": "on_premise",
  "mode": "monitor",
  "days_back": 7,
  "counties": [],
  "geocode": false,
  "max_records": 5000
}
```

# Actor output Schema

## `filings` (type: `string`):

All filings from this run as JSON. Fields: state, jurisdiction, application_id, status, license_type_code, license_type_label, on_premise, business_name, legal_entity, address, city, county, zip, lat, lon, filed_date, first_seen_at, event_type, source_url, is_new.

## `filingsCsv` (type: `string`):

Same filings as a CSV download for spreadsheets and CRMs.

## `newFilings` (type: `string`):

Filings first seen in this run (monitor mode): the actual leads.

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

Per-state counts, requests made and anti-bot events for this run (key-value store record RUN_SUMMARY).

# 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 = {
    "states": [
        "CA",
        "NY",
        "TX"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("tegusdev/us-liquor-license-monitor").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 = { "states": [
        "CA",
        "NY",
        "TX",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("tegusdev/us-liquor-license-monitor").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 '{
  "states": [
    "CA",
    "NY",
    "TX"
  ]
}' |
apify call tegusdev/us-liquor-license-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,tegusdev/us-liquor-license-monitor"
        }
    }
}
```

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/0aLfsMRpgnhAX6SHU/builds/AFeJREJNGdzihd6Tu/openapi.json