# France Judicial Property Auctions Scraper (`automation-lab/france-judicial-property-auctions-scraper`) Actor

Extract upcoming and historical French judicial property auctions from Licitor with prices, court dates, property details, visits, addresses, and lawyer contacts.

- **URL**: https://apify.com/automation-lab/france-judicial-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

## France Judicial Property Auctions Scraper

Collect structured French judicial real-estate auction data from **Licitor**.
Turn regional searches, court calendars, and individual announcements into clean records ready for Excel, Google Sheets, databases, maps, alerts, or investment models.

The Actor covers upcoming sales and historical adjudication pages.
It extracts the information acquisition teams normally copy by hand: tribunal, sale date, property description, floor area, occupancy, opening price, address, visits, bidding conditions, lawyer details, coordinates, references, and source URL.

### What does France Judicial Property Auctions Scraper do?

The scraper visits public pages on `licitor.com`, discovers every auction announcement across pagination, opens each detail page, and saves one normalized record per announcement ID.

It can:

- 🏠 find upcoming judicial property auctions across France;
- ⚖️ target a specific Tribunal Judiciaire calendar;
- 💶 collect opening prices and bidding or deposit conditions;
- 📍 extract addresses and map coordinates;
- 📅 capture auction dates and scheduled property visits;
- 👩‍⚖️ collect the pursuing lawyer's public contact details;
- 📈 retrieve historical adjudication information when Licitor publishes it;
- 🔗 process individual announcement URLs for focused due diligence.

### Who is it for?

#### Property investors

Build a repeatable pipeline of court-auction opportunities instead of reviewing many regional pages manually.
Filter by location, price, occupancy, area, or auction date after export.

#### Acquisition teams and brokers

Monitor target tribunals, enrich internal deal records, and route suitable properties to analysts.
The canonical source URL keeps every lead auditable.

#### Auction services and lawyers

Track auction calendars, visit windows, court references, and public lawyer contacts in a consistent format.

#### Market-data vendors

Create structured French judicial-auction datasets for dashboards, comparable-sale research, alerts, and downstream APIs.

### Why use this Actor?

Licitor pages are designed for human browsing.
This Actor converts their server-rendered pages into typed records at scale.

Benefits include:

- no login or account required for public announcements;
- deterministic HTTP extraction without a browser;
- pagination and detail-page traversal;
- deduplication by Licitor announcement ID;
- normalized ISO dates, euro values, decimal areas, and coordinates;
- original descriptions and bidding text retained for context;
- direct exports in JSON, CSV, Excel, XML, and RSS formats;
- integrations with Apify API, webhooks, schedules, and MCP.

### What data can you extract?

| Field | Description |
|---|---|
| `announcementId` | Unique Licitor announcement number |
| `publishedAt` | Announcement publication timestamp |
| `court` | Tribunal Judiciaire handling the sale |
| `department` | French department shown by Licitor |
| `auctionType` | Judicial sale procedure or auction type |
| `auctionAt` | Normalized auction date and time |
| `propertyTitle` | Main property or lot title |
| `description` | Combined description of all advertised lots |
| `lots` | Structured title and description for each sub-lot |
| `areaM2` | Parsed floor area in square metres |
| `roomCount` | Parsed number of principal rooms |
| `occupancy` | Free, occupied, rented, or vacant status when stated |
| `openingPriceEur` | Opening price as a number in euros |
| `biddingTerms` | Deposit, price-reduction, and lawyer bidding conditions |
| `city` | Municipality |
| `streetAddress` | Public street address |
| `fullAddress` | Combined address, city, and department |
| `latitude`, `longitude` | Coordinates from the Licitor map link |
| `visitTimes` | On-site viewing schedule |
| `lawyerName` | Pursuing lawyer or firm |
| `lawyerAddress` | Public office address |
| `lawyerPhone` | Public telephone number |
| `reference` | File or sale reference |
| `resultText` | Adjudication text when present |
| `canonicalUrl` | Canonical Licitor announcement URL |
| `scrapedAt` | Extraction timestamp |

### How to scrape upcoming French judicial property auctions

1. Open the Actor input page.
2. Leave **Start URLs** empty.
3. Select one or more French coverage regions.
4. Choose **Upcoming auctions**.
5. Set a practical maximum number of records.
6. Click **Start**.
7. Export the resulting dataset in your preferred format.

