# Texas TABC Liquor License Search — Official State Open Data (`keeganlabs/texas-tabc-liquor-licenses`) Actor

Every Texas liquor, beer, and wine license from the TABC official open-data feed (~125k records, ~74k active), refreshed daily. Owner, trade name, license type & status, issue/expiration dates, premises & mailing address, county, phone. Filter by county, city, type, status, or name.

- **URL**: https://apify.com/keeganlabs/texas-tabc-liquor-licenses.md
- **Developed by:** [Keegan Labs](https://apify.com/keeganlabs) (community)
- **Categories:** Lead generation, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-usage

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Texas TABC Liquor License Search 🍺🥃🍷

**The only dedicated Texas liquor-license actor on Apify Store.** Straight from the
**Texas Alcoholic Beverage Commission (TABC)** official open-data feed on
[data.texas.gov](https://data.texas.gov/resource/7hf9-qc9f) — **~125,000 license records
(~74,000 active), refreshed daily by the state.** No CAPTCHAs, no stale scrapes, no
guesswork. Every mixed-beverage permit, package store, beer retailer, distiller, brewpub,
and winery license in Texas, filterable and normalized.

Other "liquor license" listings in the store are thin national aggregators. This actor is
**dedicated to Texas**, pulls the **authoritative state source**, and returns clean,
structured records you can drop straight into a CRM, territory map, or compliance workflow.

---

### Who buys this

- **Alcohol distributors & beverage sales reps** — build and refresh territory lead lists
  of every on-/off-premise license by county and license type.
- **POS, payment & fintech vendors** — target bars, restaurants, and package stores the
  day their license goes active.
- **Restaurant / bar / hospitality suppliers** — reach new and renewing licensees.
- **Commercial real estate & site selectors** — map license density and turnover by city
  and county.
- **Compliance, AML & KYB teams** — verify a business's alcohol license, owner of record,
  status, and expiration against the official state registry.

---

### What you get

Filterable, normalized records with a stable schema. Filters (all optional):

| Input | Meaning |
| --- | --- |
| `county` | Texas county (partial, case-insensitive) — e.g. `Harris`, `Travis`, `Bexar` |
| `city` | City (partial, case-insensitive) — e.g. `Houston`, `Austin` |
| `licenseType` | TABC type code (exact) — `MB`, `BQ`, `BG`, `Q`, `NT`, `P`, `DS`, `W`, … |
| `licenseStatus` | `Active`, `Expired`, `Surrendered`, `Suspended`, … (defaults to **Active**) |
| `includeAllStatuses` | Return every status, not just active |
| `nameContains` | Substring matched against **owner** OR **trade (DBA)** name |
| `issuedFrom` / `issuedTo` | Issue-date range (ISO `YYYY-MM-DD`) — great for "new this month" lead pulls |
| `maxRecords` | Cap on results (default 5,000) |
| `socrataAppToken` | Optional Socrata app token to raise rate limits (not required) |

**Common license types:** `MB` Mixed Beverage · `BQ`/`BG` Wine & Malt Beverage Retailer ·
`Q` Package Store · `NT` Beer Retail (Off-Premise) · `P` Package Store · `DS` Distiller ·
`BE` Brewpub · `W` Winery · `S` Wholesaler.

#### Example output record

```json
{
  "licenseId": "100000290",
  "masterFileId": "2100050776",
  "licenseType": "BG",
  "licenseTypeLabel": "Wine and Malt Beverage Retailer",
  "licenseStatus": "Active",
  "primaryStatus": "Active",
  "ownerName": "BONNIE HEGEMEYER",
  "tradeName": "CROSS ROADS TAVERN",
  "tier": "Retail",
  "originalIssueDate": "1987-12-11",
  "currentIssuedDate": "2025-12-15",
  "expirationDate": "2027-12-10",
  "statusChangeDate": "2025-12-15",
  "address": {
    "street": "12716 FM 1094",
    "city": "Sealy",
    "state": "TX",
    "zip": "77474-9870",
    "county": "AUSTIN",
    "country": "United States"
  },
  "mailingAddress": {
    "street": "12716 FM 1094",
    "city": "Sealy",
    "state": "TX",
    "zip": "77474-9870",
    "country": "United States"
  },
  "phone": "",
  "legacyLicenseNumber": "BG227874",
  "sourceDataset": "7hf9-qc9f",
  "sourceUrl": "https://data.texas.gov/resource/7hf9-qc9f.json"
}
````

Names are whitespace-cleaned and uppercased, IDs are de-noised (Socrata's trailing `.0`
stripped), ZIPs are ZIP+4 formatted, and all dates are ISO `YYYY-MM-DD`.

***

### Example runs

- **Every active mixed-beverage permit in Harris County:**
  `{ "county": "Harris", "licenseType": "MB" }`
- **New package stores issued this year statewide:**
  `{ "licenseType": "Q", "issuedFrom": "2026-01-01" }`
- **Find a specific chain's licenses:** `{ "nameContains": "SPEC'S" }`
- **Everything in Austin, all statuses:** `{ "city": "Austin", "includeAllStatuses": true }`

***

### Data source & freshness

- **Dataset:** `7hf9-qc9f` — *TABC License Information* on data.texas.gov (Socrata SODA API).
- **Volume:** ~125,579 total records; ~73,749 currently **Active** (as of 2026-07-22).
- **Refresh:** updated by the state **daily** (verified 2026-07-22 12:30 UTC).
- **Access:** official public open data — no login, no CAPTCHA. This actor uses the
  documented SODA API with a descriptive User-Agent, server-side `$where` filtering,
  polite paging, and exponential backoff.

The companion dataset `kguh-7q9z` (TABCLicenses) carries only 11 columns and no status or
dates; this actor deliberately uses the richer `7hf9-qc9f` feed so you get status, tier,
issue/expiration dates, phone, and mailing address.

***

### Pricing

Pay-per-event — you only pay for what you pull:

| Event | Price (USD) |
| --- | --- |
| Actor start | **$0.005** |
| License record | **$0.003** |

A typical county pull of 1,000 active licenses costs **~$3.01**. The whole active-license
universe (~74k rows) runs ~$222 for a full statewide refresh — a fraction of what any
list broker charges for a one-time, un-sourced CSV, and yours is re-runnable daily against
the authoritative state registry.

**Why these numbers:** priced to the pattern of our other government-filing actors
(actor-start $0.005 + per-record $0.003, matching the Ohio SoS filings actor). The
liquor-license category on Apify is underserved — existing entries are thin national
aggregators with tiny user counts and no Texas focus — so this dedicated, authoritative,
daily-fresh feed is priced to be an obvious yes for a distributor or vendor building a
Texas book of business.

***

*Data is sourced from the Texas Alcoholic Beverage Commission's public open-data portal.
This actor is an independent tool and is not affiliated with or endorsed by the TABC or the
State of Texas.*

# Actor input Schema

## `county` (type: `string`):

Filter by Texas county (partial match, case-insensitive). Example: HARRIS, TRAVIS, BEXAR.

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

Filter by city (partial match, case-insensitive). Example: Houston, Austin.

## `licenseType` (type: `string`):

TABC license-type code (exact match). Common: MB (Mixed Beverage), BQ/BG (Wine & Malt Beverage Retailer), Q (Package Store), NT (Beer Retail Off-Premise), P (Package Store), DS (Distiller), W (Winery).

## `licenseStatus` (type: `string`):

Filter by license status (partial match). Values include: Active, Active - Renewal Pending, Expired, Expired - Original Required, Surrendered, Suspended, Cancelled. Defaults to 'Active' unless 'Include all statuses' is on.

## `includeAllStatuses` (type: `boolean`):

If true and no explicit status is set, returns licenses of every status (active, expired, surrendered, etc.).

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

Free-text substring matched against both the owner (business) name and the trade (DBA) name, case-insensitive.

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

Only include licenses whose current issue date is on or after this date (ISO YYYY-MM-DD).

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

Only include licenses whose current issue date is on or before this date (ISO YYYY-MM-DD).

## `maxRecords` (type: `integer`):

Hard cap on the number of license records to return. The full dataset is ~125k rows (~74k Active).

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

Optional data.texas.gov / Socrata application token to raise API throttling limits. Not required — the API works without one.

## Actor input object example

```json
{
  "county": "Harris",
  "city": "Austin",
  "licenseType": "MB",
  "licenseStatus": "Active",
  "includeAllStatuses": false,
  "nameContains": "Spec",
  "issuedFrom": "2025-01-01",
  "issuedTo": "2025-12-31",
  "maxRecords": 5000
}
```

# 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("keeganlabs/texas-tabc-liquor-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("keeganlabs/texas-tabc-liquor-licenses").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).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 keeganlabs/texas-tabc-liquor-licenses --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=keeganlabs/texas-tabc-liquor-licenses",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Texas TABC Liquor License Search — Official State Open Data",
        "description": "Every Texas liquor, beer, and wine license from the TABC official open-data feed (~125k records, ~74k active), refreshed daily. Owner, trade name, license type & status, issue/expiration dates, premises & mailing address, county, phone. Filter by county, city, type, status, or name.",
        "version": "1.0",
        "x-build-id": "nK353Q5zV8LFBz1kJ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/keeganlabs~texas-tabc-liquor-licenses/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-keeganlabs-texas-tabc-liquor-licenses",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/keeganlabs~texas-tabc-liquor-licenses/runs": {
            "post": {
                "operationId": "runs-sync-keeganlabs-texas-tabc-liquor-licenses",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/keeganlabs~texas-tabc-liquor-licenses/run-sync": {
            "post": {
                "operationId": "run-sync-keeganlabs-texas-tabc-liquor-licenses",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "county": {
                        "title": "County",
                        "type": "string",
                        "description": "Filter by Texas county (partial match, case-insensitive). Example: HARRIS, TRAVIS, BEXAR."
                    },
                    "city": {
                        "title": "City",
                        "type": "string",
                        "description": "Filter by city (partial match, case-insensitive). Example: Houston, Austin."
                    },
                    "licenseType": {
                        "title": "License / permit type code",
                        "type": "string",
                        "description": "TABC license-type code (exact match). Common: MB (Mixed Beverage), BQ/BG (Wine & Malt Beverage Retailer), Q (Package Store), NT (Beer Retail Off-Premise), P (Package Store), DS (Distiller), W (Winery)."
                    },
                    "licenseStatus": {
                        "title": "License status",
                        "type": "string",
                        "description": "Filter by license status (partial match). Values include: Active, Active - Renewal Pending, Expired, Expired - Original Required, Surrendered, Suspended, Cancelled. Defaults to 'Active' unless 'Include all statuses' is on."
                    },
                    "includeAllStatuses": {
                        "title": "Include all statuses (not just Active)",
                        "type": "boolean",
                        "description": "If true and no explicit status is set, returns licenses of every status (active, expired, surrendered, etc.).",
                        "default": false
                    },
                    "nameContains": {
                        "title": "Owner or trade name contains",
                        "type": "string",
                        "description": "Free-text substring matched against both the owner (business) name and the trade (DBA) name, case-insensitive."
                    },
                    "issuedFrom": {
                        "title": "Issued on/after (YYYY-MM-DD)",
                        "type": "string",
                        "description": "Only include licenses whose current issue date is on or after this date (ISO YYYY-MM-DD)."
                    },
                    "issuedTo": {
                        "title": "Issued on/before (YYYY-MM-DD)",
                        "type": "string",
                        "description": "Only include licenses whose current issue date is on or before this date (ISO YYYY-MM-DD)."
                    },
                    "maxRecords": {
                        "title": "Maximum records",
                        "minimum": 1,
                        "maximum": 200000,
                        "type": "integer",
                        "description": "Hard cap on the number of license records to return. The full dataset is ~125k rows (~74k Active).",
                        "default": 5000
                    },
                    "socrataAppToken": {
                        "title": "Socrata app token (optional)",
                        "type": "string",
                        "description": "Optional data.texas.gov / Socrata application token to raise API throttling limits. Not required — the API works without one."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```