# New York Open Data Scraper (`parseforge/data-ny-gov-new-york-open-data-scraper`) Actor

Query New York State open data catalog across thousands of datasets covering health, transport, education, finance, environment, and demographics. Filter by dataset, agency, or category and export rows to JSON, CSV, or Excel for civic research, journalism, and analytics dashboards.

- **URL**: https://apify.com/parseforge/data-ny-gov-new-york-open-data-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Other, Real estate
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $13.00 / 1,000 result items

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 🗽 New York State Open Data Scraper

> 🚀 **Export any New York State open dataset in seconds.** Pull rows from **1,500+ public datasets** covering driver licenses, tax records, health, education, transportation, and more. Filter with full-text search, column equality, and custom sort.

> 🕒 **Last updated:** 2026-05-23 · **📊 4 fields** per record · **🗽 1,500+ datasets** · **🏛️ Official NY State source** · **🔎 Socrata-powered**

The **New York State Open Data Scraper** taps `data.ny.gov`, the official Socrata-powered open-data hub of New York State government. The Actor returns **4 structured fields per record**: the dataset resource ID, the full row payload, a collection timestamp, and an error slot. The row payload preserves every column from the source dataset exactly as Socrata serves it, so downstream pipelines see no schema loss.

The catalog covers **more than 1,500 public datasets** across active driver licenses, tax rolls, public health surveillance, school report cards, MTA ridership, real-estate assessments, environmental sensor feeds, agency budgets, election results, vehicle inspections, and dozens of other domains. This Actor wraps Socrata SoQL so you can search, filter, and sort without touching the API directly.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Real-estate analysts, NY-focused journalists, civic-tech developers, urban planners, transportation researchers, public-health teams, transparency advocates | Property valuation comps, investigative reporting, civic-app data layers, urban analytics dashboards, transit ridership studies, license verification pipelines |

---

### 📋 What the New York State Open Data Scraper does

A single workflow with rich filtering:

- 📊 **Pull rows by resource ID.** Pass a 4x4 Socrata identifier (e.g. `9a8c-vfzj` Active Driver License Information).
- 🔎 **Full-text search.** Optional `$q` query across every column.
- 🧮 **Column filters.** Pass `{"county": "BRONX", "operation_type": "Store"}` for exact-match equality filters.
- 📐 **Sort order.** Order by any column (`license_number DESC`, `city ASC`).
- 🪪 **Stable schema.** Each record bundles the resource ID, the raw row, and a collection timestamp.

The Actor handles Socrata pagination automatically so you do not have to worry about offsets.

> 💡 **Why it matters:** New York State publishes one of the largest civic open-data catalogs in the U.S., yet most teams burn engineering hours writing a Socrata client per dataset. This Actor delivers consistent rows you can pipe straight into BI tools, notebooks, or civic-tech apps without per-dataset glue code.

---

### 🎬 Full Demo

_🚧 Coming soon: a 3-minute walkthrough showing how to go from sign-up to a downloaded dataset._

---

### ⚙️ Input

<table>
<thead>
<tr><th>Input</th><th>Type</th><th>Default</th><th>Behavior</th></tr>
</thead>
<tbody>
<tr><td>maxItems</td><td>integer</td><td>10</td><td>Records to return. Free plan caps at 10, paid plan at 1,000,000.</td></tr>
<tr><td>resourceId</td><td>string</td><td>"9a8c-vfzj"</td><td>4x4 Socrata identifier for the dataset. Find IDs at data.ny.gov.</td></tr>
<tr><td>searchQuery</td><td>string</td><td>""</td><td>Optional full-text query across every column.</td></tr>
<tr><td>filters</td><td>object</td><td>{}</td><td>Exact-match column filters as key/value pairs.</td></tr>
<tr><td>sortOrder</td><td>string</td><td>""</td><td>Order results by a column (e.g. license_number DESC).</td></tr>
</tbody>
</table>

**Example: Bronx restaurants from the Active Driver License dataset.**