A small prefilled run targets Paris and Île-de-France and returns up to ten records.

### How to scrape one court or announcement

Paste any supported Licitor URL into **Start URLs**.
The URL can be:

- a regional upcoming-auctions search;
- a regional historical-results search;
- a Tribunal Judiciaire hearing calendar;
- a paginated search page;
- an individual `/annonce/...html` detail page.

When a detail URL is supplied, the Actor extracts it directly.
When a listing URL is supplied, the Actor follows its announcement links and pagination.

### Input

```json
{
  "regions": ["paris-et-ile-de-france"],
  "scope": "upcoming",
  "dateFrom": "2026-08-01",
  "dateTo": "2026-12-31",
  "maxItems": 100
}
````

#### Input options

- `startUrls` — optional Licitor listing, calendar, or announcement URLs.
- `regions` — geographic zones used when `startUrls` is empty.
- `scope` — `upcoming`, `historical`, or `all`.
- `dateFrom` — optional inclusive auction date in `YYYY-MM-DD` format.
- `dateTo` — optional inclusive auction date in `YYYY-MM-DD` format.
- `maxItems` — maximum unique records, from 1 to 10,000.

Date filters apply to the auction date, not the publication date.
A record without a parseable auction date is excluded when a date filter is active.

### Output example

```json
{
  "announcementId": "109150",
  "publishedAt": "2026-07-02T22:00:00.000Z",
  "court": "Tribunal Judiciaire de Versailles",
  "department": "Yvelines",
  "auctionType": "Vente aux enchères publiques sur liquidation judiciaire en un seul lot",
  "auctionAt": "2026-09-02T09:30:00.000Z",
  "propertyTitle": "Une maison d'habitation",
  "areaM2": 82.13,
  "roomCount": 6,
  "occupancy": "Libre",
  "openingPriceEur": 200000,
  "city": "Houilles",
  "streetAddress": "15 bis, rue de l'Argonne",
  "latitude": 48.9267159,
  "longitude": 2.1827631,
  "lawyerName": "Maître Élisa Gueilhers, Avocat",
  "canonicalUrl": "https://www.licitor.com/annonce/.../109150.html"
}
```

Optional fields are returned as `null` when Licitor does not publish them.
This gives downstream systems a stable shape without inventing values.

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

The Actor uses pay-per-event pricing:

- a small one-time **Start** charge per run;
- one **Item** charge for each auction record saved;
- automatic volume discounts by Apify pricing tier.

You can control the final cost with `maxItems`.
HTTP extraction keeps compute use low because no browser is launched.
The current Start price is **$0.005**. The per-record price is tiered: FREE **$0.000087829**, BRONZE **$0.000076373**, SILVER **$0.000059571**, GOLD **$0.000045824**, PLATINUM **$0.000030549**, and DIAMOND **$0.000021384**. The live pricing tab remains authoritative.

### Scheduling an auction monitor

Use an Apify schedule to run the Actor daily or weekly.
For a practical monitor:

1. choose one or more target regions;
2. set `scope` to `upcoming`;
3. keep a rolling `dateFrom` in your integration if required;
4. compare `announcementId` values against your own database;
5. send unseen records to email, Slack, a CRM, or a webhook.

Licitor may update an existing announcement.
If change detection matters, store selected fields and compare them between runs.

### Integration patterns

#### Google Sheets opportunity tracker

Run the Actor on a schedule and send dataset items to Google Sheets.
Analysts can filter by `openingPriceEur`, `department`, `areaM2`, and `auctionAt`.

#### CRM or acquisition pipeline

Create a deal when a record matches your price and region rules.
Use `announcementId` as the external ID and `canonicalUrl` as the source link.

#### Geographic analysis

Load `latitude` and `longitude` into a GIS tool or BI map.
Combine the records with neighbourhood, transit, risk, or market-price datasets.

#### Alerting workflow

Attach a webhook to successful runs.
A serverless function can query the dataset and notify teams about new auctions or approaching visit dates.

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/france-judicial-property-auctions-scraper').call({
  regions: ['paris-et-ile-de-france'],
  scope: 'upcoming',
  maxItems: 100,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("automation-lab/france-judicial-property-auctions-scraper").call(
    run_input={
        "regions": ["sud-est-mediterrannee"],
        "scope": "all",
        "maxItems": 250,
    }
)
items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)
```

