# Biddit Belgium Property Auctions Scraper (`automation-lab/biddit-belgium-property-auctions-scraper`) Actor

🏠 Extract public Biddit auction lots with prices, bid windows, multilingual property details, photos, documents, visits, and source links.

- **URL**: https://apify.com/automation-lab/biddit-belgium-property-auctions-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Real estate
- **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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## Biddit Belgium Property Auctions Scraper

Extract Belgian public property auctions from Biddit into structured JSON, CSV, Excel, XML, or any other Apify dataset format.

Get current prices, bid windows, multilingual property descriptions, addresses, photos, visits, documents, terms, and notary-linked references without manually opening every lot.

Use the Actor for scheduled inventory monitoring, investment screening, valuation research, or exact-lot due diligence.

### What does Biddit Belgium Property Auctions Scraper do?

Biddit Belgium Property Auctions Scraper reads the public auction inventory on [Biddit](https://www.biddit.be/) and saves one clean dataset item per auction lot.

It supports three practical workflows:

- 🔎 scrape the broad public Biddit auction feed
- 🎯 reuse a Biddit search or filter URL
- 🔢 enrich exact Biddit reference codes

The Actor uses Biddit's anonymous structured data endpoints.

No Biddit login is required for public lots.

Bidding, favorites, and account actions are not performed.

### Why use this Biddit scraper?

Biddit pages are designed for people browsing one property at a time.

Research teams often need the same fields across many properties.

This Actor makes that workflow repeatable.

- ⚡ collect multiple lots in one run
- 💶 compare starting, current, estimated, and selling prices
- 🗓️ track bidding start and end timestamps
- 🌍 retain French, Dutch, German, and English text when available
- 🏠 capture rooms, areas, features, utilities, and planning details
- 📎 preserve public attachments and terms links
- 🔁 schedule runs for fresh auction inventory

### Who is it for?

#### Property investors

Build a daily feed of Belgian auction opportunities and shortlist lots by location, status, property type, or price.

#### Auction and foreclosure analysts

Monitor bid windows, current prices, and sold outcomes in a consistent schema.

#### Brokers and acquisition teams

Find inventory outside conventional listing portals and enrich exact references before outreach or review.

#### Valuation teams

Combine property attributes, areas, land income, asking prices, and auction outcomes with internal models.

#### Deal-sourcing services

Power alerts, dashboards, and customer-facing feeds with scheduled Apify runs.

### What Biddit data can you extract?

| Field group | Example data |
|---|---|
| Identifiers | reference code, lot ID, sale ID, organisation ID |
| Sale | handling method, status, withdrawn flag, has bids |
| Prices | starting, current, estimated, selling price |
| Timing | first publication, bidding start, bidding end, bid pace |
| Property | type, subtype, title, description |
| Address | street, number, postal code, municipality, country |
| Location | latitude and longitude |
| Areas | living, terrain, business, garage surfaces |
| Rooms | bedrooms, bathrooms, floors, parking and other room facts |
| Features | garden, terrace, elevator, pool, access and security facts |
| Media | ordered pictures, virtual visit, video link |
| Documents | attachments, document types, terms and conditions |
| Compliance | utilities, energy, environment, urbanism, heritage |
| Contacts | public property contact and notary organisation references |
| Provenance | source URL and scrape timestamp |

Fields are included when Biddit publishes them for the selected lot.

Missing upstream values are omitted rather than invented.

### How to scrape Biddit property auctions

1. Open the Actor input page.
2. Keep the prefilled broad Biddit search URL or paste your own Biddit search URL.
3. Set the maximum number of auction lots.
4. Leave **Include full property details** enabled for descriptions, photos, visits, and documents.
5. Choose French, Dutch, German, or English for normalized text.
6. Optionally add sale-status or handling-method filters.
7. Click **Start**.
8. Export the dataset or connect it to another service.

A small first run usually finishes quickly.

### Input options

#### `searchUrl`

A public `biddit.be` search or API URL.

Leave it empty to use the broad public landing feed.

Compatible URL query parameters are forwarded to the structured search endpoint.

#### `referenceCodes`

A list of exact lot references such as `297251`.

When supplied, the Actor skips search and retrieves those lots directly.

This mode is useful for recurring due diligence or a watchlist.

#### `maxItems`

The maximum number of unique lots saved.

The default is 10 for an inexpensive first run.

#### `includeDetails`

When true, the Actor retrieves the full detail record for every accepted search result.

Disable it for a faster inventory scan with fewer fields.

Exact-reference mode always retrieves details.

#### `language`

Controls normalized `title`, `description`, and the source link language.

Available values are `fr`, `nl`, `de`, and `en`.

Translation maps remain in the output whenever Biddit provides them.

#### `statuses`

Optional exact Biddit sale statuses, for example `CURRENT`.

Matching is case-insensitive.

#### `handlingMethods`

Optional exact sale methods, for example `ONLINE_PUBLIC_SALE`.

Matching is case-insensitive.

#### `pageSize`

Controls records requested from Biddit per search page.

The normal default is efficient and conservative.

### Example input: current online auctions

```json
{
  "searchUrl": "https://www.biddit.be/fr/search",
  "maxItems": 25,
  "includeDetails": true,
  "language": "fr",
  "statuses": ["CURRENT"],
  "handlingMethods": ["ONLINE_PUBLIC_SALE"]
}
````

### Example input: exact lot due diligence

```json
{
  "referenceCodes": ["297251"],
  "maxItems": 1,
  "includeDetails": true,
  "language": "nl"
}
```

### Example output

```json
{
  "referenceCode": "297251",
  "lotId": "l_16f017b36120400b9ba79bd7931689a6",
  "handlingMethod": "ONLINE_PUBLIC_SALE",
  "status": "CURRENT",
  "title": "Une maison de rapport avec 2 commerces et 6 appartements",
  "propertyType": "HOUSE",
  "propertySubtype": "HOUSE_MIXED_USED_BUILDING",
  "currentPrice": 660000,
  "startingPrice": 600000,
  "biddingStart": "2026-07-06T08:00:00Z",
  "biddingEnd": "2026-07-14T08:00:00Z",
  "bedrooms": 8,
  "terrainSurface": 140,
  "latitude": 50.8663543,
  "longitude": 4.2953606,
  "sourceUrl": "https://www.biddit.be/fr/catalog/detail/297251"
}
```

The actual enriched record can also contain nested translation maps, photos, attachments, visits, rooms, features, utilities, environment, urbanism, and terms.

### How much does it cost to scrape Biddit property auctions?

This Actor uses pay-per-event pricing.

A small start fee covers run initialization.

Each auction lot saved creates one `item` charge.

The current BRONZE reference price is $0.00010851 per lot, with tier discounts down to $0.000030383 on eligible plans.

You can always see the final estimate in Apify Console before starting a run.

Compute and dataset storage are handled by the Apify platform according to your plan.

### Monitoring current prices and bidding windows

Create an Apify schedule that runs daily or several times per day.

Use a consistent search URL and retain `referenceCode` as the stable lot key.

Compare these fields between runs:

- `currentPrice`
- `startingPrice`
- `sellingPrice`
- `status`
- `hasBids`
- `biddingEnd`
- `withdrawn`

Send changed rows to a webhook, database, spreadsheet, or automation platform.

### Working with multilingual Belgian listings

Belgian lots commonly publish French and Dutch text.

Some fields may also include German or English.

The Actor provides both:

- a normalized `title` and `description` in your preferred language
- `titleTranslations` and `descriptionTranslations` maps

If the requested language is unavailable, it falls back to another published language rather than returning invented translation text.

### Export and integrations

Apify datasets export to JSON, CSV, Excel, XML, and RSS.

Common workflows include:

- 📊 send new lots to Google Sheets for analyst review
- 🗄️ load auction records into PostgreSQL, BigQuery, or Snowflake
- 🔔 trigger Slack or email alerts when current prices change
- 🧮 enrich valuation pipelines with areas, rooms, and coordinates
- 🗺️ map auction opportunities in GIS or BI tools
- 🔗 call a webhook after each scheduled run

Use Zapier, Make, n8n, or the Apify API to automate the handoff.

### API usage with JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/biddit-belgium-property-auctions-scraper').call({
  searchUrl: 'https://www.biddit.be/fr/search',
  maxItems: 25,
  includeDetails: true,
  language: 'fr'
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Python API example

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/biddit-belgium-property-auctions-scraper').call(run_input={
    'searchUrl': 'https://www.biddit.be/nl/search',
    'maxItems': 25,
    'includeDetails': True,
    'language': 'nl',
})

for item in client.dataset(run['defaultDatasetId']).iterate_items():
    print(item)
```

### cURL API example

```bash
curl -X POST \
  'https://api.apify.com/v2/acts/automation-lab~biddit-belgium-property-auctions-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"referenceCodes":["297251"],"maxItems":1,"language":"fr"}'
```

Fetch results through the run's default dataset ID.

### Use with Apify MCP

Connect the Actor to Claude Code, Claude Desktop, Cursor, or VS Code through Apify MCP.

#### Claude Code setup

```bash
claude mcp add --transport http apify https://mcp.apify.com/?tools=automation-lab/biddit-belgium-property-auctions-scraper
```

#### Claude Desktop setup

Add this configuration to Claude Desktop's MCP configuration file.

#### Cursor setup

Add the same `mcpServers` block in Cursor Settings under MCP.

#### VS Code setup

Add the Apify server URL through the VS Code MCP server configuration and enable the Actor tool.

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com/?tools=automation-lab/biddit-belgium-property-auctions-scraper"
    }
  }
}
```

Example prompts:

- “Find current Biddit property auctions and summarize prices by municipality.”
- “Retrieve full details for Biddit reference 297251.”
- “Compare current and starting prices for the first 20 Belgian auction lots.”
- “List lots whose bidding ends soon and include their source URLs.”

### Data quality and reliability

The Actor deduplicates lots by reference code.

Requests use timeouts and exponential retries.

Search mode saves the useful search record if optional detail enrichment fails.

Exact-reference mode fails clearly when a requested public lot cannot be retrieved.

Nested source fields are retained so advanced users can inspect the published facts.

No values are inferred when Biddit does not publish them.

### Performance tips

Disable `includeDetails` for rapid inventory scans.

Enable it when you need descriptions, all photos, visits, documents, or planning facts.

Keep scheduled runs focused with a Biddit filter URL or status filter.

Use exact reference codes for watchlists rather than repeatedly scanning the whole feed.

Start with 10 to 25 lots when testing an integration.

### Limitations

The Actor extracts public Biddit data only.

It does not place bids, sign in, manage favorites, or access user-console data.

Available lots and fields depend on what Biddit publishes at run time.

Some properties omit energy, room, price, attachment, or translation fields.

A Biddit search page may use client-side state that is not represented as a reusable URL query parameter; in that case use Actor filters or exact references.

Website and API changes can require an Actor update.

### Legality of scraping Biddit

Public web data can often be collected for legitimate research and business purposes, but laws and contractual obligations vary.

You are responsible for your use case.

Review Biddit's terms, applicable database rights, privacy rules, and local regulations.

Avoid republishing personal contact details without a lawful basis.

Do not use the Actor to interfere with auctions or attempt authenticated actions.

This documentation is not legal advice.

### Troubleshooting

#### The dataset is empty

Check whether your `statuses` or `handlingMethods` values match current Biddit values.

Try the broad search with filters removed and a small `maxItems`.

Also verify that the supplied URL uses `biddit.be`.

#### A known reference fails

The lot may have been removed from public access or the reference may be mistyped.

Open the reference on Biddit and retry with only that code.

#### Some detailed fields are missing

Biddit does not publish every property fact for every lot.

Missing fields are omitted; they are not scraper errors by themselves.

#### A scheduled run shows fewer current lots

Auction inventory naturally changes as bid windows close, lots sell, or sales are withdrawn.

Compare `status`, `withdrawn`, and bidding timestamps across runs.

### FAQ

#### Does the Actor need a Biddit account?

No. It reads anonymous public search and lot-detail data.

#### Can it monitor live prices?

Yes. Schedule repeated runs and compare `currentPrice` using `referenceCode` as the key.

#### Does it translate descriptions?

No machine translation is added. It returns Biddit's available language versions and chooses a preferred normalized value.

#### Can I scrape one specific lot?

Yes. Add the reference to `referenceCodes`.

#### Can I get documents and terms?

Yes, when Biddit publishes public attachment URLs and `includeDetails` is enabled.

#### Does it return multiple properties in one lot?

Yes. Normalized top-level fields describe the primary property, while `properties` retains all detailed property records supplied for the lot.

### Related Automation Labs actors

Expand a European or auction-data workflow with:

- [France Judicial Property Auctions Scraper](https://apify.com/automation-lab/france-judicial-property-auctions-scraper)
- [Subastas BOE Auctions Scraper](https://apify.com/automation-lab/subastas-boe-auctions-scraper)
- [Auction.com Foreclosure Listings Scraper](https://apify.com/automation-lab/auction-com-foreclosure-listings-scraper)
- [Drouot Auction Lots Scraper](https://apify.com/automation-lab/drouot-auction-lots-scraper)

Choose Biddit Belgium Property Auctions Scraper when you specifically need Belgian notary-linked public property auction inventory.

### Support

If a public Biddit lot is missing or an output field changes, open an issue from the Actor page.

Include the run ID, sanitized input, expected reference code, and the field you expected.

That information makes source changes faster to reproduce and fix.

# Actor input Schema

## `searchUrl` (type: `string`):

Optional Biddit search/filter URL. Leave empty to scrape the broad public auction feed.

## `referenceCodes` (type: `array`):

Optional Biddit references to retrieve directly, for example 297251. When set, search mode is skipped.

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

Maximum number of auction lots saved to the dataset.

## `includeDetails` (type: `boolean`):

Enrich every lot with descriptions, photos, rooms, features, visits, documents, and terms.

## `language` (type: `string`):

Language used for normalized title and description. Translation maps are always retained when available.

## `statuses` (type: `array`):

Optional exact Biddit status filters, such as CURRENT. Matching is case-insensitive.

## `handlingMethods` (type: `array`):

Optional sale method filters, such as ONLINE\_PUBLIC\_SALE. Matching is case-insensitive.

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

Biddit records requested per page. Lower this only for cautious monitoring runs.

## Actor input object example

```json
{
  "searchUrl": "https://www.biddit.be/fr/search",
  "referenceCodes": [],
  "maxItems": 10,
  "includeDetails": true,
  "language": "fr",
  "statuses": [],
  "handlingMethods": [],
  "pageSize": 20
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "searchUrl": "https://www.biddit.be/fr/search",
    "referenceCodes": [],
    "maxItems": 10,
    "includeDetails": true,
    "language": "fr",
    "statuses": [],
    "handlingMethods": [],
    "pageSize": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/biddit-belgium-property-auctions-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 = {
    "searchUrl": "https://www.biddit.be/fr/search",
    "referenceCodes": [],
    "maxItems": 10,
    "includeDetails": True,
    "language": "fr",
    "statuses": [],
    "handlingMethods": [],
    "pageSize": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/biddit-belgium-property-auctions-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 '{
  "searchUrl": "https://www.biddit.be/fr/search",
  "referenceCodes": [],
  "maxItems": 10,
  "includeDetails": true,
  "language": "fr",
  "statuses": [],
  "handlingMethods": [],
  "pageSize": 20
}' |
apify call automation-lab/biddit-belgium-property-auctions-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Biddit Belgium Property Auctions Scraper",
        "description": "🏠 Extract public Biddit auction lots with prices, bid windows, multilingual property details, photos, documents, visits, and source links.",
        "version": "0.1",
        "x-build-id": "prrje2Qc6d7D7BisC"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~biddit-belgium-property-auctions-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-biddit-belgium-property-auctions-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/automation-lab~biddit-belgium-property-auctions-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-biddit-belgium-property-auctions-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/automation-lab~biddit-belgium-property-auctions-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-biddit-belgium-property-auctions-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": {
                    "searchUrl": {
                        "title": "🔎 Biddit search URL",
                        "type": "string",
                        "description": "Optional Biddit search/filter URL. Leave empty to scrape the broad public auction feed."
                    },
                    "referenceCodes": {
                        "title": "Exact lot reference codes",
                        "type": "array",
                        "description": "Optional Biddit references to retrieve directly, for example 297251. When set, search mode is skipped.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Maximum auction lots",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of auction lots saved to the dataset.",
                        "default": 10
                    },
                    "includeDetails": {
                        "title": "Include full property details",
                        "type": "boolean",
                        "description": "Enrich every lot with descriptions, photos, rooms, features, visits, documents, and terms.",
                        "default": true
                    },
                    "language": {
                        "title": "Preferred language",
                        "enum": [
                            "fr",
                            "nl",
                            "de",
                            "en"
                        ],
                        "type": "string",
                        "description": "Language used for normalized title and description. Translation maps are always retained when available.",
                        "default": "fr"
                    },
                    "statuses": {
                        "title": "Sale statuses",
                        "type": "array",
                        "description": "Optional exact Biddit status filters, such as CURRENT. Matching is case-insensitive.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "handlingMethods": {
                        "title": "Handling methods",
                        "type": "array",
                        "description": "Optional sale method filters, such as ONLINE_PUBLIC_SALE. Matching is case-insensitive.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "pageSize": {
                        "title": "Search page size",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Biddit records requested per page. Lower this only for cautious monitoring runs.",
                        "default": 50
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
