# Ontario Liquor Licence Leads — New Applications & Issued (`siroluai/ontario-liquor-licence-leads`) Actor

Liquor license leads for Ontario, Canada from official AGCO open data. Find new restaurant and bar openings — new business leads for lead generation, B2B sales and outreach by POS, insurance and beverage vendors.

- **URL**: https://apify.com/siroluai/ontario-liquor-licence-leads.md
- **Developed by:** [Emre Sirolu](https://apify.com/siroluai) (community)
- **Categories:** Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $15.00 / 1,000 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/platform/actors/running/actors-in-store#pay-per-event

## 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.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.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/platform/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

## Ontario Liquor Licence Leads — New Applications & Issued

**Fresh Ontario liquor licence leads — businesses about to open, before your competitors call them.**

Every bar, restaurant, brewery, and lounge opening in Ontario must get a liquor
licence from the **AGCO** (Alcohol and Gaming Commission of Ontario). Each new
application is posted publicly *weeks before the doors open*. This Actor turns that
public record into a clean, deduplicated lead list — business name, address, licence
type, status, and date — so you can reach new hospitality businesses first.

---

### Who it's for

If you sell to new bars and restaurants in Ontario, these are your leads the moment they appear:

- 🧾 **POS & payment processors** — get in before they pick a system.
- 🛡️ **Insurance brokers** — liquor liability, property, and business coverage.
- 🍷 **Food & beverage distributors / suppliers** — make the supplier shortlist early.
- 🧹 **Commercial cleaners & facilities services** — new venues need recurring contracts.
- 📣 **Agencies & B2B services** — signage, uniforms, marketing, accounting, design.

A new liquor licence is one of the earliest public signals that a business is opening —
earlier than a storefront, a phone number, or a Google listing.

---

### Two lead sources, one clean feed

The Actor pulls from **two official AGCO feeds** and you choose which with a single input:

| Source | What it captures | Why it matters |
|---|---|---|
| 🆕 **New applications** | Licences currently in the mandatory public-notice window | Businesses **about to open**. The freshest possible leads — they're not open yet. |
| ✅ **Recently issued** | Licences issued in the last *N* days | Businesses that **just opened** and are actively buying and setting up. |

#### Why `objection_deadline` is your best timing signal

New-application records include an **objection deadline** — the date the public-notice
period ends. That date is your timing cue:

> **A near deadline = the business is opening soon = perfect time to reach out.**

Sort by it to prioritize the venues opening next, and time your outreach so you're the
first vendor in the door.

---

### Example output

One JSON record per licence. Missing source fields are `null` — values are never invented.

| business_name | street | city | postal_code | licence_type | status | date | date_label |
|---|---|---|---|---|---|---|---|
| Plaza Sushi | 35 QUEEN ST E | Cambridge | N3C 2A7 | Liquor Sales Licence | Application in progress (public notice) | 2026-07-09 | objection_deadline |
| The Barber's Den | 17 JAMES ST W | Orillia | L3V 8A6 | Liquor Sales Licence | Application in progress (public notice) | 2026-07-19 | objection_deadline |
| Contrada Restaurant | 537 COLLEGE ST | Toronto | M6G 1A9 | Liquor Sales Licence | Active | 2026-07-06 | issue_date |

<details>
<summary>Full JSON record</summary>

```json
{
  "licence_id": "APP-3738045",
  "business_name": "Plaza Sushi",
  "establishment_address": {
    "street": "35 QUEEN ST E",
    "city": "Cambridge",
    "postal_code": "N3C 2A7"
  },
  "licence_type": "Liquor Sales Licence",
  "application_type": "New Application",
  "areas": "Indoor and Outdoor Area",
  "status": "Application in progress (public notice)",
  "date": "2026-07-09",
  "date_label": "objection_deadline",
  "file_number": "3738045",
  "source": "applications",
  "source_url": "https://www.agco.ca/sites/default/files/opendata/LiquorApplicationsUndergoingPublicNotice.csv",
  "scraped_at": "2026-07-07T14:20:00+00:00"
}
````

</details>

**`date` is always labelled** so you know what it means: `objection_deadline` for
applications (the AGCO feed does not publish the filing date), or `issue_date` for
issued licences.

***

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `max_items` | integer | `100` | Max records to return across all selected sources. |
| `status_filter` | select | `both` | `applications`, `issued`, or `both`. |
| `issued_since_days` | integer | `30` | For issued licences, keep only those issued within the last N days. |
| `only_new` | boolean | `false` | Return only licences not seen in previous runs (great for daily runs into a CRM). |

```json
{
  "max_items": 100,
  "status_filter": "both",
  "issued_since_days": 30,
  "only_new": true
}
```

***

### Official, compliant data

This Actor uses **official AGCO open data**, published by the Alcohol and Gaming
Commission of Ontario under the
[**Open Government Licence – Ontario**](https://www.ontario.ca/page/open-government-licence-ontario).
It reads the public open-data feeds directly — no logins, no personal data, no
grey-area scraping. Data © King's Printer for Ontario. This Actor is an independent
tool and is not affiliated with or endorsed by the AGCO.

***

### FAQ

**How fresh is the data?**
The AGCO refreshes these open-data feeds regularly (typically daily on business days).
Each run pulls the current published feed, so you always get the latest snapshot. New
applications appear as soon as they enter the public-notice window — well before the
business opens.

**How do I get only new leads each day?**
Set `only_new: true` and **schedule the Actor to run daily** (Apify Console → your
Actor → *Schedules*). The Actor remembers every licence it has already delivered in a
persistent key-value store and returns only licences it hasn't seen before — so each
day you get just the new openings, with no duplicates to filter.

**How do I send leads to Google Sheets, a CRM, or a webhook?**
Use **Apify integrations** (Actor run → *Integrations*, or *Settings → Integrations*):

- **Google Sheets** — auto-append every new record to a spreadsheet.
- **Webhook** — POST new results to your CRM, Zapier/Make, or Slack on each run.
- **API / exports** — pull the dataset as JSON, CSV, or Excel from the Apify API.

Pair `only_new: true` + a daily schedule + a Google Sheets or webhook integration to
get a hands-off pipeline of brand-new Ontario hospitality leads.

**Which regions are covered?**
All of Ontario, Canada — every municipality where the AGCO issues liquor licences.

**Does it cover licence types beyond restaurants and bars?**
Yes — the feed includes all liquor sales licences (restaurants, bars, lounges, hotels,
clubs, and similar establishments), plus any endorsements on issued licences.

# Actor input Schema

## `max_items` (type: `integer`):

Maximum number of licence records to return across all selected sources.

## `status_filter` (type: `string`):

Which AGCO feed(s) to pull. 'applications' = new licence applications currently undergoing public notice (freshest leads, businesses about to open). 'issued' = recently issued liquor sales licences. 'both' returns applications first, then recent issued licences.

## `issued_since_days` (type: `integer`):

Only used when 'issued' licences are included. Keeps issued-licence records whose issue date falls within the last N days, so results stay fresh sales leads.

## `only_new` (type: `boolean`):

If enabled, return only licences not seen in previous runs. Seen licence IDs are remembered in the Actor's default key-value store.

## Actor input object example

```json
{
  "max_items": 100,
  "status_filter": "both",
  "issued_since_days": 30,
  "only_new": false
}
```

# Actor output Schema

## `results` (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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("siroluai/ontario-liquor-licence-leads").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("siroluai/ontario-liquor-licence-leads").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 siroluai/ontario-liquor-licence-leads --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=siroluai/ontario-liquor-licence-leads",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Ontario Liquor Licence Leads — New Applications & Issued",
        "description": "Liquor license leads for Ontario, Canada from official AGCO open data. Find new restaurant and bar openings — new business leads for lead generation, B2B sales and outreach by POS, insurance and beverage vendors.",
        "version": "1.0",
        "x-build-id": "kFJSc1p3u0rMpwP2S"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/siroluai~ontario-liquor-licence-leads/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-siroluai-ontario-liquor-licence-leads",
                "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/siroluai~ontario-liquor-licence-leads/runs": {
            "post": {
                "operationId": "runs-sync-siroluai-ontario-liquor-licence-leads",
                "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/siroluai~ontario-liquor-licence-leads/run-sync": {
            "post": {
                "operationId": "run-sync-siroluai-ontario-liquor-licence-leads",
                "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": {
                    "max_items": {
                        "title": "Maximum items",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of licence records to return across all selected sources.",
                        "default": 100
                    },
                    "status_filter": {
                        "title": "Licence status / source",
                        "enum": [
                            "both",
                            "applications",
                            "issued"
                        ],
                        "type": "string",
                        "description": "Which AGCO feed(s) to pull. 'applications' = new licence applications currently undergoing public notice (freshest leads, businesses about to open). 'issued' = recently issued liquor sales licences. 'both' returns applications first, then recent issued licences.",
                        "default": "both"
                    },
                    "issued_since_days": {
                        "title": "Issued within last N days",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Only used when 'issued' licences are included. Keeps issued-licence records whose issue date falls within the last N days, so results stay fresh sales leads.",
                        "default": 30
                    },
                    "only_new": {
                        "title": "Only new since last run",
                        "type": "boolean",
                        "description": "If enabled, return only licences not seen in previous runs. Seen licence IDs are remembered in the Actor's default key-value store.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```