# Subito.it Real Estate Scraper (`nogards95/subito-immobili`) Actor

Scrape real estate listings from Subito.it. Search for properties for sale or rent. Extract price, size, rooms, seller type and publication date. Perfect for buyers, agencies, and market analysts.

- **URL**: https://apify.com/nogards95/subito-immobili.md
- **Developed by:** [Nogards](https://apify.com/nogards95) (community)
- **Categories:** Lead generation, Real estate, News
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $2.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Subito.it Real Estate Scraper

Fast and optimized scraper for real estate listings on Subito.it, Italy's leading classifieds marketplace.

### 🎯 What it does

Extracts real estate listings from Subito.it based on your search criteria:

- Browse all listings or narrow down with an optional keyword
- Choose between listings for sale or for rent
- Filter by price range and city
- Extract seller data (agency or private)
- Extract key property details (size, rooms, publication date)
- Get clean, structured JSON data
- Scrape multiple pages efficiently with low memory usage

### 💰 Who is this for

- 🏠 Buyers and renters monitoring the market in a specific area
- 🏢 Real estate agencies analysing competition and market prices
- 📊 Researchers and analysts studying Italian real estate trends
- 🤖 Developers building automated alerts for new listings
- 📈 Investors tracking price-per-sqm by area or property type

### 🚀 Input

```json
{
  "tipo": "vendita",
  "location": "milano",
  "maxPrice": 300000,
  "maxPages": 5
}
````

#### Parameters

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| tipo | string | No | vendita | Listing type: `vendita` (for sale) or `affitto` (for rent) |
| location | string | No | null | City filter (e.g., 'milano', 'roma', 'napoli') |
| keyword | string | No | null | Optional free-text search (e.g., 'bilocale', 'villa con giardino'). Leave empty to get all listings for the category. |
| minPrice | integer | No | null | Minimum price in euros |
| maxPrice | integer | No | null | Maximum price in euros |
| maxPages | integer | No | 3 | Number of pages to scrape (max: 50, ~30 results per page) |

#### Example inputs

**All properties for sale in Milan under €300,000:**

```json
{
  "tipo": "vendita",
  "location": "milano",
  "maxPrice": 300000,
  "maxPages": 3
}
```

**All rental listings in Rome under €1,500/month:**

```json
{
  "tipo": "affitto",
  "location": "roma",
  "maxPrice": 1500,
  "maxPages": 5
}
```

**Villas with garden for sale across Italy:**

```json
{
  "tipo": "vendita",
  "keyword": "villa con giardino",
  "minPrice": 200000,
  "maxPages": 10
}
```

### 📦 Output

Clean JSON array with each listing containing:

```json
{
  "titolo": "Bilocale ristrutturato con balcone",
  "prezzo": 185000,
  "prezzoRaw": "185.000 €",
  "valuta": "EUR",
  "link": "https://www.subito.it/...",
  "citta": "Milano (MI)",
  "mq": 55,
  "locali": 2,
  "tipoVenditore": "agenzia",
  "nomeVenditore": "Immobiliare Rossi",
  "dataPubblicazione": "2024-01-15",
  "immagini": ["https://..."]
}
```

#### Output fields

| Field | Type | Description |
|-------|------|-------------|
| titolo | string | Listing title as shown on Subito.it |
| prezzo | number | Parsed price as a number (null if not available) |
| prezzoRaw | string | Raw price string as shown (e.g., "185.000 €") |
| valuta | string | Always "EUR" |
| link | string | Full URL to the listing on Subito.it |
| citta | string | Seller location (city and province) |
| mq | number | Property size in square metres (null if not listed) |
| locali | number | Number of rooms (null if not listed) |
| tipoVenditore | string | `"agenzia"` (agency) or `"privato"` (private seller) |
| nomeVenditore | string | Name of the agency or private seller (null if not available) |
| dataPubblicazione | string | Listing publication date (null if not available) |
| immagini | array | Array with the first listing image URL |

### ⚙️ How it works

1. Builds the search URL targeting `https://www.subito.it/annunci-italia/{tipo}/immobili/`
2. Appends keyword, price filters, and pagination parameters
3. Navigates through result pages with an optimized Playwright browser
4. Extracts listing data using efficient DOM selectors
5. Identifies seller type (agency or private) from markup and text
6. Returns structured data ready for use

### 🔧 Technical details

- Uses Playwright with optimized browser settings for minimal memory usage
- Handles pagination automatically
- Low memory footprint (< 1 GB RAM)
- Optimized selectors for fast extraction
- Efficient cookie consent handling
- Reduced timeouts for faster scraping
- Blocks images, fonts, and media to minimize memory usage

### 📊 Performance

| Pages | Approx. results | Approx. run time | Memory usage |
|-------|----------------|-----------------|--------------|
| 1 | ~30 | ~30s | < 512 MB |
| 3 (default) | ~90 | ~90s | < 1 GB |
| 10 | ~300 | ~5 min | < 1 GB |
| 50 (max) | ~1,500 | ~25 min | < 2 GB |

### 💡 Use cases

**For home buyers and renters:**
Monitor new listings in a specific area and price range without checking the site every day

**For real estate agencies:**
Analyse market prices by area and property type, benchmark competitors, and track new private listings

**For investors:**
Track price-per-sqm trends by neighbourhood or city over time

### 📊 Pricing

- **Free tier**: Try it with $5 free credits monthly
- **Pay per result**: $X per 1,000 results
- No subscription required

### 🛟 Support

Found a bug? Have a feature request? Open an issue on GitHub or contact via Apify.

### ⚖️ Legal

This scraper respects Subito.it's terms of service and robots.txt.
Only publicly available data is extracted.
Use responsibly and in accordance with local laws.

***

Built with ❤️ using [Apify](https://apify.com) and [Crawlee](https://crawlee.dev)

***

## Subito.it Scraper Immobili

Scraper veloce e ottimizzato per gli annunci immobiliari di Subito.it, il principale marketplace di annunci in Italia.

### 🎯 Cosa fa

Estrae annunci immobiliari da Subito.it in base ai tuoi criteri di ricerca:

- Sfoglia tutti gli annunci o restringi con una parola chiave opzionale
- Scegli tra annunci in vendita o in affitto
- Filtra per fascia di prezzo e città
- Estrae i dati del venditore (agenzia o privato)
- Estrae le caratteristiche principali dell'immobile (mq, locali, data)
- Restituisce dati JSON puliti e strutturati
- Scraping multipagina efficiente con basso utilizzo di memoria

### 💰 A chi serve

- 🏠 Acquirenti e inquilini che vogliono monitorare il mercato su una zona specifica
- 🏢 Agenzie immobiliari che analizzano la concorrenza e i prezzi di mercato
- 📊 Ricercatori e analisti che studiano l'andamento del mercato immobiliare italiano
- 🤖 Sviluppatori che vogliono costruire alert automatici su nuovi annunci
- 📈 Investitori che tracciano prezzi per zona, tipologia o metratura

### 🚀 Input

```json
{
  "tipo": "vendita",
  "location": "milano",
  "maxPrice": 300000,
  "maxPages": 5
}
```

#### Parametri

| Parametro | Tipo | Obbligatorio | Default | Descrizione |
|-----------|------|--------------|---------|-------------|
| tipo | stringa | No | vendita | Tipo di annuncio: `vendita` o `affitto` |
| location | stringa | No | null | Filtro città (es. 'milano', 'roma', 'napoli') |
| keyword | stringa | No | null | Ricerca libera opzionale (es. 'bilocale', 'villa con giardino'). Lascia vuoto per scaricare tutti gli annunci della categoria. |
| minPrice | intero | No | null | Prezzo minimo in euro |
| maxPrice | intero | No | null | Prezzo massimo in euro |
| maxPages | intero | No | 3 | Numero di pagine da scrapare (max: 50, ~30 annunci per pagina) |

#### Esempi di input

**Tutti gli immobili in vendita a Milano sotto 300.000 €:**

```json
{
  "tipo": "vendita",
  "location": "milano",
  "maxPrice": 300000,
  "maxPages": 3
}
```

**Tutti gli affitti a Roma sotto 1.500 €/mese:**

```json
{
  "tipo": "affitto",
  "location": "roma",
  "maxPrice": 1500,
  "maxPages": 5
}
```

**Ville con giardino in vendita in tutta Italia:**

```json
{
  "tipo": "vendita",
  "keyword": "villa con giardino",
  "minPrice": 200000,
  "maxPages": 10
}
```

### 📦 Output

Array JSON con un oggetto per ogni annuncio:

```json
{
  "titolo": "Bilocale ristrutturato con balcone",
  "prezzo": 185000,
  "prezzoRaw": "185.000 €",
  "valuta": "EUR",
  "link": "https://www.subito.it/...",
  "citta": "Milano (MI)",
  "mq": 55,
  "locali": 2,
  "tipoVenditore": "agenzia",
  "nomeVenditore": "Immobiliare Rossi",
  "dataPubblicazione": "2024-01-15",
  "immagini": ["https://..."]
}
```

#### Campi dell'output

| Campo | Tipo | Descrizione |
|-------|------|-------------|
| titolo | stringa | Titolo dell'annuncio come mostrato su Subito.it |
| prezzo | numero | Prezzo come numero (null se non disponibile) |
| prezzoRaw | stringa | Prezzo grezzo come mostrato (es. "185.000 €") |
| valuta | stringa | Sempre "EUR" |
| link | stringa | URL completo dell'annuncio su Subito.it |
| citta | stringa | Città e provincia del venditore |
| mq | numero | Superficie in metri quadri (null se non indicata) |
| locali | numero | Numero di locali/vani (null se non indicato) |
| tipoVenditore | stringa | `"agenzia"` o `"privato"` |
| nomeVenditore | stringa | Nome dell'agenzia o del privato (null se non disponibile) |
| dataPubblicazione | stringa | Data di pubblicazione dell'annuncio (null se non disponibile) |
| immagini | array | Array con la prima immagine dell'annuncio |

### ⚙️ Come funziona

1. Costruisce l'URL di ricerca verso `https://www.subito.it/annunci-italia/{tipo}/immobili/`
2. Aggiunge parola chiave, fascia di prezzo e paginazione come parametri
3. Naviga le pagine di risultati con un browser Playwright ottimizzato
4. Estrae i dati degli annunci con selettori DOM efficienti
5. Identifica il tipo di venditore (agenzia o privato) dal markup e dal testo
6. Restituisce i dati strutturati pronti all'uso

### 🔧 Dettagli tecnici

- Usa Playwright con impostazioni browser ottimizzate per il minimo consumo di memoria
- Paginazione gestita automaticamente
- Footprint di memoria basso (< 1 GB RAM)
- Selettori ottimizzati per estrazione rapida
- Gestione efficiente del cookie consent
- Timeout ridotti per scraping più veloce
- Blocco di immagini, font e media per ridurre l'utilizzo di memoria

### 📊 Performance

| Pagine | Annunci circa | Tempo circa | Memoria |
|--------|--------------|-------------|---------|
| 1 | ~30 | ~30s | < 512 MB |
| 3 (default) | ~90 | ~90s | < 1 GB |
| 10 | ~300 | ~5 min | < 1 GB |
| 50 (max) | ~1.500 | ~25 min | < 2 GB |

### 💡 Casi d'uso

**Per chi cerca casa:**
Monitora i nuovi annunci su una zona e una fascia di prezzo specifica senza dover controllare il sito ogni giorno

**Per le agenzie:**
Analizza i prezzi di mercato per zona e tipologia, confronta i prezzi dei concorrenti e monitora i nuovi annunci di privati

**Per gli investitori:**
Traccia l'andamento dei prezzi al metro quadro per quartiere o città nel tempo

### 📊 Prezzi

- **Piano gratuito**: prova con 5 $ di crediti gratuiti mensili
- **Pagamento per risultato**: $X ogni 1.000 annunci estratti
- Nessun abbonamento richiesto

### 🛟 Supporto

Hai trovato un bug o hai una richiesta? Apri una issue su GitHub o contattaci tramite Apify.

### ⚖️ Note legali

Questo scraper rispetta i termini di servizio e il robots.txt di Subito.it.
Vengono estratti solo dati pubblicamente accessibili.
Usare in modo responsabile e nel rispetto delle leggi locali.

***

Realizzato con ❤️ usando [Apify](https://apify.com) e [Crawlee](https://crawlee.dev)

# Actor input Schema

## `tipo` (type: `string`):

Search for listings for sale or for rent

## `location` (type: `string`):

Location filter (e.g., 'milano', 'roma', 'napoli')

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

Optional free-text search (e.g., 'bilocale', 'villa con giardino', 'attico'). Leave empty to get all listings for the category.

## `minPrice` (type: `integer`):

Minimum price in euros (optional)

## `maxPrice` (type: `integer`):

Maximum price in euros (optional)

## `maxPages` (type: `integer`):

How many pages to scrape (each page contains ~30 listings)

## Actor input object example

```json
{
  "tipo": "vendita",
  "location": "milano",
  "keyword": "bilocale",
  "minPrice": 50000,
  "maxPrice": 300000,
  "maxPages": 5
}
```

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("nogards95/subito-immobili").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("nogards95/subito-immobili").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 '{}' |
apify call nogards95/subito-immobili --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Subito.it Real Estate Scraper",
        "description": "Scrape real estate listings from Subito.it. Search for properties for sale or rent. Extract price, size, rooms, seller type and publication date. Perfect for buyers, agencies, and market analysts.",
        "version": "1.0",
        "x-build-id": "SNtVsw0HpFuXgaNNu"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/nogards95~subito-immobili/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-nogards95-subito-immobili",
                "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/nogards95~subito-immobili/runs": {
            "post": {
                "operationId": "runs-sync-nogards95-subito-immobili",
                "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/nogards95~subito-immobili/run-sync": {
            "post": {
                "operationId": "run-sync-nogards95-subito-immobili",
                "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": {
                    "tipo": {
                        "title": "Listing Type",
                        "enum": [
                            "vendita",
                            "affitto"
                        ],
                        "type": "string",
                        "description": "Search for listings for sale or for rent",
                        "default": "vendita"
                    },
                    "location": {
                        "title": "City / Area",
                        "type": "string",
                        "description": "Location filter (e.g., 'milano', 'roma', 'napoli')"
                    },
                    "keyword": {
                        "title": "Keyword (optional)",
                        "type": "string",
                        "description": "Optional free-text search (e.g., 'bilocale', 'villa con giardino', 'attico'). Leave empty to get all listings for the category."
                    },
                    "minPrice": {
                        "title": "Minimum Price (€)",
                        "type": "integer",
                        "description": "Minimum price in euros (optional)"
                    },
                    "maxPrice": {
                        "title": "Maximum Price (€)",
                        "type": "integer",
                        "description": "Maximum price in euros (optional)"
                    },
                    "maxPages": {
                        "title": "Maximum Pages",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "How many pages to scrape (each page contains ~30 listings)",
                        "default": 3
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
