# EstateSales.net Estate Sale Scraper — State, City, ZIP & Alerts (`scrapersdelight/estatesales-net-scraper`) Actor

Scrape EstateSales.net estate sales by state, city, ZIP, geo radius, or keyword — title, company, phone, address, dates, photos & full description. Monitor mode + Slack/email/webhook alerts for new sales in your area. No login or API key. From $4 per 1,000 sales.

- **URL**: https://apify.com/scrapersdelight/estatesales-net-scraper.md
- **Developed by:** [Scrapers Delight](https://apify.com/scrapersdelight) (community)
- **Categories:** E-commerce, Automation, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

## 🏠 EstateSales.net Scraper & New-Sale Monitor

**Scrape live EstateSales.net estate-sale listings — title, company, phone, address, city/state/ZIP, start/end dates, full description, and every photo — by state, city, ZIP, geo radius, or keyword. Then run it on a schedule as a new-sale monitor that pings Slack, email, or webhook the moment a fresh sale is posted in your area, so you're first through the door.**

Turn EstateSales.net into a clean dataset or a real-time sale alert. No login, no API key, no browser automation — the site filters server-side, so you pull only the sales you actually want.

---

### What does EstateSales.net Scraper do?

EstateSales.net Scraper extracts **estate sale, auction, and moving-sale listings** from [EstateSales.net](https://www.estatesales.net) — the largest estate-sale directory in the US — and returns clean, structured rows you can export to **JSON, CSV, Excel, or push to your app via API**. Antiques, furniture, tools, collectibles, whole-house liquidations — listed by professional estate-sale companies and private sellers nationwide.

- 🔎 **Search the way the site does** — by state, city, ZIP, coordinates + radius, or keyword. All server-side.
- 🏢 **Company & contact** — the estate-sale company running it, website, and phone number(s).
- 📍 **Location** — street address (once the site reveals it), city, state, ZIP, lat/lon, and parking directions.
- 📅 **Every sale session** — first start / last end plus the full per-day schedule in UTC and local time.
- 📝 **Full description & photos** — complete sale description, terms, and every photo CDN URL.
- 🔔 **New-sale monitor** — schedule it and get **Slack / email / webhook alerts** for newly listed sales in your area.

---

### What data does it extract?

For every estate sale:

- 🆔 `sale_id`, 🔗 `sale_url`, 🏷️ `title`, 🗂️ `sale_type`
- 🏢 `company`, `company_id`, `company_website`, `company_is_trusted`
- ☎️ `phone_numbers[]`
- 📍 `address`, `city`, `state`, `zipcode`, `latitude`, `longitude`, `directions`
- 📅 `start_date`, `end_date`, `local_start_date`, `local_end_date`, `sale_dates[]` (every session)
- 🕰️ `address_revealed_at`, `first_published`, `last_modified`
- 📝 `description`, `description_excerpt`, `terms`
- 🖼️ `pictures[]`, `thumbnail`, `picture_count`, 🎬 `video_url`
- 🚦 `status`, ✨ `is_new` (monitor mode), 🕒 `scraped_at`

> **Note:** EstateSales.net reveals the exact street address only shortly before a sale starts (`address_revealed_at`). Earlier than that the `address` field is empty **by design** — city/state/ZIP and lat/lon are always there.

---

### Who is it for?

- 🛒 **Resellers, pickers & antique dealers** finding tomorrow's sales before the crowd.
- 🏠 **Estate-sale companies** tracking competitor activity, pricing, and coverage by metro.
- 📦 **Liquidators & junk-removal / cleanout services** prospecting fresh leads with phone numbers.
- 🏘️ **Real-estate investors & agents** spotting upcoming property transitions in a farm area.
- 📊 **Data teams & aggregators** combining estate sales with auction and garage-sale sources.

---

### Two ways to use it

1. **Bulk scrape** — pull every active sale for a state, city, ZIP, radius, or keyword into one clean dataset.
2. **New-sale monitor** *(the recurring play)* — set `monitorMode: true`, attach an **Apify Schedule** (every 6–12 hours), and the actor emits/alerts **only newly-listed sales** in your scope.

---

### How to use it (step by step)

1. Click **Try for free**.
2. Pick a **Search mode** (e.g. *By state*) and enter your scope (e.g. `TX`).
3. *(Optional)* keep **Fetch full details** on for the full description, schedule, seller, and all photos.
4. Click **Start**, then open the **Dataset** tab to view/export.
5. *(Optional)* set **monitorMode** + a **Schedule** + an alert channel to get pinged on new sales.

#### Quick start

```json
{ "searchMode": "state", "states": ["TX"], "maxItems": 50 }
````

#### Everything near me (radius)

```json
{ "searchMode": "coordinates", "latitude": "32.7767", "longitude": "-96.7970", "radiusMiles": 50, "maxItems": 0 }
```

#### New-sale monitor example

```json
{
  "searchMode": "city",
  "city": "Dallas",
  "cityState": "TX",
  "monitorMode": true,
  "alertOnNewSale": true,
  "slackWebhookUrl": "https://hooks.slack.com/services/…"
}
```

***

### Input

| Field | What it does |
|-------|--------------|
| `searchMode` | `state` · `city` · `zip` · `coordinates` · `keyword` · `all` |
| `states` / `city` + `cityState` / `zipcode` / `latitude` + `longitude` + `radiusMiles` / `keyword` | the scope for the chosen mode |
| `fetchDetails` | add full description, per-day schedule, seller block, terms, and every photo (1 extra request per sale) |
| `maxItems` | hard cap per run (prefilled 50 for a fast first run; 0 = unlimited) |
| `monitorMode`, `alertOnNewSale` | recurring watcher + alerts (new sales only) |
| `webhookUrl`, `slackWebhookUrl`, `emailRecipients` | alert channels |
| `proxyConfiguration`, `requestConcurrency` | proxy + parallelism (datacenter is enough) |

***

### Output

Each estate sale is one dataset record (fields listed above). Export to **JSON, CSV, Excel, HTML, or RSS**, or fetch via the **Apify API**. Dates are ISO-8601 UTC (plus local variants); `pictures` are direct CDN URLs.

Example record (trimmed):

```json
{
  "sale_id": "4940877",
  "sale_url": "https://www.estatesales.net/TX/Houston/77079/4940877",
  "title": "Memorial area estate sale",
  "company": null,
  "phone_numbers": ["8327317191"],
  "address": "12988 Trail Hollow Dr",
  "city": "Houston",
  "state": "TX",
  "zipcode": "77079",
  "start_date": "2026-06-11T14:00:00Z",
  "end_date": "2026-06-13T21:30:00Z",
  "picture_count": 139,
  "description_excerpt": "Beautiful Sofa, loveseat, Maitland smith dining table, vintage piano…",
  "thumbnail": "https://picturescdn.estatesales.net/4940877/1-1/c051c6c5….jpg"
}
```

***

### How much does it cost?

Pay-per-event — you pay for what you pull, no subscription.

| Event | What it covers | Price |
|-------|----------------|-------|
| `lot-scraped` | each sale returned | $0.004 / sale |
| `lot-detail-enriched` | each detail-page fetch (full description + photos) | $0.004 / sale |
| `monitor-run-completed` | each scheduled watch run | $0.05 / run |
| `new-lot-detected` | each newly listed sale found by the monitor | $0.02 / sale |
| `alert-delivered` | each Slack/email/webhook push | $0.005 / alert |

That's **$4 per 1,000 sales** (or $8 with full detail enrichment) — no monthly fee.

***

### Is it legal to scrape EstateSales.net?

The listings are **publicly browsable sale advertisements** — no login is required, and the contact details (company name, business phone) are published by the sellers to attract buyers. Scraping publicly available listings is generally legal, but you are responsible for your use: **review the current EstateSales.net Terms of Service before commercial use or resale of the data**, and handle private-seller phone numbers in line with applicable privacy rules.

***

### FAQ

**What is EstateSales.net?**
EstateSales.net is the largest estate-sale listing site in the US — estate-sale companies and private sellers advertise upcoming sales, auctions, and liquidations there, with photos, dates, and contact info.

**Do I need an account, login, or API key?**
No. The actor reads public listing data directly — no account, cookies, or key required.

**Can I monitor new sales and get alerts?**
Yes. Turn on `monitorMode`, attach an Apify **Schedule**, and add a Slack/webhook/email channel. Each run emits and alerts **only sales new since the last run** for your scope.

**Can I scrape a whole state? The whole country?**
Yes — `searchMode: "state"` with one or more state codes, or `searchMode: "all"` with `maxItems: 0` for every active sale in the US.

**Why is the street address empty on some sales?**
EstateSales.net hides the exact address until shortly before the sale starts (see `address_revealed_at`). City, state, ZIP, and lat/lon are always present; re-run closer to the sale date to capture the street address.

**Does it return photos and the full description?**
Yes — keep `fetchDetails` on (the default) for the complete description, terms, per-day schedule, and every photo URL. Turn it off for a faster listing-only run.

**Can I search by keyword, like "mid century" or "tools"?**
Yes — `searchMode: "keyword"` runs the site's own search across titles and descriptions.

**How do I get sales near a location rather than a whole city?**
Use `searchMode: "coordinates"` with `latitude`, `longitude`, and `radiusMiles` — the site filters by distance server-side.

**How do I export the data?**
JSON, CSV, Excel, HTML, or RSS from the Dataset tab, or via the Apify API.

**Can I integrate with Make, Zapier, n8n, or my backend?**
Yes — use the webhook/Slack channels for alerts, or the Apify API to pipe the dataset anywhere.

***

### You might also like

- 🏚️ Storage-unit & surplus auction scrapers (StorageTreasures, PublicSurplus, GSA)
- 🔨 General online auction & marketplace scrapers
- 📍 Local-listing and lead-gen scrapers

***

### Feedback

Found a missing field or want a new filter? Open an issue on the actor — fast fixes and feature requests welcome.

# Actor input Schema

## `searchMode` (type: `string`):

How to scope the search. EstateSales.net filters server-side, so only matching sales are fetched. 'By state' covers every metro in the state(s); 'All active (US)' pulls the whole national list.

## `states` (type: `array`):

Two-letter state codes, e.g. TX, CA, FL. Used when Search mode = By state. One server query per state.

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

City name, e.g. Dallas or San Antonio. Used when Search mode = By city. Matched exactly (case-insensitive) against the sale's city.

## `cityState` (type: `string`):

Optional state code to disambiguate the city, e.g. TX for Dallas. Recommended — many US city names repeat across states.

## `zipcode` (type: `string`):

Exact 5-digit ZIP when Search mode = By ZIP code. For 'everything near me', use coordinates + radius instead — ZIP matches only sales in that exact ZIP.

## `latitude` (type: `string`):

Decimal latitude of the search center when Search mode = By coordinates + radius, e.g. 32.7767 (Dallas).

## `longitude` (type: `string`):

Decimal longitude of the search center, e.g. -96.7970 (Dallas).

## `radiusMiles` (type: `integer`):

Search radius around the coordinates. 25 covers a metro core; 50-100 covers a whole metro area.

## `keyword` (type: `string`):

Free-text search across sale listings (title/description), e.g. 'mid century', 'tools', 'coins'. Used when Search mode = By keyword.

## `fetchDetails` (type: `boolean`):

Open each sale's page for the full description, all sale dates/times, every photo URL, seller block, and terms. One extra request per sale — the site is fast and open, so this is ON by default.

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

Hard cap on sales scraped this run (cost/safety guard). Defaults to 50 for a fast first run — set to 0 for an unlimited bulk scrape of the whole scope.

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

Recurring watcher: diff against the prior run's seen sales (per scope) and output/alert ONLY newly-listed sales. Pair with an Apify Schedule (e.g. every 6-12 hours).

## `alertOnNewSale` (type: `boolean`):

In monitor mode, deliver an alert for each newly-listed sale via the channels below.

## `webhookUrl` (type: `string`):

POST endpoint for new-sale alert payloads (Make / Zapier / n8n / custom). One JSON body per alert.

## `slackWebhookUrl` (type: `string`):

Slack incoming-webhook URL for formatted new-sale cards.

## `emailRecipients` (type: `array`):

Email addresses for the new-sale digest (sent via apify/send-mail).

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

Proxy settings. Datacenter rotation is enough for this site (no anti-bot).

## `requestConcurrency` (type: `integer`):

Max parallel requests for detail-page fetches. The site is fast; 8 is a good default.

## `diagnose` (type: `boolean`):

Dev only. Dumps the raw API JSON + a detail-page HTML to the key-value store (DEBUG\_API\_JSON / DEBUG\_DETAIL\_HTML), logs the parsed first record + pagination overlap check, then exits. Leave off for normal runs.

## Actor input object example

```json
{
  "searchMode": "state",
  "states": [
    "TX"
  ],
  "radiusMiles": 25,
  "fetchDetails": true,
  "maxItems": 50,
  "monitorMode": false,
  "alertOnNewSale": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "requestConcurrency": 8,
  "diagnose": false
}
```

# Actor output Schema

## `sales` (type: `string`):

The dataset of scraped estate sales (one item per sale).

# 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 = {
    "searchMode": "state",
    "states": [
        "TX"
    ],
    "fetchDetails": true,
    "maxItems": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapersdelight/estatesales-net-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 = {
    "searchMode": "state",
    "states": ["TX"],
    "fetchDetails": True,
    "maxItems": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("scrapersdelight/estatesales-net-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 '{
  "searchMode": "state",
  "states": [
    "TX"
  ],
  "fetchDetails": true,
  "maxItems": 50
}' |
apify call scrapersdelight/estatesales-net-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "EstateSales.net Estate Sale Scraper — State, City, ZIP & Alerts",
        "description": "Scrape EstateSales.net estate sales by state, city, ZIP, geo radius, or keyword — title, company, phone, address, dates, photos & full description. Monitor mode + Slack/email/webhook alerts for new sales in your area. No login or API key. From $4 per 1,000 sales.",
        "version": "0.1",
        "x-build-id": "JHt5faA0fE9kmdsN9"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapersdelight~estatesales-net-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapersdelight-estatesales-net-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/scrapersdelight~estatesales-net-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapersdelight-estatesales-net-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/scrapersdelight~estatesales-net-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapersdelight-estatesales-net-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",
                "properties": {
                    "searchMode": {
                        "title": "Search mode",
                        "enum": [
                            "state",
                            "city",
                            "zip",
                            "coordinates",
                            "keyword",
                            "all"
                        ],
                        "type": "string",
                        "description": "How to scope the search. EstateSales.net filters server-side, so only matching sales are fetched. 'By state' covers every metro in the state(s); 'All active (US)' pulls the whole national list.",
                        "default": "state"
                    },
                    "states": {
                        "title": "States",
                        "type": "array",
                        "description": "Two-letter state codes, e.g. TX, CA, FL. Used when Search mode = By state. One server query per state.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "city": {
                        "title": "City",
                        "type": "string",
                        "description": "City name, e.g. Dallas or San Antonio. Used when Search mode = By city. Matched exactly (case-insensitive) against the sale's city."
                    },
                    "cityState": {
                        "title": "City's state (2-letter)",
                        "type": "string",
                        "description": "Optional state code to disambiguate the city, e.g. TX for Dallas. Recommended — many US city names repeat across states."
                    },
                    "zipcode": {
                        "title": "ZIP code",
                        "type": "string",
                        "description": "Exact 5-digit ZIP when Search mode = By ZIP code. For 'everything near me', use coordinates + radius instead — ZIP matches only sales in that exact ZIP."
                    },
                    "latitude": {
                        "title": "Latitude",
                        "type": "string",
                        "description": "Decimal latitude of the search center when Search mode = By coordinates + radius, e.g. 32.7767 (Dallas)."
                    },
                    "longitude": {
                        "title": "Longitude",
                        "type": "string",
                        "description": "Decimal longitude of the search center, e.g. -96.7970 (Dallas)."
                    },
                    "radiusMiles": {
                        "title": "Radius (miles)",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Search radius around the coordinates. 25 covers a metro core; 50-100 covers a whole metro area.",
                        "default": 25
                    },
                    "keyword": {
                        "title": "Keyword",
                        "type": "string",
                        "description": "Free-text search across sale listings (title/description), e.g. 'mid century', 'tools', 'coins'. Used when Search mode = By keyword."
                    },
                    "fetchDetails": {
                        "title": "Fetch full details",
                        "type": "boolean",
                        "description": "Open each sale's page for the full description, all sale dates/times, every photo URL, seller block, and terms. One extra request per sale — the site is fast and open, so this is ON by default.",
                        "default": true
                    },
                    "maxItems": {
                        "title": "Max sales per run",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Hard cap on sales scraped this run (cost/safety guard). Defaults to 50 for a fast first run — set to 0 for an unlimited bulk scrape of the whole scope.",
                        "default": 50
                    },
                    "monitorMode": {
                        "title": "Monitor mode (new-sale watcher)",
                        "type": "boolean",
                        "description": "Recurring watcher: diff against the prior run's seen sales (per scope) and output/alert ONLY newly-listed sales. Pair with an Apify Schedule (e.g. every 6-12 hours).",
                        "default": false
                    },
                    "alertOnNewSale": {
                        "title": "Alert on new sales",
                        "type": "boolean",
                        "description": "In monitor mode, deliver an alert for each newly-listed sale via the channels below.",
                        "default": true
                    },
                    "webhookUrl": {
                        "title": "Webhook URL",
                        "type": "string",
                        "description": "POST endpoint for new-sale alert payloads (Make / Zapier / n8n / custom). One JSON body per alert."
                    },
                    "slackWebhookUrl": {
                        "title": "Slack webhook URL",
                        "type": "string",
                        "description": "Slack incoming-webhook URL for formatted new-sale cards."
                    },
                    "emailRecipients": {
                        "title": "Email recipients",
                        "type": "array",
                        "description": "Email addresses for the new-sale digest (sent via apify/send-mail).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "proxyConfiguration": {
                        "title": "Proxy",
                        "type": "object",
                        "description": "Proxy settings. Datacenter rotation is enough for this site (no anti-bot).",
                        "default": {
                            "useApifyProxy": true
                        }
                    },
                    "requestConcurrency": {
                        "title": "Request concurrency",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Max parallel requests for detail-page fetches. The site is fast; 8 is a good default.",
                        "default": 8
                    },
                    "diagnose": {
                        "title": "Diagnostic mode (dev)",
                        "type": "boolean",
                        "description": "Dev only. Dumps the raw API JSON + a detail-page HTML to the key-value store (DEBUG_API_JSON / DEBUG_DETAIL_HTML), logs the parsed first record + pagination overlap check, then exits. Leave off for normal runs.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```