### API usage with cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~france-judicial-property-auctions-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"scope":"historical","maxItems":100}'
```

Fetch records from the default dataset URL returned by the run API.
Never embed a permanent Apify token in client-side code.

### Use with Apify MCP

Connect AI assistants to this Actor through the actor-scoped Apify MCP endpoint:

`https://mcp.apify.com?tools=automation-lab/france-judicial-property-auctions-scraper`

#### Claude Code

Register the remote server from your terminal. Keep the token in the `APIFY_TOKEN` environment variable rather than writing it into a project file.

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/france-judicial-property-auctions-scraper" \
  --header "Authorization: Bearer $APIFY_TOKEN"
```

#### Claude Desktop

Add this server to your Claude Desktop MCP configuration. Replace `YOUR_APIFY_TOKEN` locally and do not commit the resulting file.

```json
{
  "mcpServers": {
    "apify": {
      "type": "http",
      "url": "https://mcp.apify.com?tools=automation-lab/france-judicial-property-auctions-scraper",
      "headers": {
        "Authorization": "Bearer YOUR_APIFY_TOKEN"
      }
    }
  }
}
```

#### Cursor or VS Code

Use the same remote HTTP server in Cursor's `.cursor/mcp.json` or VS Code's MCP configuration:

```json
{
  "servers": {
    "apify": {
      "type": "http",
      "url": "https://mcp.apify.com?tools=automation-lab/france-judicial-property-auctions-scraper",
      "headers": {
        "Authorization": "Bearer ${input:apify-token}"
      }
    }
  },
  "inputs": [
    {
      "id": "apify-token",
      "type": "promptString",
      "description": "Apify API token",
      "password": true
    }
  ]
}
```

Try actor-specific prompts such as:

- “Find upcoming judicial property auctions near Paris below €150,000.”
- “Extract this Versailles court calendar and summarize visit dates.”
- “Collect historical results and group them by department.”

### Data quality and normalization

The Actor preserves source text while also producing normalized values.
French decimal commas become JavaScript numbers, euro prices lose display separators, and date/time values become ISO timestamps.

Property descriptions vary because legal announcements vary.
Area, room count, occupancy, contacts, visits, and result text are therefore optional.
Always review the canonical announcement before a legal or financial decision.

### Reliability

Licitor currently serves useful HTML without client-side rendering or login.
The Actor uses conservative sequential requests, a French language header, bounded retries, and 30-second request timeouts.

Failed pages are logged and skipped so a single unavailable announcement does not destroy a larger batch.
If no records can be saved, the run fails clearly rather than returning a misleading empty success.

### Tips for better results

- Start with 10–50 records when testing a new workflow.
- Use direct court URLs for precise hearing monitoring.
- Use `historical` only when adjudication research is required.
- Avoid an extremely narrow date range until you know a sale falls inside it.
- Deduplicate downstream with `announcementId`.
- Retain `canonicalUrl` for analyst verification.
- Schedule broad crawls outside your team's peak processing hours.

### Legality and responsible use

The Actor accesses publicly visible Licitor pages without authentication.
You are responsible for complying with Licitor's terms, applicable database rights, privacy law, and rules governing your downstream use.

Public contact details should be used only for legitimate professional purposes.
Do not use the data for harassment, unsolicited bulk messaging, discriminatory profiling, or automated legal conclusions.
Auction announcements may change or be withdrawn; verify important facts with the court, pursuing lawyer, and source page.

### FAQ — frequently asked questions

#### Does the scraper require a Licitor account?

No. It extracts the public auction listings and announcement details available without login.

#### Can it scrape one property announcement?

Yes. Add the announcement URL to `startUrls` and set `maxItems` to 1.

#### Does it return auction outcomes?

It collects historical pages and saves adjudication text when that information is present in the detail HTML.
Not every announcement contains a published outcome.

#### Why are some fields null?

Legal notices differ in structure and completeness.
A null value means the field was not stated or could not be reliably normalized; it does not mean zero or “none.”

#### Why did my run find no records?

Check that the URL is on `licitor.com`, widen the auction date range, and confirm the selected region currently has listings.
The run log identifies HTTP failures or a no-record condition.

#### Can I use the output in Excel?

Yes. Open the dataset, choose **Export**, and select Excel or CSV.
Nested `lots` are easiest to consume in JSON; the top-level description is convenient for tabular exports.

#### Are map coordinates guaranteed exact?

No. They are copied from Licitor's map link, which itself warns that accuracy is not guaranteed.
Use them for screening, then validate the address.

### Related scrapers

Combine this Actor with other automation-lab Store actors for a broader property workflow:

- [SeLoger Property Listings Scraper](https://apify.com/automation-lab/seloger-property-listings-scraper) for ordinary French sale and rental listings;
- [France Property Risk Scraper](https://apify.com/automation-lab/france-property-risk-scraper) when available for location risk enrichment;
- other [automation-lab actors](https://apify.com/automation-lab) for geocoding, enrichment, and monitoring.

Judicial auctions and ordinary property listings are different workflows.
Choose this Actor when the court sale, opening price, visits, and bidding conditions are the key data.

### Support

If Licitor changes its page structure or a supported URL returns incomplete data, open an issue from the Actor page.
Include the run URL, input, and one affected announcement URL so the problem can be reproduced quickly.

# Actor input Schema

## `startUrls` (type: `array`):

Optional Licitor region, court calendar, results, or individual announcement URLs. Leave empty to crawl selected regions.

## `regions` (type: `array`):

Licitor coverage zones to crawl when no start URLs are supplied.

## `scope` (type: `string`):

Collect upcoming sales, historical adjudication results, or both.

## `dateFrom` (type: `string`):

Optional inclusive start date in YYYY-MM-DD format.

## `dateTo` (type: `string`):

Optional inclusive end date in YYYY-MM-DD format.

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

Stop after saving this many unique announcement IDs.

## Actor input object example

```json
{
  "regions": [
    "paris-et-ile-de-france"
  ],
  "scope": "upcoming",
  "maxItems": 10
}
```

# 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 = {
    "regions": [
        "paris-et-ile-de-france"
    ],
    "scope": "upcoming",
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/france-judicial-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 = {
    "regions": ["paris-et-ile-de-france"],
    "scope": "upcoming",
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/france-judicial-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 '{
  "regions": [
    "paris-et-ile-de-france"
  ],
  "scope": "upcoming",
  "maxItems": 10
}' |
apify call automation-lab/france-judicial-property-auctions-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "France Judicial Property Auctions Scraper",
        "description": "Extract upcoming and historical French judicial property auctions from Licitor with prices, court dates, property details, visits, addresses, and lawyer contacts.",
        "version": "0.1",
        "x-build-id": "IGE6gxCFIlwkiZCSj"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~france-judicial-property-auctions-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-france-judicial-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~france-judicial-property-auctions-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-france-judicial-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~france-judicial-property-auctions-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-france-judicial-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": {
                    "startUrls": {
                        "title": "🔗 Licitor pages or announcements",
                        "type": "array",
                        "description": "Optional Licitor region, court calendar, results, or individual announcement URLs. Leave empty to crawl selected regions.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "regions": {
                        "title": "French regions",
                        "type": "array",
                        "description": "Licitor coverage zones to crawl when no start URLs are supplied.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "paris-et-ile-de-france",
                                "bretagne-grand-ouest",
                                "centre-loire-limousin",
                                "sud-est-mediterrannee",
                                "sud-ouest-pyrenees"
                            ],
                            "enumTitles": [
                                "Paris & Île-de-France",
                                "Brittany & Grand Ouest",
                                "Centre, Loire & Limousin",
                                "South-East & Mediterranean",
                                "South-West & Pyrenees"
                            ]
                        },
                        "default": [
                            "paris-et-ile-de-france",
                            "bretagne-grand-ouest",
                            "centre-loire-limousin",
                            "sud-est-mediterrannee",
                            "sud-ouest-pyrenees"
                        ]
                    },
                    "scope": {
                        "title": "Auction scope",
                        "enum": [
                            "upcoming",
                            "historical",
                            "all"
                        ],
                        "type": "string",
                        "description": "Collect upcoming sales, historical adjudication results, or both.",
                        "default": "upcoming"
                    },
                    "dateFrom": {
                        "title": "Auction date from",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Optional inclusive start date in YYYY-MM-DD format."
                    },
                    "dateTo": {
                        "title": "Auction date to",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Optional inclusive end date in YYYY-MM-DD format."
                    },
                    "maxItems": {
                        "title": "Maximum auction records",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Stop after saving this many unique announcement IDs.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```