# Italy Property Auctions API - PVP Judicial Auctions in English (`webdata_labs/italy-pvp-auctions-api`) Actor

\[💵 $4.00 / 1K] Aste giudiziarie dal Portale delle Vendite Pubbliche: prezzo base, offerta minima, stato occupazione, tribunale. Clean English schema for international investors - base price, minimum offer, discount %, occupancy, coordinates & bidding links. Not a pvp.giustizia.it dump.

- **URL**: https://apify.com/webdata\_labs/italy-pvp-auctions-api.md
- **Developed by:** [WebData Labs](https://apify.com/webdata_labs) (community)
- **Categories:** Lead generation, Developer tools, Real estate
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 auction records

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.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

## Italy Property Auctions API - PVP Judicial Auctions in English

**One clean English row for every Italian judicial auction.** Filter by region, city, category and price band, or pass specific announcement IDs, and get analysis-ready investor leads from Italy's official Ministry of Justice auction portal (`pvp.giustizia.it` - the Portale delle Vendite Pubbliche): base price, minimum offer, the **discount vs base price**, occupancy status, sale date and offer deadline, coordinates, court, and the direct links to the official bidding sites - decoded from the register's internal codes into one consistent schema.

Italy runs the **largest judicial-auction market in Europe** - hundreds of thousands of court-ordered sales of apartments, commercial buildings, land, vehicles, machinery and company shares flow through the PVP register. But the register speaks an undocumented internal dialect: sale types are cryptic codes (`SENIN`, `VENDAS`), occupancy arrives as truncated flags (`LIBER`/`OCCUP`), categories are SCREAMING_SNAKE Italian, some sale dates are data-entry junk (the register really contains auctions dated year 3019 - this Actor flags them), and the number an investor actually wants - **how far below the base price the minimum offer sits** - is never given. The few existing Italy auction scrapers dump raw Italian from third-party aggregator sites. This Actor reads the **official register itself** and does the hard part: decodes every code to English, normalizes dates and money, derives the `discountPctVsBase` signal, resolves occupancy, and returns **one consistent row** per auction with the official bidding links attached.

### ✅ What you get / ❌ what this isn't

| This Actor gives you | This Actor is not |
|---|---|
| One normalized row per auction, English-labeled, identical shape every time | Not a raw Italian `pvp.giustizia.it` dump |
| Economics decoded: base price, minimum offer, bid increment, derived discount % | Not affiliated with or endorsed by the Ministry of Justice or any court |
| Occupancy resolved: `FREE` / `OCCUPIED` / `UNKNOWN` | Not investment, legal, or bidding advice |
| Sale schedule: sale date/time, **offer deadline**, junk-date flag | Not a guarantee that every auction exposes every field |
| Search by region (English names work: Tuscany, Sicily...), city, category, price band | Not real-time - reflects the register's publication cadence |
| Direct links to the official listing & telematic **bidding** sites per auction | Not a bidding or escrow service - you bid through the official channels |

### 🔎 Why use this Actor

- Source below-market Italian property deals by filtering on base price and the derived discount.
- Get a fresh, structured feed of auctions **currently on sale** for any region or city.
- See occupancy status up front - the difference between a usable property and a legal project.
- Jump straight to the official telematic bidding site via `listingSites[]`.
- Get **English** auction leads for an international pipeline instead of Italian register codes.
- Feed normalized auction data into a CRM, dashboard, model, or LLM workflow.

### 👥 Who it's for

- Property investors, flippers, and buy-to-let buyers hunting distressed and below-market assets in Italy.
- Real-estate lead-gen agencies and portals serving auction buyers.
- Funds and brokers tracking judicial sales by region, category, or price band.
- Proptech and data teams building Italian auction alerts or dashboards.
- Anyone who wants one tidy English schema instead of a `pvp.giustizia.it` reverse-engineering project.

### 🗂️ What data you get

One row per auction:

| Field | Type | Description |
|---|---|---|
| `auctionId`, `announcementUrl` | number / string | PVP announcement ID and the official public URL |
| `assetClass` | string | `REAL_ESTATE` / `MOVABLE` / `COMPANY` / `SECURITIES_CREDITS` / `OTHER` |
| `category`, `categoryIt` | string | `RESIDENTIAL` / `COMMERCIAL` / `INDUSTRIAL` / ... (+ Italian) |
| `itemTypes[]` | array | English item typologies: Apartment, Parking space, Building land... |
| `basePrice` | number | Prezzo base d'asta in EUR |
| `minimumOffer` | number | Offerta minima in EUR |
| `minBidIncrement` | number | Rialzo minimo in EUR |
| `discountPctVsBase` | number | Derived: how far the minimum offer sits below the base price |
| `occupancyStatus` | string | `FREE` / `OCCUPIED` / `UNKNOWN` (decoded from register flags) |
| `saleDate`, `saleDateTime` | string | Auction date (ISO 8601) |
| `saleDateSuspect` | boolean | Flags register data-entry junk (e.g. year 3019 sale dates) |
| `offerDeadline` | string | Deadline to submit an offer (ISO 8601) |
| `saleType`, `saleMode` | string | `SEALED_BID` / `OPEN_OUTCRY` + `ONLINE_ASYNC` / `ONLINE_LIVE` / `IN_PERSON` |
| `address`, `city`, `province`, `region` | object / string | Structured location with postal code |
| `latitude`, `longitude` | number | Geocoded coordinates when the register provides them |
| `court`, `courtCode`, `procedureNumber` | string | The court and procedure behind the sale |
| `listingSites[]` | array | Official listing and telematic **bidding** URLs for this auction |
| `items[]`, `itemCount` | array / number | Every item in the lot with English typology and description |
| `significantEvents[]` | array | Rectifications and notices attached to the announcement |
| `outcome` | string | Sale outcome, when the register exposes one |

### ⚙️ How to pull auction data

1. Open the Actor on Apify.
2. Set `region` (Italian or English name - `Lazio`, `Tuscany`, `Sicily`...), optional `city`, `propertyCategory`, and a price band. Or paste specific `auctionIds`.
3. Keep `timeFilter` on **On sale / upcoming** for live leads, or switch to recent outcomes / full archive.
4. Run the Actor and open the `Auctions` dataset view.
5. Export JSON, CSV, Excel, HTML, or XML, or call the Actor through the Apify API.

### 📥 Input

```json
{
  "region": "Lazio",
  "city": "Roma",
  "assetType": "real-estate",
  "propertyCategory": "residential",
  "timeFilter": "on-sale",
  "maxBasePrice": 300000,
  "maxResults": 50
}
````

### 📤 Output

```json
{
  "recordType": "auction",
  "auctionId": 4600384,
  "announcementUrl": "https://pvp.giustizia.it/pvp/it/detail_annuncio.page?idAnnuncio=4600384",
  "assetClass": "REAL_ESTATE",
  "category": "RESIDENTIAL",
  "itemTypes": ["Social housing unit"],
  "currency": "EUR",
  "basePrice": 83500.0,
  "minimumOffer": 62625.0,
  "minBidIncrement": 3000.0,
  "discountPctVsBase": 25.0,
  "occupancyStatus": "FREE",
  "saleDate": "2026-11-19",
  "saleDateTime": "2026-11-18T10:30",
  "saleDateSuspect": false,
  "offerDeadline": "2026-11-18T23:59",
  "saleType": "SEALED_BID",
  "saleMode": "ONLINE_ASYNC",
  "city": "Roma",
  "province": "Roma",
  "region": "Lazio",
  "latitude": 41.8835806,
  "longitude": 12.578722,
  "court": "Tribunale di ROMA",
  "listingSites": [
    { "url": "https://www.fallcoaste.it/vendita/...", "site": "https://www.fallcoaste.it", "type": "listing" }
  ],
  "itemCount": 1
}
```

### 💵 How much does it cost?

The launch price is about `$4.00 / 1,000 auctions`, tier-discounted for higher Apify plans. One auction row is one charged result. A run returning 80 auctions is 80 results. Failed lookups are not charged.

### 🔁 Run it on the Apify platform

Schedule a recurring run to keep a regional auction feed fresh (new announcements, upcoming deadlines), call it from the Apify API, export to CSV/JSON/Excel, or connect the dataset to Make, Zapier, webhooks, a warehouse, a CRM, or an LLM pipeline.

### ⚠️ Limits and caveats

- This Actor reads the **public official register** (`pvp.giustizia.it`, Portale delle Vendite Pubbliche, Ministry of Justice). It is not affiliated with the Ministry or any court and returns only data already public there.
- **Not investment or legal advice.** Occupancy, descriptions, and procedure details are reproduced from the register; verify every lot with the official documentation before bidding.
- **Field coverage varies.** Older or movable-goods auctions may lack coordinates, images, or occupancy flags; `occupancyStatus` is then `UNKNOWN`.
- **Some register dates are junk.** A few sale dates are court data-entry errors (year 3019 and similar); they are flagged with `saleDateSuspect: true`, not silently dropped.
- Deep pagination is capped by `maxResults` (up to 1,000 per run); narrow by region, category, or price band for bigger pulls.
- Data reflects the register's publication cadence, not real time.

### 🧩 Related Actors

- Spain Property Auctions API - BOE Subastas decoded into English investor leads.
- EU Tenders API - normalized TED public procurement in one English schema.
- Brazil CNPJ Company API - clean English firmographics for any Brazil CNPJ.
- US Building Permits API - normalized construction permits and contractor leads.

### ❓ FAQ

#### What is the Portale delle Vendite Pubbliche?

`pvp.giustizia.it` is the Italian Ministry of Justice's official register of court-ordered sales: real-estate foreclosures, bankruptcy liquidations, and movable-asset auctions from every Italian tribunal. Publication there is mandated by law, which makes it the single most complete source of Italian judicial auctions - and this Actor turns it into clean, English-labeled investor leads.

#### What is `discountPctVsBase`?

It is the gap between the base auction price (`prezzo base d'asta`) and the minimum acceptable offer (`offerta minima`), as a percentage. Italian procedure commonly allows offers down to 75% of base, so 25% is typical - and repeated failed auctions push the base itself far below market. Always verify the lot before acting.

#### Why does occupancy matter?

An `OCCUPIED` property may involve a lengthy legal process before you can use it; a `FREE` one is immediately available. The register encodes this in truncated per-item flags; this Actor resolves them into one `occupancyStatus` per auction.

#### Can I search all of Italy?

Yes. Leave `region` empty for the whole country, or set a region in Italian or English (`Lombardia` or `Lombardy`, `Toscana` or `Tuscany`) plus an optional `city`.

#### How do I actually bid?

Through the official channels only. Each row carries `listingSites[]` with the auction's official listing pages and the telematic bidding site (`type: "bidding"`) registered for that sale.

#### Does it need a proxy?

No. The PVP register is a public official source served reliably to datacenter IPs. Enable Apify Proxy only for very large batches.

### 🇮🇹 In italiano

**Estrai le aste giudiziarie dal Portale delle Vendite Pubbliche (pvp.giustizia.it)** in uno schema pulito e strutturato: prezzo base, offerta minima, rialzo minimo, sconto sul prezzo base, stato di occupazione, data vendita e termine presentazione offerte, tribunale, coordinate e i link ufficiali per fare offerta - pronto per Excel, CSV o JSON.

- **Filtra per regione e città** (per esempio Lazio/Roma, Lombardia/Milano) o cerca in tutta Italia.
- **Solo annunci in vendita**, esiti recenti, o l'intero archivio storico.
- **I link ufficiali** ai siti di pubblicità e ai gestori delle vendite telematiche sono inclusi in ogni riga.
- Gli importi sono numeri puliti e le etichette sono tradotte in inglese per investitori internazionali - i codici originali del registro restano disponibili con `includeRaw`.

Manca un campo o qualcosa non funziona? Apri un issue dell'Actor con l'URL della run e rispondiamo di solito entro un giorno.

### 🛠️ Support

For bugs, missing fields, or a feature request, open an Actor issue with the run URL, the filters or auction IDs used, and the field or behavior you expected.

### ⭐ Rate this Actor

If this Actor saved you time, please take 30 seconds to leave a review on the **Reviews** tab of [Italy Property Auctions API - PVP Judicial Auctions in English](https://apify.com/webdata_labs/italy-pvp-auctions-api) - reviews are the main trust signal other users see, and they directly decide which features get built next. If something is broken or a field is missing, please [open an issue](https://apify.com/webdata_labs/italy-pvp-auctions-api/issues) first - we typically respond within a day and would love the chance to fix it before you rate.

# Actor input Schema

## `region` (type: `string`):

Italian region to search. Accepts Italian or English names: 'Lazio', 'Lombardia'/'Lombardy', 'Toscana'/'Tuscany', 'Sicilia'/'Sicily'... Leave empty to search all of Italy.

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

Optional locality filter, e.g. 'Roma', 'Milano', 'Firenze'. Combined with region.

## `assetType` (type: `string`):

What kind of asset is being auctioned.

## `propertyCategory` (type: `string`):

Narrow real estate to a category. Ignored for non-real-estate asset types.

## `timeFilter` (type: `string`):

On sale = auctions currently open or upcoming (what investors want). Recent outcomes = recently held auctions. Full archive = everything since 2010+ (includes concluded).

## `minBasePrice` (type: `integer`):

Only auctions with a base price at or above this amount.

## `maxBasePrice` (type: `integer`):

Only auctions with a base price at or below this amount.

## `searchQuery` (type: `string`):

Free-text search over the announcement text, e.g. 'villa vista mare' or a street name.

## `auctionIds` (type: `string`):

Fetch specific auctions directly instead of searching. One or more PVP announcement IDs (the idAnnuncio number, e.g. '4600384'), separated by comma, space or new line. When set, the search filters above are ignored.

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

Fetch each auction's detail record (sale method, offer deadline, official bidding links, per-item descriptions). One extra light request per auction. Off = search rows only, twice as fast.

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

Safety cap on how many auctions to return in one run.

## `includeRaw` (type: `boolean`):

Attach the original Italian API payloads under 'raw' for auditing. Off by default to keep rows clean.

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

Optional. The PVP portal is a public official source and works without a proxy; enable Apify Proxy only for very large batches.

## Actor input object example

```json
{
  "region": "Lazio",
  "assetType": "real-estate",
  "propertyCategory": "any",
  "timeFilter": "on-sale",
  "includeDetails": true,
  "maxResults": 50,
  "includeRaw": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `OUTPUT` (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 = {
    "region": "Lazio"
};

// Run the Actor and wait for it to finish
const run = await client.actor("webdata_labs/italy-pvp-auctions-api").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 = { "region": "Lazio" }

# Run the Actor and wait for it to finish
run = client.actor("webdata_labs/italy-pvp-auctions-api").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 '{
  "region": "Lazio"
}' |
apify call webdata_labs/italy-pvp-auctions-api --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=webdata_labs/italy-pvp-auctions-api",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Italy Property Auctions API - PVP Judicial Auctions in English",
        "description": "[💵 $4.00 / 1K] Aste giudiziarie dal Portale delle Vendite Pubbliche: prezzo base, offerta minima, stato occupazione, tribunale. Clean English schema for international investors - base price, minimum offer, discount %, occupancy, coordinates & bidding links. Not a pvp.giustizia.it dump.",
        "version": "0.1",
        "x-build-id": "xOYHudkXtlOS3MGdp"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/webdata_labs~italy-pvp-auctions-api/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-webdata_labs-italy-pvp-auctions-api",
                "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/webdata_labs~italy-pvp-auctions-api/runs": {
            "post": {
                "operationId": "runs-sync-webdata_labs-italy-pvp-auctions-api",
                "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/webdata_labs~italy-pvp-auctions-api/run-sync": {
            "post": {
                "operationId": "run-sync-webdata_labs-italy-pvp-auctions-api",
                "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": {
                    "region": {
                        "title": "Region",
                        "type": "string",
                        "description": "Italian region to search. Accepts Italian or English names: 'Lazio', 'Lombardia'/'Lombardy', 'Toscana'/'Tuscany', 'Sicilia'/'Sicily'... Leave empty to search all of Italy."
                    },
                    "city": {
                        "title": "City / comune (optional)",
                        "type": "string",
                        "description": "Optional locality filter, e.g. 'Roma', 'Milano', 'Firenze'. Combined with region."
                    },
                    "assetType": {
                        "title": "Asset type",
                        "enum": [
                            "real-estate",
                            "movable",
                            "companies",
                            "credits",
                            "other"
                        ],
                        "type": "string",
                        "description": "What kind of asset is being auctioned.",
                        "default": "real-estate"
                    },
                    "propertyCategory": {
                        "title": "Property category",
                        "enum": [
                            "any",
                            "residential",
                            "commercial",
                            "industrial",
                            "sports",
                            "other"
                        ],
                        "type": "string",
                        "description": "Narrow real estate to a category. Ignored for non-real-estate asset types.",
                        "default": "any"
                    },
                    "timeFilter": {
                        "title": "Auction window",
                        "enum": [
                            "on-sale",
                            "recent-outcomes",
                            "archive"
                        ],
                        "type": "string",
                        "description": "On sale = auctions currently open or upcoming (what investors want). Recent outcomes = recently held auctions. Full archive = everything since 2010+ (includes concluded).",
                        "default": "on-sale"
                    },
                    "minBasePrice": {
                        "title": "Min base price (EUR)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only auctions with a base price at or above this amount."
                    },
                    "maxBasePrice": {
                        "title": "Max base price (EUR)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only auctions with a base price at or below this amount."
                    },
                    "searchQuery": {
                        "title": "Free-text search (optional)",
                        "type": "string",
                        "description": "Free-text search over the announcement text, e.g. 'villa vista mare' or a street name."
                    },
                    "auctionIds": {
                        "title": "Specific auction IDs (optional)",
                        "type": "string",
                        "description": "Fetch specific auctions directly instead of searching. One or more PVP announcement IDs (the idAnnuncio number, e.g. '4600384'), separated by comma, space or new line. When set, the search filters above are ignored."
                    },
                    "includeDetails": {
                        "title": "Fetch full details",
                        "type": "boolean",
                        "description": "Fetch each auction's detail record (sale method, offer deadline, official bidding links, per-item descriptions). One extra light request per auction. Off = search rows only, twice as fast.",
                        "default": true
                    },
                    "maxResults": {
                        "title": "Max auctions",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Safety cap on how many auctions to return in one run.",
                        "default": 50
                    },
                    "includeRaw": {
                        "title": "Include raw fields",
                        "type": "boolean",
                        "description": "Attach the original Italian API payloads under 'raw' for auditing. Off by default to keep rows clean.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy",
                        "type": "object",
                        "description": "Optional. The PVP portal is a public official source and works without a proxy; enable Apify Proxy only for very large batches.",
                        "default": {
                            "useApifyProxy": 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
