# Astegiudiziarie Scraper — Italian Judicial Property Auctions (`studio-amba/astegiudiziarie-scraper`) Actor

Extract judicial real-estate auction lots from Astegiudiziarie.it — Italy's #1 court-auction portal since 1995. Get starting prices, addresses, province, competent court, procedure number, auction hearing date, bidding deadline, and lot details. Filter by province, city, or price range.

- **URL**: https://apify.com/studio-amba/astegiudiziarie-scraper.md
- **Developed by:** [Studio Amba](https://apify.com/studio-amba) (community)
- **Categories:** Real estate
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $7.00 / 1,000 result scrapeds

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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## Astegiudiziarie Scraper

Extract Italian judicial real-estate auctions from [Astegiudiziarie.it](https://www.astegiudiziarie.it) — Italy's #1 court-auction portal since 1995 — into structured JSON with starting prices, addresses, competent court, procedure numbers, and auction dates.

### What is Astegiudiziarie Scraper?

**Astegiudiziarie Scraper** pulls structured data out of Italy's leading judicial property auction portal, helping you find distressed/below-market properties, track auction volume by region, and automate court-auction lead generation — without manually browsing hundreds of listings.

- **Find distressed-property leads:** every listing on this site is a court-ordered sale (espropriazione immobiliare) — properties sold below market value by definition
- **Monitor auction activity by region:** filter by province or city and track how many properties go to auction, average starting prices, and which courts (tribunali) are most active
- **Automate market research:** export starting prices, procedure numbers, and auction dates to build datasets for valuation models or regional distress analysis
- **Build automated alerts:** schedule daily runs and get notified when new lots matching your criteria (city, price range) appear
- **Feed a CRM or dashboard:** export structured data to Google Sheets, Airtable, or any BI tool via Apify integrations

Astegiudiziarie.it has **no public API and no export feature**. This scraper queries the same internal JSON API the website itself uses — fast, reliable, no browser automation needed.

### How to scrape Astegiudiziarie data

The input is simple: pick a province and/or city, optionally a price range, and run.

#### Input options

| Field | Type | Required | Description |
|-------|------|----------|--------------|
| `provincia` | String | No | Italian province name, e.g. `"Roma"`, `"Milano"`, `"Napoli"`. Default: `"Roma"`. Leave empty (with `comune`) to search all of Italy |
| `comune` | String | No | Italian city/municipality name, narrower than province, e.g. `"Roma"`, `"Bologna"` |
| `prezzoDa` | Integer | No | Minimum starting price (EUR) |
| `prezzoA` | Integer | No | Maximum starting price (EUR) |
| `includeHistorical` | Boolean | No | Include closed/archived auctions (default `false`). The archive can be 10-100x larger than current listings — useful for historical analysis, noisy for lead generation |
| `scrapeDetails` | Boolean | No | Fetch each lot's detail page for surface area (m²) and room count (default `true`). The search API alone doesn't expose these two fields |
| `maxResults` | Integer | No | Maximum lots to return (default: 100, max: 5000) |
| `proxyConfiguration` | Object | No | Apify proxy settings. The site has no anti-bot protection (verified) — not required for success, but recommended for very large runs |

#### Tips for best results

- **Start with a province, narrow with a city:** `provincia: "Milano"` returns every lot in the province; add `comune: "Milano"` to narrow to the city itself
- **Use `prezzoDa`/`prezzoA` for lead qualification:** e.g. `prezzoDa: 50000, prezzoA: 150000` to target a specific investment band
- **Leave `scrapeDetails: true`:** surface area and room count are only available from the detail page, and the extra request per lot is cheap (this is a plain HTTP actor, no browser)
- **Schedule daily runs:** new lots are published continuously across Italy's ~140 civil courts

### Output

Results are stored in a **dataset** you can download as JSON, CSV, Excel, XML, or HTML directly from the Apify Console.

#### Output fields

| Field | Type | Example |
|-------|------|---------|
| `title` | String | `"Appartamento — Cernusco sul Naviglio MI"` |
| `price` / `startingPrice` | Number | `357000` |
| `currency` | String | `"EUR"` |
| `listingType` | String | `"auction"` (always — every listing here is a court-ordered sale) |
| `propertyType` | String | `"appartamento"` |
| `address` | String | `"Via Giacomo Leopardi 17"` |
| `city` | String | `"Cernusco sul Naviglio"` |
| `province` | String | `"MI"` (two-letter Italian province code) |
| `latitude` / `longitude` | Number | `45.5281748`, `9.3278855` |
| `surface` | Number | `357` (m², only when `scrapeDetails: true` and the source publishes it) |
| `rooms` | Number | `6.5` (only when `scrapeDetails: true` and the source publishes it) |
| `court` | String | `"Milano"` (competent Tribunale) |
| `procedureNumber` | String | `"21240/2023"` |
| `procedureRole` | String | `"MI-CONT-21240-2023"` |
| `salePrice` | Number | Final sale price, only present once a lot is sold |
| `auctionDate` | String (ISO) | `"2026-10-13T15:30:00"` |
| `biddingDeadline` | String (ISO) | `"2026-10-12T13:00:00"` |
| `publicationDate` | String (ISO) | Listing publication date |
| `saleStatus` | String | `"PARTECIPABILE"` (eligible to bid) |
| `saleOutcome` | String | `"Sconosciuto"` (unknown/pending) until the auction resolves |
| `isOnlineAuction` | Boolean | `true` — most sales are "vendita telematica" |
| `urlVerified` | Boolean | See **Limitations** below — whether the detail URL was confirmed live |
| `url` | String | Full listing URL |
| `imageUrl` | String | Primary listing photo |
| `description` | String | Full property description |
| `scrapedAt` | String (ISO) | Scrape timestamp |

#### Example output

```json
{
    "title": "Appartamento — Gaggiano MI",
    "price": 536000,
    "currency": "EUR",
    "url": "https://www.astegiudiziarie.it/vendita-asta-appartamento-gaggiano-localita-vigano-certosino-via-don-giovanni-minzoni-70-l2332527-p1313533",
    "scrapedAt": "2026-07-31T09:15:44.820Z",
    "listingType": "auction",
    "propertyType": "appartamento",
    "address": "Localita' Vigano Certosino, via Don Giovanni Minzoni 70",
    "city": "Gaggiano",
    "province": "MI",
    "latitude": 45.3829993,
    "longitude": 9.027457,
    "surface": 357,
    "rooms": 15,
    "description": "Appartamento e seminterrato comunicanti tra loro con scala interna",
    "imageUrl": "https://www.astegiudiziarie.it/Allegato/Foto-PV-EI-396-2025-4.jpg/2332527",
    "lotId": 2332527,
    "saleId": 4356532,
    "lotNumber": "LOTTO UNICO",
    "court": "Pavia",
    "procedureNumber": "396/2025",
    "procedureRole": "PV-EI-396-2025",
    "startingPrice": 536000,
    "auctionDate": "2026-09-30T15:30:00",
    "biddingDeadline": "2026-09-29T12:00:00",
    "publicationDate": "2026-07-30T12:27:00",
    "saleStatus": "PARTECIPABILE",
    "saleOutcome": "Sconosciuto",
    "isOnlineAuction": true,
    "hasPhotos": true,
    "hasFloorPlans": false,
    "hasVirtualTour": false,
    "urlVerified": true
}
```

### How much does it cost to scrape Astegiudiziarie?

Astegiudiziarie Scraper uses **only HTTP requests** (no browser), making it fast and cheap to run.

| Scenario | Est. cost | Time |
|----------|-----------|------|
| 100 lots with full details (surface, rooms) | ~$1.51 | ~1-2 min |
| 500 lots, quick overview (`scrapeDetails: false`) | ~$2.01 | ~30 sec |
| One province, current auctions only (typically 20-600 lots) | ~$0.25-3.10 | ~10 sec-3 min |

**Pricing breakdown:**

- Per run start: $0.01
- Per result: $0.012

### Can I integrate this with other apps?

Yes, through [Apify integrations](https://apify.com/integrations):

- **Google Sheets** — automatically export auction leads to a spreadsheet
- **Slack / Email** — get notified when new lots match your criteria
- **Zapier / Make** — trigger workflows when a run finishes
- **Airtable** — build a searchable auction-property database
- **REST API** — call the scraper programmatically from any language

### Can I use this as an API?

Yes. Use the [Apify API](https://docs.apify.com/api/v2) to run it programmatically.

**Python:**

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")
run = client.actor("studio-amba/astegiudiziarie-scraper").call(run_input={
    "provincia": "Milano",
    "prezzoDa": 50000,
    "prezzoA": 200000,
    "maxResults": 100,
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(f"{item['title']} — €{item['price']:,}")
```

**JavaScript:**

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

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });
const run = await client.actor('studio-amba/astegiudiziarie-scraper').call({
    provincia: 'Milano',
    prezzoDa: 50000,
    prezzoA: 200000,
    maxResults: 100,
});

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

Check the [API tab](https://apify.com/studio-amba/astegiudiziarie-scraper/api) for full documentation.

### FAQ

#### What is Astegiudiziarie.it?

Astegiudiziarie.it (Aste Giudiziarie Inlinea S.p.A.) is Italy's largest judicial real-estate auction portal, operating since 1995. Every listing is a court-ordered sale (espropriazione immobiliare) managed under Italian civil procedure — the properties are typically sold below market value as part of debt-recovery or foreclosure proceedings.

#### How does this scraper work?

It queries the same internal JSON API the website's own search box uses — one request to get all matching lot IDs, then batched requests (20 at a time, the server's own page-size cap) to hydrate full details. No browser automation needed.

#### Can I filter by price range?

Yes. `prezzoDa` and `prezzoA` filter directly on the source API's starting-price field.

#### Can I get surface area and room count?

Yes, when `scrapeDetails: true` (default) and the source publishes them. Coverage varies by listing — many Italian judicial-auction notices simply don't include a structured surface figure, even though the free-text description usually does (e.g. "superficie commerciale... mq.357").

#### Is it legal to scrape Astegiudiziarie?

This scraper extracts publicly available auction data (a matter of public record under Italian judicial procedure) that the site displays to all visitors. As with any scraping tool, use the data responsibly and in compliance with applicable laws.

### Limitations

- **Italy only.** Every listing is a court-ordered sale under Italian civil procedure.
- **A small number of very-recently-published lots may carry an unverified URL.** Astegiudiziarie.it's own search API returns a detail-page URL that 404s on their own server for a meaningful share of lots (confirmed by testing the site's own social-share buttons, which produce the identical dead link — an upstream bug, not a scraping artifact). This scraper cross-references the site's own sitemap to substitute the correct, working URL for the same lot, which resolves it for any lot old enough to be indexed. Each item includes `urlVerified: true/false`; `true` means the URL was confirmed (via the sitemap or a live check), `false` means the lot is too new for the sitemap and the raw (occasionally dead) API URL had to be used as a last resort.
- **Surface/room coverage is source-limited.** These fields simply aren't populated by the auction notice for a large share of listings — this scraper extracts what's published, it doesn't infer or estimate.
- **No bid history.** This is a sealed/asynchronous telematic bidding process, not a live ascending auction — there's no running bid ladder to expose, only the starting price and (once resolved) the final sale price.
- **Historical archive is large.** `includeHistorical: true` can return 10-100x more lots than the active set — set `maxResults` accordingly.

### Related scrapers

Combine with these for broader European judicial-auction and real estate coverage:

- 🇧🇪 [Biddit Scraper](https://apify.com/studio-amba/biddit-scraper) — Belgian notarial property auctions (same auction genre)
- 🏚️ [Distressed Property Feed](https://apify.com/studio-amba/distressed-property-feed) — cross-source distressed-property leads
- 🇮🇹 [Immobiliare.it Scraper](https://apify.com/studio-amba/immobiliare-scraper) — Italy's #1 general real estate portal
- 🇮🇹 [Casa.it Scraper](https://apify.com/studio-amba/casa-it-scraper) — Italian real estate listings

### Your feedback

Found a bug or have a feature request? Open an issue on the [Issues tab](https://apify.com/studio-amba/astegiudiziarie-scraper/issues). We actively maintain this scraper and respond to all reports.

# Actor input Schema

## `provincia` (type: `string`):

Italian province name, e.g. "Roma", "Milano", "Napoli". Leave empty (together with Comune) to search the whole country.

## `comune` (type: `string`):

Italian city/municipality name, e.g. "Roma", "Milano". Narrower than Province — use either or both.

## `prezzoDa` (type: `integer`):

Only return lots with a starting price (prezzo base) at or above this amount.

## `prezzoA` (type: `integer`):

Only return lots with a starting price (prezzo base) at or below this amount.

## `includeHistorical` (type: `boolean`):

Include closed and archived auctions (dataset can be 10-100x larger, going back years). Default: current/active auctions only — the useful set for lead generation.

## `scrapeDetails` (type: `boolean`):

Fetch each lot's detail page for surface area (m²) and room count. Adds one HTTP request per lot. Recommended — the search API alone doesn't expose these fields.

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

Maximum number of auction lots to return.

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

Astegiudiziarie.it has no anti-bot protection (verified) — proxy is not required for success, but recommended for very large runs.

## Actor input object example

```json
{
  "provincia": "Roma",
  "comune": "",
  "includeHistorical": false,
  "scrapeDetails": true,
  "maxResults": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "IT"
  }
}
```

# Actor output Schema

## `results` (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 = {
    "provincia": "Roma",
    "maxResults": 20,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "IT"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("studio-amba/astegiudiziarie-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 = {
    "provincia": "Roma",
    "maxResults": 20,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "IT",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("studio-amba/astegiudiziarie-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 '{
  "provincia": "Roma",
  "maxResults": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "IT"
  }
}' |
apify call studio-amba/astegiudiziarie-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/nL1JrkfpyAQg6b8bm/builds/k8M76pukvKGx3EGBC/openapi.json