```json
{
    "maxItems": 50,
    "resourceId": "9a8c-vfzj",
    "filters": { "county": "BRONX" },
    "sortOrder": "license_number DESC"
}
````

**Example: full-text search across NY State agency contracts.**

```json
{
    "maxItems": 100,
    "resourceId": "6gke-w4nb",
    "searchQuery": "education technology"
}
```

> ⚠️ **Good to Know:** dataset resource IDs are 4x4 Socrata identifiers visible in every dataset URL at data.ny.gov. Column names in `filters` and `sortOrder` use the dataset's API field names (lowercase with underscores), not the human-readable column headers.

***

### 📊 Output

Each record contains **4 fields**. Download the dataset as CSV, Excel, JSON, or XML.

#### 🧾 Schema

| Field | Type | Example |
|---|---|---|
| 🆔 `resourceId` | string | `"9a8c-vfzj"` |
| 📦 `row` | object | `{ "license_number": "...", "county": "BRONX", ... }` |
| 🕒 `scrapedAt` | ISO 8601 | `"2026-05-23T10:00:00.000Z"` |
| ❌ `error` | string | null | `null` |

#### 📦 Sample records

<details>
<summary><strong>🪪 Active driver license row (Bronx county)</strong></summary>

```json
{
    "resourceId": "9a8c-vfzj",
    "row": {
        "license_number": "123456789",
        "name_first": "JOHN",
        "name_last": "DOE",
        "date_of_birth": "1980-05-15",
        "county": "BRONX",
        "license_class": "D",
        "license_expiration_date": "2027-12-31"
    },
    "scrapedAt": "2026-05-23T10:00:00.000Z"
}
```

</details>

<details>
<summary><strong>🚇 MTA ridership row</strong></summary>

```json
{
    "resourceId": "vxuj-8kew",
    "row": {
        "date": "2025-12-01",
        "subways_total_estimated_ridership": 4123456,
        "buses_total_estimated_ridership": 1456789,
        "lirr_total_estimated_ridership": 234567
    },
    "scrapedAt": "2026-05-23T10:00:00.000Z"
}
```

</details>

<details>
<summary><strong>🏫 School report card row</strong></summary>

```json
{
    "resourceId": "z8hd-axxx",
    "row": {
        "district_name": "NEW YORK CITY GEOGRAPHIC DISTRICT #2",
        "school_year": "2024-25",
        "grade_level": "3",
        "ela_proficiency_percent": 67.4
    },
    "scrapedAt": "2026-05-23T10:00:00.000Z"
}
```

</details>

***

### ✨ Why choose this Actor

| | Capability |
|---|---|
| 🗽 | **1,500+ datasets.** Every public dataset on data.ny.gov is reachable by resource ID. |
| 🔎 | **Native Socrata filtering.** Full-text search, column equality, and sort, exposed as inputs. |
| 📦 | **Schema-preserving rows.** Every dataset column is passed through unchanged. |
| 🏛️ | **Official source.** Direct from the NY State open-data portal, no third-party caching. |
| ⚡ | **Fast pagination.** Pulls thousands of rows per minute with automatic offset handling. |
| 🚫 | **No authentication.** Works against the public Socrata catalog. No login or API key needed. |
| 🔁 | **Always fresh.** Each run pulls live rows, reflecting whatever the publishing agency updated last. |

> 📊 NY State has one of the most active state-level open-data programs in the U.S. This Actor turns that catalog into structured rows for any downstream system.

***

### 📈 How it compares to alternatives

| Approach | Cost | Coverage | Refresh | Setup |
|---|---|---|---|---|
| **⭐ NY State Open Data Scraper** *(this Actor)* | $5 free credit, then pay-per-use | **1,500+ datasets** | **Live per run** | ⚡ 2 min |
| Hand-written Socrata client | Free + engineering | Same | Build it yourself | 🛠️ Hours per dataset |
| Commercial real-estate / civic data providers | $$$$ | Curated subset | Real-time | ⏳ Days |
| One-off CSV downloads | Free | Snapshot only | Manual | 🐢 Tech debt |

Pick this Actor when you want consistent NY State open-data rows without writing per-dataset glue code.

***

### 🚀 How to use

1. 📝 **Sign up.** [Create a free account with $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp) (takes 2 minutes).
2. 🌐 **Open the Actor.** Go to the NY State Open Data Scraper page on the Apify Store.
3. 🎯 **Set input.** Paste a resource ID from data.ny.gov, add optional filters or a search query, and set `maxItems`.
4. 🚀 **Run it.** Click **Start** and let the Actor collect your data.
5. 📥 **Download.** Grab your results in the **Dataset** tab as CSV, Excel, JSON, or XML.

> ⏱️ Total time from signup to downloaded dataset: **3-5 minutes.** No coding required.

***

### 💼 Business use cases

<table>
<tr>
<td width="50%" valign="top">

#### 🏠 Real Estate & Property

- Assessment-roll comps for valuation models
- Tax-lien and lis-pendens monitoring
- Neighborhood and borough demographic overlays
- Property-transfer pipelines for brokerage tools

</td>
<td width="50%" valign="top">

#### 📰 Journalism & Investigations

- FOIL-free first pass on state datasets
- Public-spending and contract analysis
- License and inspection-record reporting
- Election and campaign-finance reporting

</td>
</tr>
<tr>
<td width="50%" valign="top">

#### 🏛️ Civic-Tech & Government

- Civic-app data layers
- Public-service dashboards
- Resident-facing search tools
- Transparency portals and accountability sites

</td>
<td width="50%" valign="top">

#### 📊 Urban Analytics & Planning

- Transit ridership trend modeling
- Public-health surveillance dashboards
- School-performance research
- Environmental sensor analytics

</td>
</tr>
</table>

***

### 🔌 Automating New York State Open Data Scraper

Control the scraper programmatically for scheduled runs and pipeline integrations:

- 🟢 **Node.js.** Install the `apify-client` NPM package.
- 🐍 **Python.** Use the `apify-client` PyPI package.
- 📚 See the [Apify API documentation](https://docs.apify.com/api/v2) for full details.

The [Apify Schedules feature](https://docs.apify.com/platform/schedules) lets you trigger this Actor on any cron interval. A daily run after the publishing agency's nightly refresh keeps downstream tables current automatically.

***

### 🌟 Beyond business use cases

Open civic data powers more than enterprise dashboards. The same structured rows support research, education, activism, and personal initiatives.

<table>
<tr>
<td width="50%">

#### 🎓 Research and academia

- Urban-planning thesis projects
- Public-policy quantitative research
- Reproducible civic-data coursework
- Open-government accountability studies

</td>
<td width="50%">

#### 🎨 Personal and creative

- Neighborhood-explorer hobby maps
- Personal property-research tools
- Data-art and civic-visualization projects
- Local-history storytelling

</td>
</tr>
<tr>
<td width="50%">

#### 🤝 Non-profit and civic

- Voter education and outreach
- Tenant-rights organizing
- Public-health advocacy
- Environmental justice campaigns

</td>
<td width="50%">

#### 🧪 Experimentation

- Train city-prediction models
- Prototype civic AI agents
- Build neighborhood-aware browser extensions
- Test data-pipeline frameworks on real records

</td>
</tr>
</table>

***

### 🤖 Ask an AI assistant about this scraper

Open a ready-to-send prompt about this ParseForge actor in the AI of your choice:

- 💬 [**ChatGPT**](https://chat.openai.com/?q=How%20do%20I%20use%20the%20New%20York%20State%20Open%20Data%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🧠 [**Claude**](https://claude.ai/new?q=How%20do%20I%20use%20the%20New%20York%20State%20Open%20Data%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🔍 [**Perplexity**](https://perplexity.ai/search?q=How%20do%20I%20use%20the%20New%20York%20State%20Open%20Data%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🅒 [**Copilot**](https://copilot.microsoft.com/?q=How%20do%20I%20use%20the%20New%20York%20State%20Open%20Data%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)

***

### ❓ Frequently Asked Questions

#### 🧩 How does it work?

Paste a resource ID from any data.ny.gov dataset, add optional filters or a search query, click Start, and the Actor pages through Socrata and emits one clean structured row per record.

#### 📏 How accurate is the data?

The Actor reads rows directly from the official NY State portal. Accuracy and timeliness depend on the publishing agency. Each dataset page on data.ny.gov shows the last-updated timestamp.

#### 🔁 How often is the dataset refreshed?

Update cadence varies by dataset: some refresh nightly (driver licenses, MTA ridership), others quarterly or annually (tax rolls, school report cards). Every run of this Actor pulls live rows.

#### 🆔 How do I find a resource ID?

Open any dataset on data.ny.gov. The 4x4 identifier (e.g. `9a8c-vfzj`) appears in the URL and in the API docs panel.

#### 📊 How many datasets are covered?

More than 1,500 public datasets across health, transportation, education, real estate, energy, agriculture, public safety, and dozens of other domains.

#### ⏰ Can I schedule regular runs?

Yes. Use Apify Schedules to run this Actor on any cron interval. A nightly cron is enough for most operational use cases.

#### ⚖️ Is this data legal to use?

Data published on data.ny.gov is open for commercial reuse under standard public-data terms. Check the per-dataset terms page on data.ny.gov for any attribution requirements.

#### 💼 Can I use this data commercially?

Yes. NY State open data is licensed for commercial reuse. You are responsible for downstream compliance with privacy regulations relevant to your use case.

#### 💳 Do I need a paid Apify plan to use this Actor?

No. The free Apify plan is enough for testing and small runs (10 records per run). A paid plan lifts the limit and unlocks scheduling and higher concurrency.

#### 🧮 How do filters work?

Pass an object like `{"county": "BRONX"}` for exact-match column equality. For ranges and complex predicates use the search query for full-text matching across all columns.

#### 🆘 What if I need help?

Our support team is here to help. Contact us through the Apify platform or use the Tally form linked below.

***

### 🔌 Integrate with any app

NY State Open Data Scraper connects to any cloud service via [Apify integrations](https://apify.com/integrations):

- [**Make**](https://docs.apify.com/platform/integrations/make) - Automate multi-step workflows
- [**Zapier**](https://docs.apify.com/platform/integrations/zapier) - Connect with 5,000+ apps
- [**Slack**](https://docs.apify.com/platform/integrations/slack) - Get run notifications in your channels
- [**Airbyte**](https://docs.apify.com/platform/integrations/airbyte) - Pipe NY State rows into your warehouse
- [**GitHub**](https://docs.apify.com/platform/integrations/github) - Trigger runs from commits and releases
- [**Google Drive**](https://docs.apify.com/platform/integrations/drive) - Export datasets straight to Sheets

You can also use webhooks to alert your team when a watched dataset crosses a threshold, or to push fresh rows into a Notion knowledge base.

***

### 🔗 Recommended Actors

- [**🏙️ Chicago Open Data Portal Scraper**](https://apify.com/parseforge/data-cityofchicago-scraper) - Official City of Chicago open data
- [**🇨🇴 Colombia datos.gov.co Scraper**](https://apify.com/parseforge/colombia-datos-gov-co-scraper) - Official Colombian government open data
- [**🇨🇱 Chile datos.gob.cl Scraper**](https://apify.com/parseforge/chile-datos-gob-cl-scraper) - Official Chilean government open data
- [**🇬🇧 GOV.UK Bank Holidays Scraper**](https://apify.com/parseforge/gov-uk-bank-holidays-scraper) - Official UK bank-holiday calendar
- [**🌐 Nominatim OSM Scraper**](https://apify.com/parseforge/nominatim-osm-scraper) - Geocode addresses via OpenStreetMap

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for more civic and open-data scrapers.

***

**🆘 Need Help?** [**Open our contact form**](https://tally.so/r/BzdKgA) to request a new scraper, propose a custom data project, or report an issue.

***

> **⚠️ Disclaimer:** this Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by the State of New York, any New York State agency, or Socrata/Tyler Technologies. All trademarks mentioned are the property of their respective owners. Only publicly available open civic data is collected.

# Actor input Schema

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

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

## `resourceId` (type: `string`):

The dataset identifier (e.g. 9a8c-vfzj for Active Driver License Information). Find IDs at data.ny.gov.

## `searchQuery` (type: `string`):

Full-text search across all columns of the selected resource.

## `filters` (type: `object`):

Exact-match column filters. Example: {"county": "BRONX", "operation\_type": "Store"}.

## `sortOrder` (type: `string`):

Order results by a column. Example: 'license\_number DESC' or 'city ASC'.

## `selectColumns` (type: `string`):

Comma-separated list of columns to return. Example: 'license\_number, city, county'. Leave blank to return all columns.

## `whereClause` (type: `string`):

Advanced filter expression. Example: "county = 'BRONX' AND license\_type = 'STORE'" or "date\_created > '2024-01-01'".

## `groupBy` (type: `string`):

Group rows by one or more columns. Example: 'county'. Combine with selectColumns containing aggregates like count(\*).

## `havingClause` (type: `string`):

Filter on grouped/aggregated rows. Example: 'count(\*) > 100'. Requires Group By.

## Actor input object example

```json
{
  "maxItems": 10,
  "resourceId": "9a8c-vfzj"
}
```

# Actor output Schema

## `overview` (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 = {
    "maxItems": 10,
    "resourceId": "9a8c-vfzj"
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/data-ny-gov-new-york-open-data-scraper").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 = {
    "maxItems": 10,
    "resourceId": "9a8c-vfzj",
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/data-ny-gov-new-york-open-data-scraper").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 '{
  "maxItems": 10,
  "resourceId": "9a8c-vfzj"
}' |
apify call parseforge/data-ny-gov-new-york-open-data-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=parseforge/data-ny-gov-new-york-open-data-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "New York Open Data Scraper",
        "description": "Query New York State open data catalog across thousands of datasets covering health, transport, education, finance, environment, and demographics. Filter by dataset, agency, or category and export rows to JSON, CSV, or Excel for civic research, journalism, and analytics dashboards.",
        "version": "1.0",
        "x-build-id": "9yEbUJpXVEht6XorG"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~data-ny-gov-new-york-open-data-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-data-ny-gov-new-york-open-data-scraper",
                "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/parseforge~data-ny-gov-new-york-open-data-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-data-ny-gov-new-york-open-data-scraper",
                "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/parseforge~data-ny-gov-new-york-open-data-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-data-ny-gov-new-york-open-data-scraper",
                "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",
                "required": [
                    "resourceId"
                ],
                "properties": {
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    },
                    "resourceId": {
                        "title": "Resource ID",
                        "type": "string",
                        "description": "The dataset identifier (e.g. 9a8c-vfzj for Active Driver License Information). Find IDs at data.ny.gov."
                    },
                    "searchQuery": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Full-text search across all columns of the selected resource."
                    },
                    "filters": {
                        "title": "Column Filters",
                        "type": "object",
                        "description": "Exact-match column filters. Example: {\"county\": \"BRONX\", \"operation_type\": \"Store\"}."
                    },
                    "sortOrder": {
                        "title": "Sort Order",
                        "type": "string",
                        "description": "Order results by a column. Example: 'license_number DESC' or 'city ASC'."
                    },
                    "selectColumns": {
                        "title": "Select Columns",
                        "type": "string",
                        "description": "Comma-separated list of columns to return. Example: 'license_number, city, county'. Leave blank to return all columns."
                    },
                    "whereClause": {
                        "title": "Where Clause",
                        "type": "string",
                        "description": "Advanced filter expression. Example: \"county = 'BRONX' AND license_type = 'STORE'\" or \"date_created > '2024-01-01'\"."
                    },
                    "groupBy": {
                        "title": "Group By",
                        "type": "string",
                        "description": "Group rows by one or more columns. Example: 'county'. Combine with selectColumns containing aggregates like count(*)."
                    },
                    "havingClause": {
                        "title": "Having Clause",
                        "type": "string",
                        "description": "Filter on grouped/aggregated rows. Example: 'count(*) > 100'. Requires Group By."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
