# US Restaurant Inspections & New Restaurant Leads (`digital_influx/us-restaurant-inspections`) Actor

Health inspections of restaurants and food businesses in New York City, Chicago, Seattle & King County, Montgomery County MD, Cincinnati and Austin: results, grades, violations, closures, phone numbers. Find new restaurants before they open and get only new inspections on a schedule.

- **URL**: https://apify.com/digital_influx/us-restaurant-inspections.md
- **Developed by:** [Bruno Petrelli](https://apify.com/digital_influx) (community)
- **Categories:** Lead generation, Business, Travel
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 inspection saveds

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 Restaurant Inspections & New Restaurant Leads

**Health inspections of restaurants and food businesses from six US health departments, in one clean format:** New York City, Chicago, Seattle & King County, Montgomery County (Maryland), Cincinnati and Austin. Results, grades, scores, every violation, closures, phone numbers where the city publishes them. And the leads nobody else lists: **new restaurants inspected before they open or get their license.**

No login, no API key, no proxies: the data comes from the official open-data portals of each city and county, updated daily.

### Who uses it

- **Suppliers and B2B sales teams** (food and drink distributors, POS and payments, delivery apps, linen, waste, pest control, insurance, staffing): new restaurants in your city every week, before or right when they open.
- **Food safety consultants and pest control:** businesses that just failed an inspection, were closed by the health department, or had critical violations.
- **Restaurant groups and franchises:** monitor the inspections of your own locations and your competitors'.
- **Journalists, researchers and apps:** inspection results in one schema across six jurisdictions, with coordinates.

### What you get

One record per inspection (the portals of New York City, King County and Cincinnati publish one row per violation; they are joined here).

| Field | Example |
|---|---|
| `source`, `jurisdiction` | `chicago`, Chicago, IL |
| `name`, `alsoKnownAs`, `owner`, `category` | IZAAN MYANMAR GROCERY, Grocery Store (cuisine in New York City) |
| `address`, `city`, `state`, `zip`, `phone`, `latitude`, `longitude` | Where it is, and the phone in New York City and Cincinnati |
| `establishmentId` | The business's permit or license number at the portal |
| `inspectionId`, `inspectionDate`, `inspectionType` | 2643485, 2026-09-30, License |
| `newEstablishment` | true for a pre-opening, pre-permit, new license or change-of-ownership inspection; null where the portal does not say |
| `outcome`, `resultText` | `pass`, `conditional`, `fail`, `closed`, `reopened`, `no-entry`, `out-of-business` (null where the portal grades instead), and the portal's own words |
| `score`, `grade` | As each portal gives them: New York City scores (lower is better) and grades A/B/C; King County violation points and Excellent to Needs To Improve; Austin scores out of 100 |
| `closed` | Closed by the health department at this inspection |
| `violationCount`, `criticalViolationCount`, `violations` | Each violation with `code`, `description`, `critical`, `points` and the inspector's `comments` |
| `riskCategory` | Chicago and King County risk level |
| `sourceUrl`, `retrievedAt` | The dataset page and when it was read |
| `change` | With *Only new*: `new` or `updated` |

The run's **OUTPUT** record has the totals per portal, the count per result, the portals skipped by a filter and the attribution.

Example record (shortened):

```json
{
  "source": "chicago",
  "jurisdiction": "Chicago, IL",
  "name": "IZAAN MYANMAR GROCERY",
  "category": "Grocery Store",
  "address": "6350 N CLAREMONT AVE",
  "zip": "60659",
  "inspectionId": "2643485",
  "inspectionDate": "2026-09-30",
  "inspectionType": "License",
  "newEstablishment": true,
  "outcome": "fail",
  "violationCount": 9,
  "violations": [{ "code": "1", "description": "PERSON IN CHARGE PRESENT, DEMONSTRATES KNOWLEDGE, AND PERFORMS DUTIES", "critical": null, "points": null, "comments": "PERSON IN CHARGE WITH NO SANITATION MANAGER CERTIFICATE..." }]
}
```

### Input

New restaurants in New York City and Chicago, inspected in the last 14 days:

```json
{
  "sources": ["new-york-city", "chicago"],
  "onlyNewEstablishments": true,
  "inspectedWithinDays": 14,
  "maxResults": 50
}
```

| Field | What it does |
|---|---|
| `sources` | `new-york-city`, `chicago`, `king-county-wa`, `montgomery-county-md`, `cincinnati`, `austin`. Empty = all six. |
| `onlyNewEstablishments` | Only inspections made before a business opens or gets its license (New York City, Chicago, Montgomery County). |
| `inspectedWithinDays` | The date window, 30 days by default. |
| `outcomes` | Keep only these results, e.g. `["fail", "closed"]`. |
| `onlyWithCriticalViolations` | Only inspections with critical (New York City) or red (King County) violations. |
| `businessNames` | Businesses whose name contains these, e.g. `Starbucks`. |
| `categoryKeywords` | Words in the cuisine or business type: `Pizza`, `Chinese`, `Bakery`, `Grocery`, `Mobile`. |
| `zipCodes` | 5-digit ZIP codes, or the first 3 digits for a wider area. |
| `maxResults` | Newest first, across all portals (1,000 by default). |
| `onlyNew` + `memoryName` | For scheduled runs: only inspections not saved before, or whose result changed. |
| `appToken` | Optional free Socrata app token, if a portal refuses requests. |

Restaurants closed by the health department in the last 30 days, all six portals:

```json
{
  "outcomes": ["closed"],
  "inspectedWithinDays": 30
}
```

Failed inspections of pizza places in Chicago and New York City:

```json
{
  "sources": ["chicago", "new-york-city"],
  "categoryKeywords": ["Pizza"],
  "outcomes": ["fail", "closed"],
  "inspectedWithinDays": 60
}
```

A daily feed of new restaurants in Montgomery County, Maryland (schedule it in *Schedules*):

```json
{
  "sources": ["montgomery-county-md"],
  "onlyNewEstablishments": true,
  "onlyNew": true
}
```

### Only new or updated inspections

Turn on **Only new** and schedule the task. Each run saves only the inspections that earlier runs of the same search did not save, plus the ones whose result changed since (New York City adds grades days after the inspection). The memory lives in a key-value store named `us-restaurant-inspections-state` in your own Apify account and forgets inspections older than the date window. Give a **Memory name** to share it between tasks, or a new one to start over.

### Pricing

Pay per event: you pay **only for inspections saved to the dataset**. Inspections left out by your filters and inspections already saved by an earlier run are free. Set a maximum cost for a run and the Actor stops cleanly when it is reached.

Measured on 2026-10-02: the last 14 days of all six portals were 2,336 inspections, read in about 12 seconds. 221 of them were new businesses (148 in New York City, 62 in Chicago, 11 in Montgomery County).

### Use it from AI agents (MCP)

Claude, ChatGPT, Cursor and any other MCP client can run this Actor as a tool: add `https://mcp.apify.com?tools=digital_influx/us-restaurant-inspections` as a remote MCP server and sign in with your Apify account. It is also one of the tools of US & UK Public Records MCP (`digital_influx/public-records-mcp`), by the same author, made for agents.

### Good to know

- **Portals publish with a delay:** New York City and Chicago about a day, King County, Montgomery County and Cincinnati two to four days, Austin about three weeks.
- **New restaurants:** New York City inspects before the permit ("Pre-permit"), Chicago when the license is requested ("License"), Montgomery County before opening and on a change of ownership. King County, Cincinnati and Austin do not mark them; with *Only new restaurants* on, they are skipped and the OUTPUT says so.
- **Results differ by city.** New York City grades (A, B, C) instead of passing or failing, so its `outcome` is only set for clean inspections, closures and reopenings; Austin publishes scores only. `resultText` always has the portal's own words.
- **Montgomery County's portal repeats rows** (one inspection came 259 times, identical): the Actor asks for each one once.
- **Phones** are published by New York City and Cincinnati only.
- **Requests:** one per second per portal, as their robots.txt asks. Without an app token the portals share a request limit per IP address; if a run reports a refused request, add a free Socrata app token.

### Sources and attribution

- New York City: NYC Department of Health and Mental Hygiene (DOHMH), "DOHMH New York City Restaurant Inspection Results", NYC Open Data, dataset 43nn-pn8j. Each record carries the date it was read (`retrievedAt`); the Actor joins the rows of each inspection into one record and renames the fields.
- Chicago: City of Chicago, "Food Inspections", Chicago Data Portal, dataset 4ijn-s7e5. This site provides applications using data that has been modified for use from its original source, www.cityofchicago.org, the official website of the City of Chicago. The City of Chicago makes no claims as to the content, accuracy, timeliness, or completeness of any of the data provided at this site. The data provided at this site is subject to change at any time. It is understood that the data provided at this site is being used at one's own risk.
- Seattle & King County: Public Health – Seattle & King County, "Food Establishment Inspection Data", dataset r878-4sxa (public domain).
- Montgomery County, MD: "HHS - Food Inspection Data from July 2024 and onward", dataset dkrp-gr48 (public domain).
- Cincinnati: City of Cincinnati, "Cincinnati Food Safety Program", dataset rg6p-b3h3 (public domain).
- Austin: City of Austin, "Food Establishment Inspection Scores", dataset ecmv-9xxi (public domain).

None of these agencies endorses this Actor or any business in its results.

### Questions or ideas?

Want another city or county? Open an issue on the Issues tab: we answer within a few days.

# Actor input Schema

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

Health department portals to read. Empty = all six.

## `onlyNewEstablishments` (type: `boolean`):

Inspections made before a business opens or gets its license: pre-permit in New York City, license inspections in Chicago, pre-opening and change of ownership in Montgomery County. The other portals do not mark them and are skipped.

## `inspectedWithinDays` (type: `integer`):

Inspections of the last N days. Portals publish with a delay: New York City and Chicago about a day, Austin about three weeks.

## `outcomes` (type: `array`):

Keep only these results. New York City grades instead of passing or failing, so it only has "pass" (no violations), "closed" and "reopened"; Austin gives scores only. Empty = all.

## `onlyWithCriticalViolations` (type: `boolean`):

New York City (critical) and King County (red) mark them; the other portals do not, so their inspections are left out when this is on.

## `businessNames` (type: `array`):

Keep businesses whose name contains one of these, e.g. Starbucks, McDonald's.

## `categoryKeywords` (type: `array`):

Words in the cuisine or business type, e.g. Pizza, Chinese, Bakery, Grocery, Mobile. Cincinnati and Austin do not give a type and are skipped.

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

5-digit ZIP codes, or their first 3 digits for a wider area (e.g. 606 for most of Chicago).

## `maxResults` (type: `integer`):

Newest inspections first, across all portals. You also never pay more than the spending limit you set for the run.

## `onlyNew` (type: `boolean`):

Save only inspections that earlier runs of this same search did not save, or whose result changed since (New York City adds grades days later; each row says which). Schedule it daily or weekly. The memory lives in a key-value store named "us-restaurant-inspections-state" in your account.

## `memoryName` (type: `string`):

By default each search has its own memory. Give a name to share one memory between tasks, or a new name to start over.

## `appToken` (type: `string`):

Without a token, the portals share a request limit per IP address. A free app token from any Socrata portal gives you your own limit. Only needed if a run reports a refused request.

## Actor input object example

```json
{
  "sources": [
    "new-york-city",
    "chicago"
  ],
  "onlyNewEstablishments": true,
  "inspectedWithinDays": 14,
  "onlyWithCriticalViolations": false,
  "maxResults": 50,
  "onlyNew": false
}
```

# Actor output Schema

## `results` (type: `string`):

No description

## `summary` (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 = {
    "sources": [
        "new-york-city",
        "chicago"
    ],
    "onlyNewEstablishments": true,
    "inspectedWithinDays": 14,
    "maxResults": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("digital_influx/us-restaurant-inspections").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 = {
    "sources": [
        "new-york-city",
        "chicago",
    ],
    "onlyNewEstablishments": True,
    "inspectedWithinDays": 14,
    "maxResults": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("digital_influx/us-restaurant-inspections").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 '{
  "sources": [
    "new-york-city",
    "chicago"
  ],
  "onlyNewEstablishments": true,
  "inspectedWithinDays": 14,
  "maxResults": 50
}' |
apify call digital_influx/us-restaurant-inspections --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,digital_influx/us-restaurant-inspections"
        }
    }
}
```

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/C4aPiu9Vlnkgt4YRv/builds/ZkPFresvCVdBOnNeM/openapi.json