# StorageTreasures Scraper & Auction Monitor (`scrapersdelight/storagetreasures-scraper`) Actor

Scrape StorageTreasures storage-unit auctions — current bid, unit size, contents,
photos, facility & location — by state, city, ZIP, or facility. Run it on a schedule
as a new-lot monitor with Slack, email & webhook alerts.

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

## Pricing

from $4.00 / 1,000 per lot returneds

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

## 📦 StorageTreasures Scraper & Storage Auction Monitor

**Scrape live StorageTreasures storage-unit auctions — current bid, close time, unit size, contents, photos, facility, and location — by state, city, ZIP, or facility. Then run it on a schedule as a geo-filtered new-lot monitor that pings Slack, email, or webhook the moment a fresh locker drops in your area, so you bid first.**

The fastest way to turn StorageTreasures.com into a clean dataset or a real-time deal alert. No login, no browser automation, no copy-paste — just structured storage-auction data on demand or on a timer.

---

### What does StorageTreasures Scraper do?

StorageTreasures Scraper extracts **storage-unit auction listings** from [StorageTreasures.com](https://www.storagetreasures.com) and returns them as clean, structured rows you can export to **JSON, CSV, Excel, or push to your own app via API**. Use it to build a storage-auction dataset, comp sold prices, feed a reselling tool, or get alerted to new lockers near you before the competition.

- 🔎 **Search any way the site does** — by state, city, ZIP code, facility, or keyword, or pull every active lot nationwide.
- 💰 **Get the numbers that matter** — current bid, starting bid, minimum next bid, reserve, bid count, and views.
- 📸 **Full lot detail** — unit size, contents description, every photo, category tags, facility name + address, and payment options.
- ⏰ **Time-aware** — exact close time and a live `time_left_seconds` countdown so you know what's ending soon.
- 🔔 **New-lot monitor** — schedule it and get **Slack / email / webhook alerts** for newly listed lockers in your target area.
- 🚀 **Fast & cheap** — pulls the entire ~25,000-lot national feed in minutes for about a dollar, thanks to concurrent paging.

---

### What data does StorageTreasures Scraper extract?

For every storage auction lot:

- 🆔 `auction_id` — unique lot ID
- 🔗 `lot_url` — direct link to the listing
- 🏷️ `title` — e.g. "10 x 10 unit — Midlothian, TX"
- 📐 `size`, `unit_width`, `unit_length`, `unit_volume` — unit dimensions
- 📦 `unit_contents` — what's visible in the locker
- 📝 `unit_additional` — facility terms / extra notes
- 💵 `current_bid`, `initial_bid`, `minimum_bid`, `reserve_price` — all in USD
- 🔨 `total_bids`, `has_bid`, `total_views` — bidding activity
- 🧾 `cleaning_deposit`, `cleanout_time_hours`, `sales_tax`, `payment_options`
- 🏢 `facility_id`, `facility_name`, `address`, `city`, `state`, `zipcode`
- 🗂️ `categories[]` — contents categories (Furniture, Electronics, Boxes, etc.)
- 🖼️ `images[]` — every lot photo
- 📅 `active_date`, `post_date`, `end_date`, `current_date`
- ⏳ `time_left_seconds` — seconds until the auction closes
- 🚦 `status_name`, `status_slug`, `type_name`, `upcoming`, `is_expired`, `soft_close`
- ✨ `is_new` — set in monitor mode for freshly listed lots
- 🕒 `scraped_at` — capture timestamp

---

### Who is it for?

- 🛒 **Storage-unit flippers & resellers** sourcing lockers to win, clear, and resell.
- ♻️ **Thrift, consignment & estate-sale sourcers** hunting cheap inventory by category.
- 📊 **Reseller-tooling & SaaS builders** who need a storage-auction data feed.
- 🧭 **Auction aggregators** combining StorageTreasures with other lien-sale sites.
- 🏢 **"We buy storage units" operators** tracking new lots across many metros at once.

One nearby locker won often pays for the data many times over.

---

### Two ways to use it

1. **Bulk scrape / backfill** — pull every active (or sold) lot for a state, city, ZIP, facility, or keyword into one clean dataset. Great for price comps and market analysis.
2. **New-lot monitor** *(the recurring play)* — set `monitorMode: true`, attach an **Apify Schedule** (hourly for hot metros), and the actor diffs against the previous run and emits/alerts **only newly-listed lots**. Expired lots are pruned so relists re-alert.

---

### How to use StorageTreasures Scraper (step by step)

1. Click **Try for free**.
2. Pick a **Search type** (e.g. *By state*) and enter your scope (e.g. `tx`).
3. Choose **Auction status** — `active` (biddable now) or `sold` (price history).
4. *(Optional)* turn on **Fetch full details** for contents, full address, and all photos.
5. Click **Start**, then open the **Dataset** tab to view/export results.
6. *(Optional)* set **monitorMode** + a **Schedule** + an alert channel to get pinged on new lots.

#### Quick start

```json
{ "searchType": "state", "states": ["tx"], "status": "active" }
````

#### New-lot monitor example

```json
{
  "searchType": "zipcode",
  "zipcodes": ["75201"],
  "monitorMode": true,
  "alertOnNewLot": true,
  "slackWebhookUrl": "https://hooks.slack.com/services/…"
}
```

***

### Input

| Field | What it does |
|-------|--------------|
| `searchType` | `state` · `city` · `zipcode` · `facility` · `keyword` · `all` |
| `states` / `city` / `zipcodes` / `facilityId` / `keyword` | the scope for the chosen search type |
| `status` | `active` (biddable) · `sold` (price history) · `all` |
| `maxBid` | only return lots at/below this current bid (bargain filter) |
| `fetchDetails` | add contents, full address, and all photos (one extra request per lot) |
| `maxLots` | hard cap per run (0 = unlimited) |
| `monitorMode`, `alertOnNewLot`, `alertOnBidChange`, `watchlistAuctionIds` | recurring watcher + alerts |
| `webhookUrl`, `slackWebhookUrl`, `emailRecipients` | alert channels |
| `pageSize`, `requestConcurrency` | tuning — bigger pages + more concurrency = faster scans |
| `proxyConfiguration` | proxy settings (datacenter is enough) |
| `apiKey` | **leave empty** — read from the live site at runtime; set only if extraction ever fails |

***

### Output

Each lot is one dataset record. Sample (trimmed):

```json
{
  "auction_id": "6273422",
  "lot_url": "https://www.storagetreasures.com/auctions/tx/midlothian/6273422",
  "title": "10 x 10 unit — Midlothian, TX",
  "unit_contents": "Dressers, totes, boxes, clothing, Bedding / Clothing, Furniture",
  "type_name": "Lien Unit",
  "status_slug": "active",
  "current_bid": 90,
  "minimum_bid": 100,
  "total_bids": 8,
  "total_views": 316,
  "sales_tax": 6.25,
  "size": "10 x 10",
  "unit_volume": 100,
  "categories": ["Boxes", "Clothing & Shoes", "Household Furniture"],
  "facility_id": "126182",
  "facility_name": "Public Storage 78051",
  "address": "3960 Old Fort Worth Rd",
  "city": "Midlothian",
  "state": "TX",
  "zipcode": "76065",
  "images": [
    "https://media.st-prd-1.aws.storagetreasures.com/data/auctions/images/4/1/7/7/1/7/4/5/large.jpg"
  ],
  "end_date": "2026-05-31 15:00:00",
  "time_left_seconds": 32897,
  "is_expired": false,
  "scraped_at": "2026-05-31T05:51:44.393Z"
}
```

Export the dataset to **JSON, CSV, Excel, HTML, or RSS**, or fetch it through the **Apify API**. Money fields are numbers in USD; dates are the auction's UTC datetime strings; `time_left_seconds` counts down to `end_date`.

***

### How fast is it, and how many results can you get?

The actor pages the full national feed (~25,000 active lots) in **concurrent batches with a large page size**, so a complete nationwide pull finishes in **minutes**, not hours. Narrow scopes with `maxLots` set stop as soon as the cap is hit. There's no hard result limit — pull a single ZIP or the entire country.

> **How filtering works:** StorageTreasures' list endpoint returns the national feed, so the actor downloads it and filters by your scope **locally**. That's why a nationwide scan reads the whole feed — it's fast and cheap (concurrent paging), and `maxLots` caps cost whenever you want a sample.

***

### How much does scraping StorageTreasures cost?

This actor uses **pay-per-event** pricing — you pay for what you pull, with no monthly subscription. Suggested rates:

| Event | What it covers | Suggested price |
|-------|----------------|-----------------|
| `lot-scraped` | each lot returned | ~$0.004 / lot (**$4 per 1,000**) |
| `lot-detail-enriched` | each full-detail fetch | ~$0.003 / lot |
| `monitor-run-completed` | each scheduled watch run | ~$0.05 / run |
| `new-lot-detected` | each newly listed lot found | ~$0.02 / lot |
| `alert-delivered` | each Slack/email/webhook push | ~$0.005 / alert |

A daily watcher over a few metros catching ~20 new lots/day runs a few dollars a month — trivial next to one resale win. *(Final per-event prices are set on the actor's pricing page.)*

***

### Is it legal to scrape StorageTreasures?

Scraping **publicly available** auction listings is generally legal, and these listing pages are public and `robots.txt`-allowed. The data returned is **lot contents/listing data, not personal data**. That said, you are responsible for your own use: **review the current StorageTreasures Terms of Service before commercial use or resale of the data**, and don't use it in ways that violate applicable laws. When in doubt, consult a lawyer.

***

### FAQ

**What is StorageTreasures?**
StorageTreasures is the largest online marketplace for storage-unit (lien) auctions in the US, where self-storage facilities sell off the contents of delinquent units to the highest bidder.

**Do I need a StorageTreasures account or login to use this?**
No. The actor reads public listing data directly — no account, password, or cookies required.

**Can I monitor new storage auctions and get alerts?**
Yes. Turn on `monitorMode`, attach an Apify **Schedule**, and add a `slackWebhookUrl`, `webhookUrl`, or `emailRecipients`. Each run emits and alerts **only the lots that are new since the last run**.

**Can I filter to bargains under a certain price?**
Yes — set `maxBid` and only lots at or below that current bid are returned.

**Can I get the sold price history for comps?**
Set `status: "sold"` to pull sold lots for price comparison and market analysis where available.

**Can I scrape a single facility or a single ZIP code?**
Yes — use `searchType: "facility"` with a `facilityId`, or `searchType: "zipcode"` with one or more `zipcodes`.

**Does it return photos of the units?**
Yes. Every lot includes an `images[]` array; turn on `fetchDetails` to get the full photo set and contents description.

**How do I export the data?**
From the Dataset tab you can download JSON, CSV, Excel, HTML, or RSS, or pull it programmatically via the Apify API.

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

**Will it break if the site changes its API key?**
No. The actor reads the site's current public key from the live page at each run and self-heals if it rotates. You can also set `apiKey` manually as a fallback.

**Is there a free way to try it?**
Yes — run it with a small `maxLots` (e.g. 25) on the free tier to see the data shape before scaling up.

***

### You might also like

- 🏛️ Other lien & surplus auction sites (GovDeals, PublicSurplus, GSA Auctions)
- 🔨 General online auction & marketplace scrapers
- 📍 Local-listing and facility-data scrapers

***

### Feedback

Found a missing field, a site change, or want a new filter? Open an issue on the actor — fast fixes and feature requests welcome. Your feedback directly shapes the roadmap.

# Actor input Schema

## `searchType` (type: `string`):

How to scope the crawl. Maps to StorageTreasures' own search modes. 'all' walks every US state.

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

Two-letter state abbreviations to crawl, e.g. tx, fl, nv. Used when Search type = By state (or By city, to disambiguate).

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

City name when Search type = By city (pair with a state).

## `zipcodes` (type: `array`):

ZIP codes when Search type = By ZIP + radius. Pair with the radius below.

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

Search radius around each ZIP/city. StorageTreasures supports 5-500.

## `facilityId` (type: `string`):

Restrict to a single facility (facility\_id) when Search type = By facility.

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

Free-text keyword when Search type = By keyword (matches lot title/contents).

## `status` (type: `string`):

Filter by status. 'active' = currently biddable; 'sold' enables price-history/comps pulls.

## `maxBid` (type: `integer`):

Only return lots whose current bid is at or below this (bargain filter). Leave empty for no cap.

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

Call the per-lot detail endpoint to add description, full address, lat/lng and all photos. One extra request per lot.

## `maxLots` (type: `integer`):

Hard cap on lots 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 lots (per scope) and output/alert ONLY newly-listed lots. Pair with an Apify Schedule.

## `alertOnNewLot` (type: `boolean`):

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

## `alertOnBidChange` (type: `boolean`):

Also alert when the current bid changes on a watched lot (see watchlist IDs).

## `watchlistAuctionIds` (type: `array`):

Specific auction\_ids to track for bid changes when 'Alert on bid changes' is on.

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

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

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

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

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

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

## `apiKey` (type: `string`):

Leave EMPTY. The actor reads StorageTreasures' current public API key from the live site at runtime. Only set this if automatic extraction ever fails (the key is published in the site's own page JavaScript).

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

Proxy settings. Datacenter rotation is enough; switch to residential only for aggressive full-country bulk pulls.

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

Max parallel requests for both page fetches and detail fetches. Higher = faster full-feed scans; keep modest to respect the site's rate limits.

## `pageSize` (type: `integer`):

How many lots to pull per list request. Larger = fewer round-trips = faster. The actor auto-detects the server's real cap if this is too high.

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

Dev only. Dumps the raw API record shapes to the log + key-value store (DEBUG\_RAW\_LIST / DEBUG\_RAW\_DETAIL) and probes which param filters by state, then exits. Use to fix field mappings; leave off for normal runs.

## Actor input object example

```json
{
  "searchType": "state",
  "states": [
    "tx"
  ],
  "radiusMiles": 50,
  "status": "active",
  "fetchDetails": true,
  "maxLots": 50,
  "monitorMode": false,
  "alertOnNewLot": true,
  "alertOnBidChange": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "requestConcurrency": 5,
  "pageSize": 200,
  "diagnose": false
}
```

# Actor output Schema

## `lots` (type: `string`):

The dataset of scraped auction lots (one item per lot).

# 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 = {
    "states": [
        "tx"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapersdelight/storagetreasures-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 = { "states": ["tx"] }

# Run the Actor and wait for it to finish
run = client.actor("scrapersdelight/storagetreasures-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 '{
  "states": [
    "tx"
  ]
}' |
apify call scrapersdelight/storagetreasures-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "StorageTreasures Scraper & Auction Monitor",
        "description": "Scrape StorageTreasures storage-unit auctions — current bid, unit size, contents,\n  photos, facility & location — by state, city, ZIP, or facility. Run it on a schedule\n  as a new-lot monitor with Slack, email & webhook alerts.",
        "version": "0.1",
        "x-build-id": "nF72JBxGQ25HiPbJU"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapersdelight~storagetreasures-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapersdelight-storagetreasures-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~storagetreasures-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapersdelight-storagetreasures-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~storagetreasures-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapersdelight-storagetreasures-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": {
                    "searchType": {
                        "title": "Search type",
                        "enum": [
                            "state",
                            "city",
                            "zipcode",
                            "facility",
                            "keyword",
                            "all"
                        ],
                        "type": "string",
                        "description": "How to scope the crawl. Maps to StorageTreasures' own search modes. 'all' walks every US state.",
                        "default": "state"
                    },
                    "states": {
                        "title": "States",
                        "type": "array",
                        "description": "Two-letter state abbreviations to crawl, e.g. tx, fl, nv. Used when Search type = By state (or By city, to disambiguate).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "city": {
                        "title": "City",
                        "type": "string",
                        "description": "City name when Search type = By city (pair with a state)."
                    },
                    "zipcodes": {
                        "title": "ZIP codes",
                        "type": "array",
                        "description": "ZIP codes when Search type = By ZIP + radius. Pair with the radius below.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "radiusMiles": {
                        "title": "Radius (miles)",
                        "minimum": 5,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Search radius around each ZIP/city. StorageTreasures supports 5-500.",
                        "default": 50
                    },
                    "facilityId": {
                        "title": "Facility ID",
                        "type": "string",
                        "description": "Restrict to a single facility (facility_id) when Search type = By facility."
                    },
                    "keyword": {
                        "title": "Keyword",
                        "type": "string",
                        "description": "Free-text keyword when Search type = By keyword (matches lot title/contents)."
                    },
                    "status": {
                        "title": "Auction status",
                        "enum": [
                            "active",
                            "sold",
                            "all"
                        ],
                        "type": "string",
                        "description": "Filter by status. 'active' = currently biddable; 'sold' enables price-history/comps pulls.",
                        "default": "active"
                    },
                    "maxBid": {
                        "title": "Max current bid ($)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only return lots whose current bid is at or below this (bargain filter). Leave empty for no cap."
                    },
                    "fetchDetails": {
                        "title": "Fetch full details",
                        "type": "boolean",
                        "description": "Call the per-lot detail endpoint to add description, full address, lat/lng and all photos. One extra request per lot.",
                        "default": true
                    },
                    "maxLots": {
                        "title": "Max lots per run",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Hard cap on lots 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-lot watcher)",
                        "type": "boolean",
                        "description": "Recurring watcher: diff against the prior run's seen lots (per scope) and output/alert ONLY newly-listed lots. Pair with an Apify Schedule.",
                        "default": false
                    },
                    "alertOnNewLot": {
                        "title": "Alert on new lots",
                        "type": "boolean",
                        "description": "In monitor mode, deliver an alert for each newly-listed lot via the channels below.",
                        "default": true
                    },
                    "alertOnBidChange": {
                        "title": "Alert on bid changes (watchlist)",
                        "type": "boolean",
                        "description": "Also alert when the current bid changes on a watched lot (see watchlist IDs).",
                        "default": false
                    },
                    "watchlistAuctionIds": {
                        "title": "Watchlist auction IDs",
                        "type": "array",
                        "description": "Specific auction_ids to track for bid changes when 'Alert on bid changes' is on.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "webhookUrl": {
                        "title": "Webhook URL",
                        "type": "string",
                        "description": "POST endpoint for new-lot 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-lot cards."
                    },
                    "emailRecipients": {
                        "title": "Email recipients",
                        "type": "array",
                        "description": "Email addresses for the new-lot digest (sent via apify/send-mail).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "apiKey": {
                        "title": "API key (optional)",
                        "type": "string",
                        "description": "Leave EMPTY. The actor reads StorageTreasures' current public API key from the live site at runtime. Only set this if automatic extraction ever fails (the key is published in the site's own page JavaScript)."
                    },
                    "proxyConfiguration": {
                        "title": "Proxy",
                        "type": "object",
                        "description": "Proxy settings. Datacenter rotation is enough; switch to residential only for aggressive full-country bulk pulls.",
                        "default": {
                            "useApifyProxy": true
                        }
                    },
                    "requestConcurrency": {
                        "title": "Request concurrency",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Max parallel requests for both page fetches and detail fetches. Higher = faster full-feed scans; keep modest to respect the site's rate limits.",
                        "default": 5
                    },
                    "pageSize": {
                        "title": "Page size (records per request)",
                        "minimum": 30,
                        "maximum": 500,
                        "type": "integer",
                        "description": "How many lots to pull per list request. Larger = fewer round-trips = faster. The actor auto-detects the server's real cap if this is too high.",
                        "default": 200
                    },
                    "diagnose": {
                        "title": "Diagnostic mode (dev)",
                        "type": "boolean",
                        "description": "Dev only. Dumps the raw API record shapes to the log + key-value store (DEBUG_RAW_LIST / DEBUG_RAW_DETAIL) and probes which param filters by state, then exits. Use to fix field mappings; 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
