# US Property Records Scraper - Owner Leads (`scrapesage/us-property-records-scraper`) Actor

Scrape US property & parcel records with owner names, mailing addresses, absentee-owner flags, assessed/market values & characteristics from official open-data portals: NY statewide (23M parcels), NYC, Cook County/Chicago, Norfolk VA. Filters + monitoring, no browser.

- **URL**: https://apify.com/scrapesage/us-property-records-scraper.md
- **Developed by:** [Scrape Sage](https://apify.com/scrapesage) (community)
- **Categories:** Real estate, Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$2.50 / 1,000 property records

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## US Property Records Scraper — Owner Leads, Mailing Addresses & Values

Extract **property & parcel records with the owner data real-estate investors actually pay for** — **owner names, owner mailing addresses, absentee-owner flags, assessed & market values, and full property characteristics** — straight from **official county and state assessment open-data portals**. Every record is a ready-to-mail **owner lead**: who owns it, where to reach them, what it's worth, and how good a prospect it is (lead score 0–100).

No login, no cookies, no browser, no paid data broker — fast, clean extraction from public government records.

### Why this property-records scraper?

Most "property" scrapers return for-sale listings, or a single county, or owner names with **no mailing address** (so you can't actually contact anyone). This actor merges **multiple official assessment rolls into one unified schema** and ships the data that drives direct-mail and skip-trace pipelines — including the **absentee-owner flag** that separates out-of-area landlords (your best sellers) from owner-occupants.

| Data | Typical scrapers | This actor |
|---|---|---|
| Owner name(s) | partial | ✅ |
| Owner **mailing address** (where to send mail) | ❌ | ✅ where published |
| **Absentee / out-of-state owner** flag | ❌ | ✅ derived |
| Owner type (individual / business / trust / government) | ❌ | ✅ classified |
| Market value / assessed value / land & improvement value | partial | ✅ |
| Property type & class (normalized + raw codes) | partial | ✅ |
| Year built, units, floors, lot & building area, zoning | ❌ | ✅ where published |
| Last sale date & price | ❌ | ✅ where published |
| Multiple states / counties in **one** dataset | ❌ | ✅ |
| Lead score (0–100) per property | ❌ | ✅ |
| Monitor mode — only new/changed records | ❌ | ✅ |

### Coverage (official open-data sources)

| Source | Area | Owner | Mailing addr | Value | Characteristics |
|---|---|---|---|---|---|
| **ny-state** | New York **statewide** (23.5M parcels, excl. NYC) | ✅ | ✅ | market + assessed | class, school district |
| **nyc** | New York City — all five boroughs (PLUTO) | ✅ | — | assessed | year built, units, floors, area, zoning, geo |
| **cook-il** | Cook County / **Chicago**, IL | ✅ | ✅ | — | property & owner address |
| **norfolk-va** | **Norfolk, VA** | ✅ | — | market + land + improvement | year built, area, last sale |

All four are clean, keyless government Socrata APIs — no anti-bot, no browser. More states/counties are added over time (the schema is identical across sources).

### Use cases

- **Real-estate investor & wholesaler lead lists** — pull every **absentee owner** in a county or ZIP, with their mailing address, and run direct-mail or cold-call campaigns. Sort by `leadScore` or value.
- **Direct-mail & skip-tracing input** — owner name + mailing address is the seed every skip-trace and mail house needs; export to CSV and go.
- **Portfolio-landlord & commercial prospecting** — filter to `businessOwnersOnly` (LLC/Corp/Trust) to find entity owners, multi-unit buildings, and high-value commercial parcels.
- **Property-services lead gen** — roofers, solar, insurance, property managers, and lenders target owners by property type, value band, and year built.
- **Market & ownership intelligence** — assessed/market values, sales, and land-use mix by area; track who owns what.
- **Monitoring** — schedule recurring runs and capture only new owners, sales, and parcels as assessment rolls refresh.

### How to use

1. [Sign up for Apify](https://console.apify.com/sign-up) — the free plan is enough to try this actor.
2. Open the **US Property Records Scraper**, pick **sources** and add filters (county, city, ZIP, property type, value band, `absenteeOwnersOnly`), then click **Start**.
3. Watch results stream into the dataset table.
4. **Export** as JSON, CSV, Excel, XML, or RSS — or pull results programmatically via the [Apify API](https://docs.apify.com/api/v2).

### Input

```json
{
    "sources": ["ny-state", "cook-il"],
    "counties": ["Westchester"],
    "propertyTypes": ["residential"],
    "absenteeOwnersOnly": true,
    "businessOwnersOnly": false,
    "minValue": 250000,
    "maxResults": 1000,
    "sortBy": "value"
}
```

- **sources** — which portals to query: `ny-state`, `nyc`, `cook-il`, `norfolk-va`. Leave empty for all.
- **counties** — New York county names (`Westchester`, `Erie`, `Nassau`, `Suffolk`, …); applies to `ny-state`.
- **cities** — property city / town / municipality. NYC accepts a borough name (`Manhattan`, `Brooklyn`, …).
- **zipCodes** — property ZIP, full or prefix (`112` = all 112xx).
- **propertyTypes** — `residential`, `commercial`, `industrial`, `vacant`, `agricultural`, `other`.
- **ownerNameQuery** — owner name contains (e.g. `LLC`, `Trust`, a company/person).
- **absenteeOwnersOnly** — only owners whose mailing address differs from the property (out-of-area landlords). Applies to sources with a mailing address (`ny-state`, `cook-il`).
- **businessOwnersOnly** — only LLC / corporation / partnership / trust owners.
- **excludeGovernmentOwners** *(default true)* — drop city/state/federal/authority owners.
- **minValue / maxValue** — value band (market value for NY State & Norfolk, assessed for NYC).
- **minYearBuilt / maxYearBuilt** — applies to NYC & Norfolk.
- **rollYear** — pin NY State / Cook County to a year (default: latest).
- **sortBy** — `value` (highest first), `newest` (latest sale), `leadScore`, or `none`.
- **maxResults / maxResultsPerSource**, **deduplicateResults**, **socrataAppToken** (optional, higher rate limits).
- **monitorMode / monitorKey** — emit only new/changed records since the last run.

### Output

One record per property (`recordType: "property"`):

```json
{
    "recordType": "property",
    "source": "ny-state",
    "sourceLabel": "NY State Assessment Roll",
    "state": "NY",
    "county": "Westchester",
    "municipality": "Yonkers",
    "propertyAddress": "120 Main St, Yonkers, NY",
    "propertyCity": "Yonkers",
    "propertyState": "NY",
    "parcelId": "012.34-5-6",
    "ownerName": "120 MAIN STREET LLC",
    "ownerNames": ["120 MAIN STREET LLC"],
    "ownerType": "business",
    "isBusiness": true,
    "mailingAddress": "500 Park Ave, New York, NY 10022",
    "mailingCity": "New York",
    "mailingState": "NY",
    "mailingZip": "10022",
    "absenteeOwner": true,
    "ownerOccupied": false,
    "isOutOfStateOwner": false,
    "propertyType": "residential",
    "propertyClass": "Apartment",
    "propertyClassCode": "411",
    "marketValue": 1850000,
    "assessedValue": 1480000,
    "landValue": 320000,
    "taxableValue": 1480000,
    "schoolDistrict": "Yonkers",
    "rollYear": "2025",
    "leadScore": 84,
    "sourceFields": { "...": "every raw field from the source row" },
    "scrapedAt": "2026-06-20T12:00:00.000Z"
}
```

NYC adds `yearBuilt`, `unitsResidential`, `unitsTotal`, `numFloors`, `lotAreaSqFt`, `buildingAreaSqFt`, `zoning`, `latitude`/`longitude`; Norfolk adds `lastSaleDate`, `lastSalePrice`, `improvementValue`, `acreage`. Every source row's raw fields are kept under `sourceFields` so you never lose data. A field is `null` only when that source doesn't publish it — nothing is dropped.

### Automate & schedule

Run this actor on autopilot and pull results into your own stack:

- **[Apify API](https://docs.apify.com/api/v2)** — start runs, fetch datasets, and manage schedules over REST.
- **[apify-client for JavaScript](https://docs.apify.com/api/client/js/)** and **[apify-client for Python](https://docs.apify.com/api/client/python/)** — official SDKs.
- **[Schedules](https://docs.apify.com/platform/schedules)** — run it daily/weekly to capture new owners, sales, and parcels as assessment rolls refresh; perfect for fresh lead pipelines.
- **[Webhooks](https://docs.apify.com/platform/integrations/webhooks)** — trigger downstream actions (CRM import, Slack alert, mail-merge) the moment a run finishes.

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'MY_APIFY_TOKEN' });

const run = await client.actor('scrapesage/us-property-records-scraper').call({
    sources: ['ny-state'],
    counties: ['Westchester'],
    absenteeOwnersOnly: true,
    propertyTypes: ['residential'],
    maxResults: 1000,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`Got ${items.length} property owner leads`);
```

**Monitoring vs. Schedules:** turn on `monitorMode` to emit only properties that are **new or changed** since the last run (tagged `monitorEvent: "new"`). It pairs with [Schedules](https://docs.apify.com/platform/schedules) — the schedule starts the run, monitoring decides what's new — so the two never conflict.

### Integrate with any app

Connect the dataset to 5,000+ apps — no code required:

- **[Make](https://docs.apify.com/platform/integrations/make)** — multi-step automation scenarios.
- **[Zapier](https://docs.apify.com/platform/integrations/zapier)** — push new owner leads straight into your CRM or mail house.
- **[Slack](https://docs.apify.com/platform/integrations/slack)** — get notified when a monitored area gets new records.
- **[Google Drive / Sheets](https://docs.apify.com/platform/integrations/drive)** — auto-export every run to a spreadsheet.
- **[Airbyte](https://docs.apify.com/platform/integrations/airbyte)** — pipe results into your data warehouse.
- **[GitHub](https://docs.apify.com/platform/integrations/github)** — trigger runs from commits or releases.

### Use with AI assistants (MCP)

The output is clean, LLM-ready JSON. Call this actor from Claude, ChatGPT, or any agent framework through the **[Apify MCP server](https://docs.apify.com/platform/integrations/mcp)** — ask your assistant to "find absentee owners of 2–4 unit residential properties in Westchester County over $400k" and let it run the scraper for you.

### Agent-ready: autonomous payments (x402 & Skyfire)

This actor is **agent-ready** — AI agents can discover it, run it, and **pay for it autonomously**, with no Apify account and no human in the loop. It uses [pay-per-event](https://docs.apify.com/platform/actors/publishing/monetize/pay-per-event) pricing and [limited permissions](https://docs.apify.com/platform/actors/development/permissions), so it qualifies for Apify's agentic-payment standards:

- **[x402](https://docs.apify.com/platform/integrations/x402)** — an open, HTTP-native payment protocol. Agents pay per run in USDC on the Base network directly through the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp) — no account, no API key.
- **[Skyfire](https://docs.apify.com/platform/integrations/skyfire)** — agent-to-service payments for fully autonomous AI-agent workflows.

Building an AI agent, MCP tool, or autonomous data pipeline? This scraper is ready to plug in and pay as it goes.

### More scrapers from scrapesage

Build a complete **real-estate & owner lead-gen stack**:

- **[Redfin Scraper](https://apify.com/scrapesage/redfin-scraper)** — for-sale listings, sold comps & estimates.
- **[Crexi Scraper](https://apify.com/scrapesage/crexi-scraper)** — commercial real estate, prices & broker leads.
- **[Rent.com Scraper](https://apify.com/scrapesage/rent-com-scraper)** — apartments, rentals & property leads.
- **[US Building Permits Scraper](https://apify.com/scrapesage/us-building-permits-scraper)** — construction & contractor leads from the same owners.
- **[FastExpert Scraper](https://apify.com/scrapesage/fastexpert-agent-scraper)** — real-estate agent leads & reviews.
- **[BuildZoom Scraper](https://apify.com/scrapesage/buildzoom-scraper)** — contractors, licenses, permits & leads.
- **[US Business Formation Scraper](https://apify.com/scrapesage/us-business-formation-scraper)** — new LLC & company owner leads.
- **[Website Contact Scraper](https://apify.com/scrapesage/website-contact-scraper)** — turn an owner's business website into emails, phones & socials.

### Tips

- **Targeting absentee landlords**: set `absenteeOwnersOnly: true` with `ny-state` or `cook-il` (the sources that publish a mailing address). Add `businessOwnersOnly` to focus on LLC/portfolio owners.
- **Big areas**: narrow with `counties` / `cities` / `zipCodes` and a `minValue` band — the actor pulls server-side-sorted results, so the most valuable (or newest) records come first.
- **Rate limits**: very large runs go faster with a free `socrataAppToken` (from any of the open-data portals).
- **Recurring leads**: combine [Schedules](https://docs.apify.com/platform/schedules) with `monitorMode` to capture only new owners/sales each run.

### FAQ

**Where does the owner data come from?** From official county and state property-assessment open-data portals (public records). No paid data broker, no login.

**Do I get owner phone numbers or emails?** Public assessment records contain the owner **name and mailing address**, not phone/email — that's exactly what skip-trace and direct-mail workflows need. For business owners, pipe the owner name into the [Website Contact Scraper](https://apify.com/scrapesage/website-contact-scraper) to enrich with emails and phones.

**What's the absentee-owner flag?** It's `true` when the owner's mailing address is in a different city or state than the property — the signal that the owner doesn't live there (a landlord/investor). It's computed only for sources that publish a mailing address.

**Why is a field null?** Some sources don't publish every field (e.g. NYC has no owner mailing address; Cook County has no value). Fields are `null` only when that source doesn't publish them — never because the scraper skipped them; the full raw row is always in `sourceFields`.

**Can I export to Google Sheets, CSV, or Excel?** Yes — one click in the dataset view, or automatically on every run via the [Google Drive integration](https://docs.apify.com/platform/integrations/drive).

**How do I monitor an area for new records?** Create a [Schedule](https://docs.apify.com/platform/schedules) and turn on `monitorMode` — you'll get only new/changed properties each run.

**Is scraping this data legal?** This actor collects publicly available government records only. You are responsible for using the data in compliance with applicable laws (e.g. GDPR/CCPA, DPPA, and direct-mail/telemarketing rules) and each portal's terms.

### Need help?

Open an issue on the actor's **Issues** tab, or visit the [Apify help center](https://help.apify.com/). Feature requests — including additional states/counties — are welcome; this actor is actively maintained.

# Actor input Schema

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

Which official open-data portals to query. <b>ny-state</b> = New York statewide assessment roll (23.5M parcels, owner + mailing address + market value, excludes NYC). <b>nyc</b> = New York City PLUTO (every NYC tax lot: owner, assessed value, building characteristics). <b>cook-il</b> = Cook County / Chicago (owner name + owner mailing address + property address). <b>norfolk-va</b> = Norfolk, VA (owner, values, year built, last sale). Leave empty for all.

## `counties` (type: `array`):

Filter by county — applies to the <b>ny-state</b> source, e.g. <code>Westchester</code>, <code>Erie</code>, <code>Nassau</code>, <code>Suffolk</code>, <code>Monroe</code>, <code>Albany</code>. Case-insensitive exact county name.

## `cities` (type: `array`):

Filter by the property's city / town / municipality (case-insensitive exact match). NY State uses the municipality name (<code>Yonkers</code>, <code>Buffalo</code>). NYC accepts a borough name (<code>Manhattan</code>, <code>Brooklyn</code>, <code>Queens</code>, <code>Bronx</code>, <code>Staten Island</code>). Cook County / Norfolk use the city name (<code>Chicago</code>, <code>Evanston</code>, <code>Norfolk</code>).

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

Filter by property ZIP — full ZIP (<code>11201</code>) or a prefix (<code>112</code> matches all 112xx). Applies to NYC, Cook County and Norfolk (NY State has no parcel ZIP, so it matches the owner's mailing ZIP there).

## `addressContains` (type: `string`):

Only return properties whose street address contains this text (case-insensitive), e.g. <code>Broadway</code> or <code>Main St</code>.

## `propertyTypes` (type: `array`):

Filter by normalized property type. Applies where the dataset publishes a property class (NY State, NYC, Norfolk); Cook County has no class field and is skipped when this is set.

## `propertyClassCodes` (type: `array`):

Power-user passthrough of the source's own class codes. NY State = 3-digit property class (<code>210</code> one-family, <code>411</code> apartment). NYC = building class (<code>A1</code>, <code>D6</code>, <code>O4</code>). Matched exactly (case-insensitive).

## `ownerNameQuery` (type: `string`):

Only return properties whose owner name contains this text (case-insensitive), e.g. <code>LLC</code>, <code>Trust</code>, or a specific person/company name.

## `absenteeOwnersOnly` (type: `boolean`):

Only return properties where the owner's mailing address is in a different city/state than the property (out-of-area landlords & investors — the highest-converting direct-mail leads). Requires a mailing address, so it applies to NY State and Cook County; NYC and Norfolk are skipped when this is on.

## `businessOwnersOnly` (type: `boolean`):

Only return properties owned by a company, LLC, corporation, partnership or trust (filters out owner-occupant individuals). Ideal for portfolio-landlord and commercial prospecting.

## `excludeGovernmentOwners` (type: `boolean`):

Drop properties owned by a government body (city, county, state, federal, authorities, school districts, transit). Recommended for lead lists.

## `minValue` (type: `integer`):

Only properties at or above this value. Uses market value (NY State, Norfolk) or assessed value (NYC). Cook County has no value field and is skipped when this is set.

## `maxValue` (type: `integer`):

Only properties at or below this value.

## `minYearBuilt` (type: `integer`):

Only properties built in or after this year. Applies to NYC and Norfolk (which publish year built).

## `maxYearBuilt` (type: `integer`):

Only properties built in or before this year. Applies to NYC and Norfolk.

## `rollYear` (type: `integer`):

Pin NY State and Cook County to a specific year. Leave blank to use the latest available year automatically.

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

Maximum number of property records to return in this run (across all selected sources).

## `maxResultsPerSource` (type: `integer`):

Cap how many records are pulled from each source before the global limit and sorting are applied. Leave blank to use the same value as Max results.

## `sortBy` (type: `string`):

Order of the returned records. <b>value</b> = highest value first (best for high-equity targets). <b>newest</b> = most recent sale first (Norfolk). <b>leadScore</b> = best leads first. <b>none</b> = natural order (fastest).

## `deduplicateResults` (type: `boolean`):

Skip duplicate property records within this run (recommended).

## `monitorMode` (type: `boolean`):

Remember which properties were already returned (in a named key-value store) and emit ONLY records that are new since the last run — each tagged <code>monitorEvent: "new"</code>. A change of owner or a new sale also surfaces as new. Portals refresh on each assessment roll; run on a Schedule to capture new owners, sales and listings as fresh leads. Works alongside Apify Schedules (the schedule starts the run; monitoring decides what's new).

## `monitorKey` (type: `string`):

Names the memory used by monitoring mode. Use a distinct key per saved watch (e.g. per area/source) so different monitors don't share state.

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

Optional Socrata app token for higher rate limits on very large runs. Not required — leave blank for normal use. Get one free at any of the open-data portals (e.g. data.ny.gov).

## `proxyConfiguration` (type: `object`):

Optional proxy. Government open data is fetched directly and needs no proxy — leave this off for the fastest runs. Enable Apify Proxy only if your network requires it.

## Actor input object example

```json
{
  "sources": [
    "ny-state",
    "nyc",
    "cook-il",
    "norfolk-va"
  ],
  "absenteeOwnersOnly": false,
  "businessOwnersOnly": false,
  "excludeGovernmentOwners": true,
  "maxResults": 100,
  "sortBy": "value",
  "deduplicateResults": true,
  "monitorMode": false,
  "monitorKey": "default",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

All scraped property / owner-lead records as JSON items in the default dataset.

# 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": [
        "ny-state",
        "nyc",
        "cook-il",
        "norfolk-va"
    ],
    "maxResults": 100,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapesage/us-property-records-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 = {
    "sources": [
        "ny-state",
        "nyc",
        "cook-il",
        "norfolk-va",
    ],
    "maxResults": 100,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapesage/us-property-records-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 '{
  "sources": [
    "ny-state",
    "nyc",
    "cook-il",
    "norfolk-va"
  ],
  "maxResults": 100,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call scrapesage/us-property-records-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=scrapesage/us-property-records-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/DIg6A6oy4iaBVVvvb/builds/h8dwWWdECSqQWMgzH/openapi.json