# Subito Scraper 🩵  \[$0.7/1k | w/ Contacts 📞 ] (`epicscrapers/subito-scraper`) Actor

⚡ From $0.7/1k ⚡ Extract data from Subito.it across all categories: electronics, home, motors, sports, pets, clothing, jobs, real estate, and more. Search by URL or keywords, filter by category, region, and price. Enrich the data with phone numbers, store details, and seller account info.

- **URL**: https://apify.com/epicscrapers/subito-scraper.md
- **Developed by:** [Epic Scrapers](https://apify.com/epicscrapers) (community)
- **Categories:** E-commerce, Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.70 / 1,000 listings

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

## Subito Scraper 🛒 — Scrape Listings from Subito.it

Extract listings from **Subito.it** — Italy's largest classifieds marketplace — across every category: electronics, cars, motorcycles, real estate, jobs, home & garden, sports, animals, clothing, and more.

Scrape **thousands of listings in a single run** with automatic pagination, built-in proxy rotation, smart URL parsing, and optional data enrichment for seller phone numbers, shop details, and account reputation.

---

### Why this actor

Subito.it has no public developer API and blocks naive scrapers within minutes. This actor handles all of that for you — credential-free, proxy-aware, and ready to run.

- **Works out of the box** — paste a Subito search URL and hit Start.
- **No sub-page scraping** — every field is captured directly, including description, images, price, geo, and seller metadata.
- **Covers every category** — cars with mileage/fuel, real estate with surface/rooms, electronics with condition/shipping, and category-specific attributes preserved generically.
- **Italy-native** — region, province, and comune resolution built in.
- **Optional enrichment** — pay only for the extra seller data you actually use.

---

### What you get

Every listing is pushed to the dataset as a clean, structured JSON object.

#### Core listing fields (always included)

| Field | Description |
|---|---|
| `title` | Listing subject |
| `description` | Full ad body text |
| `page_url` | Listing URL on Subito.it |
| `category` | Category name (e.g. *Auto*) |
| `sub_category` | Category slug |
| `type` | Ad type (e.g. *vendo*) |
| `features.price` | Numeric price + formatted (`1.299 €`) |
| `features.item_condition` | Condition (where applicable) |
| `features.shippable` | Shipping availability |
| `features.*` | **Category-specific attributes** (mileage, fuel, rooms, surface, brand, model…) captured generically — nothing is dropped |
| `features_raw` | Full structured feature list for power users |
| `images` | Array of CDN image URLs |
| `geo.city` / `geo.province` / `geo.province_code` / `geo.region` | Italian location hierarchy |
| `publication_date.iso` / `.date` / `.time` / `.timestamp` / `.local` | Normalized publication timestamps |
| `advertiser_type` | `privato` (private) or `azienda` (professional) |
| `advertiser_name` | Seller display name |
| `advertiser_shop_data` | Basic shop name/id (when the seller is a pro) |

#### Optional enrichment (see Pricing)

| Enrichment | Adds |
|---|---|
| 📞 **Phone number** | `phone_number` — seller contact number |
| 🏪 **Shop details** | `advertiser_shop_data` expanded with `shop_categories`, `address`, `listing_count`, `impresapiu_shop_page`, `website`, `logo` |
| 👤 **Seller account info** | `advertiser_account` with `user_id`, `first_ad_insertion_date`, `total_num_approved_ads`, and `badges` (name, description, active status) |

#### Example output

```json
{
  "request_url": "https://www.subito.it/annunci-lazio/vendita/elettronica/?q=iphone+13",
  "title": "Apple iPhone 13 128GB Nuovo",
  "description": "Vendo iPhone 13 128GB nero, mai usato, ancora sigillato...",
  "page_url": "https://www.subito.it/elettronica/apple-iphone-13-128gb-nuovo-roma-123456789.htm",
  "category": "Elettronica",
  "sub_category": "elettronica",
  "type": "vendo",
  "geo": {
    "city": "Roma",
    "province": "Roma",
    "province_code": "RM",
    "region": "Lazio"
  },
  "publication_date": {
    "iso": "2026-07-08T09:14:00.000Z",
    "date": "2026-07-08",
    "time": "09:14:00",
    "timestamp": 1784080440000,
    "local": "08 Lug 14:43"
  },
  "advertiser_type": "privato",
  "advertiser_name": "Marco R.",
  "features": {
    "price": { "value": 429, "formatted": "429 €" },
    "item_condition": "nuovo",
    "shippable": "spedizione disponibile"
  },
  "features_raw": [ /* full structured features */ ],
  "images": [
    "https://cdn.subito.it/...",
    "https://cdn.subito.it/..."
  ],
  "phone_number": "+39 340 123 4567",
  "advertiser_account": {
    "user_id": "u_9876543",
    "first_ad_insertion_date": "2021-03-14",
    "total_num_approved_ads": 18,
    "badges": [
      { "name": "verified", "description": "Verificato", "is_active": true }
    ]
  }
}
````

***

### Features ↔ Benefits

| Feature | Advantage | Benefit |
|---|---|---|
| **Smart URL parsing** | Accepts search URLs, filtered URLs, listing detail URLs, or direct category/region filters | Paste any Subito URL and it just works — no manual param building |
| **Keyword search mode** | Run multiple keywords in one run, sharing the same category/region/price filters | Batch competitor keyword monitoring in minutes |
| **Automatic pagination** | Sequential offset pagination with per-query result caps | Scrape thousands of listings without handling pages yourself |
| **Built-in Apify proxy** | Residential/datacenter rotation preconfigured | Stay unblocked without managing your own proxy infrastructure |
| **Category-aware features** | Well-known fields (price, condition, shipping) normalized; everything else captured generically | Cars get mileage/fuel, homes get rooms/surface, electronics get condition — across every vertical |
| **Selective enrichment** | Phone, shop, and account enrichment can be toggled independently | Pay only for the seller data you need — keep base runs cheap |
| **Reputation metrics** | Seller account age, total listing count, and badges | Filter out scammers and identify high-volume professional sellers |
| **Clean JSON output** | Internal metadata stripped before push | Drop straight into databases, dashboards, or spreadsheets |

***

### Input options

| Input | Type | Description |
|---|---|---|
| **Start URLs** | array | One or more Subito.it URLs. Supports search URLs (`/annunci-lazio/vendita/elettronica/`), filtered URLs (`?q=iphone`), listing detail URLs, and direct API URLs. Leave empty if using keywords/filters below. |
| **Keywords** | array | Free-text search terms (e.g. `iphone 13`, `ps5`, `bici da corsa`). Each becomes its own search. Filters below are shared across all keywords. |
| **Category** | select | All categories — Auto, Moto, Elettronica, Casa, Sport, Animali, Abbigliamento, Immobiliare, Lavoro, Servizi, and more. |
| **Region** | select | All Italian regions — Lombardia, Lazio, Sicilia, Veneto, etc., or all of Italy. |
| **Min price / Max price** | integer | Filter results by price range in Euro. |
| **Max results per query** | integer | Cap listings extracted per URL/keyword. `0` = no limit. Default: `100`. |
| **Phone numbers** | boolean | Enrich each ad with the seller's phone number. |
| **Shop details** | boolean | Enrich pro-seller listings with shop address, hours, logo, website, and listing count. |
| **Seller account info** | boolean | Enrich with seller account reputation: badges, total approved ads, date of first ad. |
| **Proxy** | object | Apify proxy configuration (preconfigured to use Apify proxy by default). |

#### Quick start: search by URL

```json
{
  "startUrls": [
    "https://www.subito.it/annunci-lazio/vendita/elettronica/?q=iphone+13"
  ],
  "maxItemsPerQuery": 50
}
```

#### Quick start: search by keyword + filters

```json
{
  "searchKeywords": ["iphone 13", "samsung galaxy s24"],
  "category": "elettronica",
  "region": "lombardia",
  "minPrice": 200,
  "maxPrice": 1000,
  "maxItemsPerQuery": 100,
  "enrichPhone": true
}
```

#### Quick start: full enrichment run

```json
{
  "startUrls": ["https://www.subito.it/annunci-piemonte/vendita/auto/"],
  "maxItemsPerQuery": 200,
  "enrichPhone": true,
  "enrichShop": true,
  "enrichUserAccount": true
}
```

***

### Common use cases

- **Market research** — track supply volume and average prices across categories and regions over time.
- **Price monitoring** — detect underpriced listings (flips deals, arbitrage opportunities) in real time.
- **Lead generation** — collect seller phone numbers and shop details for B2B outreach (dealerships, estate agents).
- **Competitor & dealer intelligence** — benchmark professional sellers by total listing count, account age, and category coverage.
- **Inventory tracking** — monitor how a category's inventory shifts weekly in a specific province.
- **Real estate & vehicles** — extract rooms, surface, mileage, fuel, and condition for structured comparison shopping.
- **Fraud filtering** — flag low-reputation sellers (new accounts, few ads, no badges) before transacting.

***

### Why this actor (and not alternatives)

- **Faster** — no per-page navigation; every field is captured efficiently without rendering sub-pages.
- **Cleaner output** — normalized dates, prices, and geo hierarchy; category-specific attributes preserved generically so you never lose a field like mileage or surface.
- **Better filtering** — URL, keyword, category, region, and price inputs all combine; no rebuilding search URLs by hand.
- **Cheaper when you don't need enrichment** — phone, shop, and account enrichment are independent toggles. Run cheap base scrapes; pay for extra seller data only when it matters.
- **Graceful budget control** — set a maximum charge per run; when the budget is reached the actor stops cleanly and exits with success, so partial results are always available.

***

### Pricing

This actor uses **pay-per-event** pricing. You only pay for what the actor actually produces:

- **Base: per listing scraped** — covers the core listing fields.
- **Optional: per successful enrichment** — phone number, shop details, and seller account info are charged **separately, and only when data is actually returned**. If an enrichment fails or finds nothing, you are not charged for it.

Set a maximum charge limit per run in the Apify Console to control costs; when the limit is reached the actor halts gracefully and delivers the partial results collected so far. See the actor's pricing page for current per-event rates.

***

### FAQ

**Does it require proxies?**
The actor comes preconfigured with the Apify proxy for anti-blocking out of the box. Advanced users can override the proxy configuration in the input.

**Can it scrape all of Subito?**
Yes — every category and every Italian region is supported, with pagination that walks through every page of results up to your `maxItemsPerQuery` cap (or unlimited if set to `0`).

**Can I scrape a single listing I already have the URL for?**
Yes — paste the listing detail URL into **Start URLs** and the actor will fetch that specific ad (including phone/shop/account enrichment if enabled).

**How many listings can it collect per run?**
Thousands. Set `maxItemsPerQuery` to `0` for no per-query limit. Total output is bounded by the charge limit you set on the run.

**Do I pay for enrichments that fail?**
No. Phone, shop, and account enrichments are charged only when they successfully return data. Errors or absent data (e.g. a private seller has no shop) are never billed.

**What fields come back for a car vs. a house vs. electronics?**
The core fields (title, description, price, geo, dates, images, seller) are always present. Category-specific fields are captured generically under `features` — so cars get `Km`/`Cambio`/`Carburante`, real estate gets `Locali`/`Superficie`, electronics get `Condizione`/`Spedizione`, etc. The full structured feature list is also available under `features_raw`.

**Does it support Italian localization?**
The actor is Italy-focused and returns Italian values (region/province/comune, `nuovo`/`usato` condition, `privato`/`azienda` seller type). Prices are formatted with the `it-IT` locale.

**Is the data fresh?**
Each result includes the original `publication_date` (ISO, date, time, timestamp, and the Subito display string) so you can deduplicate and sort by recency.

***

### Get started

1. Open the actor on Apify Store.
2. Paste a Subito.it search URL — or enter keywords + filters — into the input.
3. (Optional) Toggle phone, shop, or account enrichment.
4. Set a maximum charge limit on the run.
5. Hit **Start** and read your results directly from the dataset, via the Apify API, or through a webhook.

Integrate it into your workflow with the Apify API, schedule it for daily price monitoring, or plug the dataset into your existing dashboard. Start scraping Subito.it in minutes — **[Try the Subito Scraper now →](https://apify.com)**.

# Actor input Schema

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

Subito.it URLs or direct API endpoints. Supports search URLs (e.g. /annunci-lazio/vendita/elettronica/), filtered URLs (?q=iphone), listing detail URLs etc. Leave empty if you use the keywords or filters below.

## `searchKeywords` (type: `array`):

One or more keywords to search for (e.g. 'iphone 13', 'ps5', 'road bike'). Each keyword becomes a separate search. The filters below (category, region, price) are shared across all keywords.

## `category` (type: `string`):

Listing category.

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

Filter by Italian region.

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

Maximum price in Euro.

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

Minimum price in Euro.

## `maxItemsPerQuery` (type: `integer`):

Maximum number of listings to extract per URL or keyword. 0 = no limit.

## `enrichPhone` (type: `boolean`):

Retrieve the seller's phone number for each listing (requires an extra request per listing).

## `enrichShop` (type: `boolean`):

Retrieve shop details (address, opening hours, logo, website) for professional seller listings.

## `enrichUserAccount` (type: `boolean`):

Retrieve the seller account's public information (badges, total listings count, date of first listing).

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

Apify proxy configuration.

## Actor input object example

```json
{
  "maxItemsPerQuery": 100,
  "enrichPhone": false,
  "enrichShop": false,
  "enrichUserAccount": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# 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 = {
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("epicscrapers/subito-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 = { "proxyConfiguration": { "useApifyProxy": True } }

# Run the Actor and wait for it to finish
run = client.actor("epicscrapers/subito-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 '{
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call epicscrapers/subito-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Subito Scraper 🩵  [$0.7/1k | w/ Contacts 📞 ]",
        "description": "⚡ From $0.7/1k ⚡ Extract data from Subito.it across all categories: electronics, home, motors, sports, pets, clothing, jobs, real estate, and more. Search by URL or keywords, filter by category, region, and price. Enrich the data with phone numbers, store details, and seller account info.",
        "version": "0.0",
        "x-build-id": "cplZH75GEwge3xrbs"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/epicscrapers~subito-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-epicscrapers-subito-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/epicscrapers~subito-scraper/runs": {
            "post": {
                "operationId": "runs-sync-epicscrapers-subito-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/epicscrapers~subito-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-epicscrapers-subito-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Subito.it URLs or direct API endpoints. Supports search URLs (e.g. /annunci-lazio/vendita/elettronica/), filtered URLs (?q=iphone), listing detail URLs etc. Leave empty if you use the keywords or filters below.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchKeywords": {
                        "title": "Keywords",
                        "type": "array",
                        "description": "One or more keywords to search for (e.g. 'iphone 13', 'ps5', 'road bike'). Each keyword becomes a separate search. The filters below (category, region, price) are shared across all keywords.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "category": {
                        "title": "Category",
                        "enum": [
                            "",
                            "auto",
                            "moto-e-scooter",
                            "accessori-auto",
                            "accessori-moto",
                            "veicoli-commerciali",
                            "camper-e-caravan",
                            "nautica",
                            "biciclette",
                            "elettronica",
                            "casa-e-persona",
                            "giardino-e-fai-da-te",
                            "sport-e-hobby",
                            "animali",
                            "abbigliamento-e-accessori",
                            "vendita-immobiliare",
                            "offerte-di-lavoro",
                            "servizi"
                        ],
                        "type": "string",
                        "description": "Listing category."
                    },
                    "region": {
                        "title": "Region",
                        "enum": [
                            "",
                            "abruzzo",
                            "basilicata",
                            "calabria",
                            "campania",
                            "emilia-romagna",
                            "friuli-venezia-giulia",
                            "lazio",
                            "liguria",
                            "lombardia",
                            "marche",
                            "molise",
                            "piemonte",
                            "puglia",
                            "sardegna",
                            "sicilia",
                            "toscana",
                            "trentino-alto-adige",
                            "umbria",
                            "valle-d-aosta",
                            "veneto"
                        ],
                        "type": "string",
                        "description": "Filter by Italian region."
                    },
                    "maxPrice": {
                        "title": "Maximum price (€)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum price in Euro."
                    },
                    "minPrice": {
                        "title": "Minimum price (€)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum price in Euro."
                    },
                    "maxItemsPerQuery": {
                        "title": "Maximum results per query",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of listings to extract per URL or keyword. 0 = no limit.",
                        "default": 100
                    },
                    "enrichPhone": {
                        "title": "Phone numbers",
                        "type": "boolean",
                        "description": "Retrieve the seller's phone number for each listing (requires an extra request per listing).",
                        "default": false
                    },
                    "enrichShop": {
                        "title": "Shop details",
                        "type": "boolean",
                        "description": "Retrieve shop details (address, opening hours, logo, website) for professional seller listings.",
                        "default": false
                    },
                    "enrichUserAccount": {
                        "title": "Seller account info",
                        "type": "boolean",
                        "description": "Retrieve the seller account's public information (badges, total listings count, date of first listing).",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy",
                        "type": "object",
                        "description": "Apify proxy configuration."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
