# New Liquor License Feed: Issued & Pending (6 States) (`moment-data/liquor-license-new-issuance-feed`) Actor

Newly issued and pending liquor licenses from 8 official open-data sources in 6 states (NY SLA, Texas TABC, Colorado, Missouri, Washington LCB, Chicago) in one normalized schema. New bars, restaurants, stores, breweries. Daily delta mode.

- **URL**: https://apify.com/moment-data/liquor-license-new-issuance-feed.md
- **Developed by:** [Luke Miller](https://apify.com/moment-data) (community)
- **Security:** 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 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.

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 Liquor License Feed: Newly Issued & Pending Liquor Licenses (NY, TX, CO, MO, WA, Chicago)

Get **new liquor licenses and pending liquor license applications** from **8 official government open-data sources in 6 states** in **one normalized schema**: New York State Liquor Authority (SLA), Texas Alcoholic Beverage Commission (TABC), Colorado Liquor Enforcement Division, Missouri Alcohol and Tobacco Control, Washington State Liquor and Cannabis Board (LCB) and the City of Chicago. An Oregon OLCC source is available as an opt-in, but its upstream dataset has published no new applications since June 4, 2026 (see notes). Every record is a new bar, restaurant, hotel, liquor store, grocery, brewery, winery, distillery or distributor, usually weeks before or right as it opens.

Schedule it daily with `mode: sinceLastRun` and each run delivers only the licenses you have not seen yet.

### Why this feed

- **Multi-state, one schema.** Other liquor-license tools on the Store cover one state or scrape one website. This one reads 8 active official datasets and maps them to the same fields: business (DBA) name, organization legal name, license type and code, normalized category, status, issue / effective / expiration / application dates, license or application number, premises address, city, county, state, ZIP, latitude/longitude (where published) and a link to the source dataset.
- **Two stages: issued and pending.** `stage: application` records (NY pending applications, TABC pending original applications, WA LCB local-authority notices) are the earliest signal, often weeks before a venue opens. `stage: issued` records are freshly granted licenses.
- **Leads, not noise.** By default it skips temporary/special-event permits (nonprofit event permits, picnics, festivals) and add-on privileges on existing licenses (additional bars, Sunday sales, late hours, food & beverage certificates, premises amendments), so you get **new outlets**. Turn either back on with one checkbox. Colorado tobacco licenses and Washington cannabis notices are excluded.
- **Normalized category** across states: `retail-on-premises` (bars, restaurants, hotels, clubs), `retail-off-premises` (liquor, grocery, convenience stores), `manufacturer`, `wholesale-distribution`, `temporary-event`, `other`.
- **Lag-aware.** Each agency refreshes on its own schedule. The lookback window is measured from the newest date each source has posted, so slow portals still return data, and every run reports `dataThrough` per source.
- **Entity-level only.** Individual owner names, applicant lists, birth dates and phone numbers are never copied. Legal names are included only when they are an organization (LLC, Inc, Corp, club, association, ...).
- **Fast and cheap to test.** The default input returns about 40 records (5 per source) in roughly 10 seconds.

### Who uses it

- **Beverage distributors, wholesalers and brand reps**: reach new bars, restaurants and package stores before competitors do.
- **POS, payments, insurance (liquor liability), payroll and staffing sales teams**: new hospitality businesses need all of these.
- **Restaurant suppliers, equipment dealers, glassware, linen, security and music licensing**: prospect new venues by city.
- **Market research and real estate**: track new on-premises and off-premises outlets by state, city and category.
- **AI agents and CRMs**: call it via the Apify API or MCP server, e.g. "new mixed beverage permits in Houston this week".

### Quick start

1. Click **Start** with the default input to see a sample (about 40 records across all sources).
2. For a daily lead feed, create a **Schedule** with:

```json
{
  "mode": "sinceLastRun",
  "stateKey": "my-texas-bars",
  "states": ["TX"],
  "licenseCategories": ["retail-on-premises"],
  "daysBack": 7,
  "maxItems": 1000,
  "maxItemsPerSource": 500
}
```

Each schedule should use its own `stateKey`. The first run looks back `daysBack` days; later runs only return records not delivered before (a 3-day overlap catches late postings).

### Input

| Field | Meaning |
|---|---|
| `mode` | `window` (default, stateless) or `sinceLastRun` (only new records; **use for schedules**) |
| `daysBack` | Lookback window, default 7 days |
| `sources` | any of `ny-sla-new-licenses`, `ny-sla-pending-applications`, `tx-tabc-new-licenses`, `tx-tabc-pending-applications`, `co-recently-approved`, `mo-new-liquor-licenses`, `or-olcc-applications` (opt-in, stale; see notes), `wa-lcb-license-applications`, `chicago-new-liquor-licenses` |
| `states` | `NY`, `TX`, `CO`, `MO`, `WA`, `IL`; `OR` turns on the opt-in Oregon source |
| `stages` | `issued`, `application` |
| `licenseCategories` | `retail-on-premises`, `retail-off-premises`, `manufacturer`, `wholesale-distribution`, `temporary-event`, `other` |
| `licenseTypes` | text match on license type or code, e.g. `restaurant`, `tavern`, `mixed beverage`, `MB`, `grocery`, `brewer` |
| `city`, `keyword` | exact city name; free-text match on name, type and address |
| `includeTemporary`, `includeAddOns` | off by default |
| `maxItems`, `maxItemsPerSource` | caps per run (also cap your spend). Defaults 40 / 5 for a cheap test; raise them for production |
| `includeRaw` | adds the original agency record (may contain personal names; off by default) |
| `socrataAppToken` | optional free Socrata token to avoid throttling |
| `stateKey` | saved-search name for `sinceLastRun` |

### Output example

See the *Output* tab or `sample-output.json`.

```json
{
  "stage": "issued",
  "businessName": "Ilmejung DokDo LLC",
  "legalEntityName": "Ilmejung Dokdo LLC",
  "licenseType": "Mixed Beverage Permit",
  "licenseTypeCode": "MB",
  "licenseCategory": "retail-on-premises",
  "status": "Active",
  "isAddOn": false,
  "isTemporary": false,
  "licenseNumber": "200211517",
  "eventDate": "2026-10-29",
  "issueDate": "2026-10-29",
  "effectiveDate": "2026-10-29",
  "expirationDate": "2028-10-28",
  "address": "10017 Long Point Rd",
  "city": "Houston", "county": "Harris", "state": "TX", "zip": "77055",
  "jurisdiction": "TX",
  "source": "tx-tabc-new-licenses",
  "sourceDataset": "https://data.texas.gov/d/7hf9-qc9f",
  "recordKey": "tx-tabc-new-licenses:200211517"
}
```

`eventDate` is the issue date for issued licenses and the received / posted date for applications. `state` is the premises state (out-of-state shippers and carriers licensed by Texas or Missouri keep their home state); `jurisdiction` is the issuing state. Every run also writes an `OUTPUT` summary with per-source counts, `dataThrough` and any errors. One source failing never blocks the others.

### Data sources and terms

| Jurisdiction | Dataset | Stage | Terms |
|---|---|---|---|
| New York | [SLA Current Active Licenses](https://data.ny.gov/d/9s3h-dpkz) (new originals by original issue date) | issued | [NY Open Data Terms of Use](https://data.ny.gov/download/77gx-ii52/application/pdf) |
| New York | [SLA Current Pending Licenses](https://data.ny.gov/d/f8i8-k2gm) | application | NY Open Data Terms of Use |
| Texas | [TABC License Information](https://data.texas.gov/d/7hf9-qc9f) (by original issue date) | issued | Texas Open Data Portal |
| Texas | [TABC Pending Original New Primary and Subordinate License Applications](https://data.texas.gov/d/mxm5-tdpj) | application | Texas Open Data Portal |
| Colorado | [Recently Approved Liquor Licenses in Colorado](https://data.colorado.gov/d/htyp-tqzh) | issued | Public Domain |
| Missouri | [New Liquor Licenses](https://data.mo.gov/d/dymb-xy5c) | issued | Missouri Open Data |
| Oregon (opt-in, stale) | [OLCC Liquor Applications Received](https://data.oregon.gov/d/qad4-bnxp) | application | Oregon Open Data |
| Washington | [LCB Local Authority Letters](https://data.wa.gov/d/vgcw-qfjm) (liquor only) | application | Public Domain |
| Chicago, IL | [Business Licenses](https://data.cityofchicago.org/d/r5kz-chrr) (new Tavern, Package Goods, Consumption on Premises, Caterer's Liquor, Special Event Liquor) | issued | [City of Chicago Data Terms of Use](https://www.chicago.gov/city/en/narr/foia/data_disclaimer.html) |

**Disclaimer (required by the City of Chicago terms for derivative applications):** This Actor provides data that has been modified for use from its original sources, including 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 here. The data is subject to change at any time and is used at your own risk.

This Actor is not affiliated with or endorsed by any agency. Data is as published by each agency. Notes: Colorado refreshes roughly monthly; the Washington LCB dataset is a short rolling list of recent notices; **Oregon is opt-in and currently stale:** the OLCC 'Liquor Applications Received' dataset has published no `New Application` rows since June 4, 2026 (only premises-area amendments, which are add-ons), so it is excluded by default and normally returns 0 records. Select `or-olcc-applications` in `sources` (or `OR` in `states`) to include it anyway; it is labeled in the run's `OUTPUT` summary. Oregon publishes the premises address as one line, so `city` is empty there. `licenseCategory`, `isAddOn` and `isTemporary` are best-effort labels from the license type, not official classifications.

### Good-citizen behavior

Uses the official Socrata (SODA) APIs only, no scraping. Requests are spaced at least 0.4 seconds apart per host, use a descriptive User-Agent, back off on errors and rate limits, and only the needed date window is requested.

### Pricing

Pay per event (Apify takes care of billing; you only pay for what is delivered):

| Event | Price | Charged |
|---|---|---|
| `apify-actor-start` | $0.005 | once per run |
| `license-record` | $0.003 | per liquor license record delivered |

A default test run (40 records) costs about $0.125. A TX + NY on-premises daily schedule (~60 new records/day) costs about $0.19/day. `maxItems` and Apify's *max cost per run* cap your spend; the Actor stops delivering when your budget is reached, so you are never charged for more than you set. No separate platform-usage charges: compute is included in the event prices.

### FAQ

**How fresh is the data?** New York, Texas, Missouri, Washington and Chicago refresh daily or near-daily; Colorado roughly monthly. Check `dataThrough` in the `OUTPUT` record.

**Can I get phone numbers or owner names?** No. This feed is entity-level by design. Use the business name and premises address to look up public business contact details.

**Can you add my state?** Open an issue on the Issues tab. States that publish liquor licenses on an open-data API can be added quickly.

# Actor input Schema

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

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

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

Lookback window (window mode) or first-run window (sinceLastRun). Measured from the newest date each agency has posted, so slow-refreshing portals still return data.

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

Which official datasets to read. Default is the eight active sources in 6 states (NY, TX, CO, MO, WA, Chicago IL). Oregon OLCC applications is opt-in only: its upstream dataset has had no new applications since June 4, 2026.

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

Shortcut filter on the issuing jurisdiction. Empty = all active sources (NY, TX, CO, MO, WA, Chicago IL). Choosing Oregon also turns on the opt-in OLCC source, whose upstream dataset has had no new applications since June 4, 2026.

## `stages` (type: `array`):

issued = license granted; application = pending/received applications (earliest signal, often weeks before opening). Empty = both.

## `licenseCategories` (type: `array`):

Normalized category across states. Empty = all.

## `licenseTypes` (type: `array`):

Keep records whose license type or code contains any of these (case-insensitive), e.g. restaurant, tavern, mixed beverage, MB, grocery, brewer.

## `city` (type: `string`):

Exact city name (case-insensitive), e.g. Houston, Brooklyn, Denver.

## `keyword` (type: `string`):

Keep records whose business name, license type or address contains this text.

## `includeTemporary` (type: `boolean`):

Nonprofit temporary events, picnics, festivals, temporary retail. Off by default.

## `includeAddOns` (type: `boolean`):

Additional bars, Sunday sales, late hours, food & beverage certificates and similar add-ons to an existing license. Off by default so you only get new outlets.

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

Hard cap on delivered records across all sources (also caps your spend).

## `maxItemsPerSource` (type: `integer`):

Cap per upstream dataset. Defaults are small so a test run is cheap; raise both for production. In sinceLastRun mode the rest is delivered next run.

## `includeRaw` (type: `boolean`):

Adds a 'raw' field with the original agency record. Raw records can contain individual owner/applicant names and phone numbers, so leave this off unless you need it.

## `socrataAppToken` (type: `string`):

Optional free app token to avoid shared-IP throttling on the open-data portals.

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

Name of the saved search for sinceLastRun mode. Each key keeps its own 'already delivered' history; use one key per schedule.

## Actor input object example

```json
{
  "mode": "window",
  "daysBack": 7,
  "sources": [
    "ny-sla-new-licenses",
    "ny-sla-pending-applications",
    "tx-tabc-new-licenses",
    "tx-tabc-pending-applications",
    "co-recently-approved",
    "mo-new-liquor-licenses",
    "wa-lcb-license-applications",
    "chicago-new-liquor-licenses"
  ],
  "includeTemporary": false,
  "includeAddOns": false,
  "maxItems": 40,
  "maxItemsPerSource": 5,
  "includeRaw": false,
  "stateKey": "default"
}
```

# Actor output Schema

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

One record per newly issued license or pending application.

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

Counts per source, newest record date posted by each agency, and any source errors.

# 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/liquor-license-new-issuance-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/liquor-license-new-issuance-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/liquor-license-new-issuance-feed --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,moment-data/liquor-license-new-issuance-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/v4rJ1dMMcDOIvDNCB/builds/skHbOUCTlmf90op1a/openapi.json