# Imovirtual Scraper (`automation-lab/imovirtual-scraper`) Actor

Scrape property listings from Imovirtual, Portugal's leading real estate portal. Extract price, location, property type, area, rooms, agent info, photos, and more.

- **URL**: https://apify.com/automation-lab/imovirtual-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.30 / 1,000 property listing extracteds

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

## Imovirtual Portuguese Real Estate Scraper

Extract property listings from [Imovirtual](https://www.imovirtual.com) — Portugal's largest real estate portal with over 200,000 listings across residential, commercial, and land categories. Get prices, locations, property types, room counts, agent info, photos, and more for any search on the site.

### What does it do?

Imovirtual Scraper takes Imovirtual search result URLs and extracts all listing data returned by those searches. It paginates automatically until your `maxItems` limit is reached.

- **Any property type** — apartments, houses, villas, land, commercial
- **Sale or rent** — specify via the URL (comprar/arrendar)
- **Any Portuguese location** — Lisbon, Porto, Algarve, Braga, and all regions/councils/parishes
- **Full listing detail** — price, area, rooms, floor, agency, photos, and location hierarchy

The scraper reads data from Imovirtual's server-side-rendered HTML (Next.js `__NEXT_DATA__` JSON), so it works without a headless browser — fast, reliable, and proxy-friendly.

### Who is it for?

#### 🏠 Real Estate Investors
Monitor the Portuguese market for price trends, deal-finding, and portfolio research in Lisbon, Porto, the Algarve, and emerging regions.

#### 📊 Market Research Analysts
Build datasets of active listings to track median prices, price-per-sqm by parish, transaction volume, and market saturation in any area.

#### 🌍 Expat & Digital Nomad Platforms
Portugal is among Europe's most popular expat destinations. Aggregate Imovirtual data for relocation guides, rental market overviews, or comparison tools.

#### 🏢 Real Estate Agencies & Proptech
Monitor competitor listings, track new-to-market properties, or enrich your CRM with market-wide listing data.

#### 📈 Financial & Academic Research
Study Iberian real estate pricing, urban growth patterns, and housing affordability using live listing data.

#### 🤖 AI & Data Science Teams
Build property valuation models, location scoring algorithms, or investment analytics tools using structured Imovirtual data.

### Why use this scraper?

- **No browser needed** — HTTP + SSR JSON extraction; fast and cost-efficient.
- **Full pagination** — Automatically handles Imovirtual's 36-items-per-page search results.
- **Complete location hierarchy** — district, province, parish, and street from both address and geocoding data.
- **Both sale and rental** — Works with any Imovirtual search URL.
- **Photo URLs included** — Large-resolution images for every listing.
- **Agency or private owner** — Distinguishes between agency-listed and owner-listed properties.
- **Apify proxy support** — Works with residential proxies for uninterrupted scraping at scale.

### What data does it extract?

| Field | Description | Example |
|---|---|---|
| `listingId` | Unique Imovirtual listing ID | `19100936` |
| `url` | Full URL to the listing page | `https://www.imovirtual.com/pt/ad/...` |
| `title` | Listing title | `T3 na Penha de França, Lisboa` |
| `shortDescription` | Short description from search results | `Apartamento renovado em...` |
| `estate` | Property type | `FLAT`, `HOUSE`, `TERRAIN`, `COMMERCIAL` |
| `transaction` | Sale or rent | `SELL`, `RENT` |
| `price` | Asking price | `428000` |
| `currency` | Price currency | `EUR` |
| `pricePerSqm` | Price per square metre | `6114` |
| `areaM2` | Usable floor area (m²) | `70` |
| `terrainAreaM2` | Plot/terrain area (m²) | `null` |
| `rooms` | Room count | `ONE`, `TWO`, `THREE`, `FOUR`, `MORE` |
| `floor` | Floor number | `3` |
| `city` | City/neighbourhood | `Penha de França` |
| `district` | Administrative district | `Lisboa` |
| `province` | Province/region | `Lisboa` |
| `parish` | Parish | `Penha de França` |
| `street` | Street name | `Rua Doutor Oliveira Ramos` |
| `agencyName` | Agency or private owner name | `ComprarCasa Foros de Amora` |
| `agencyId` | Agency ID on Imovirtual | `1277149` |
| `isPrivateOwner` | Private owner listing? | `false` |
| `photos` | Array of large photo URLs | `["https://..."]` |
| `dateCreated` | Listing creation date | `2026-05-10 10:44:44` |
| `pushedUpAt` | Last bumped/renewed date | `2026-05-10T10:44:44+01:00` |
| `isPromoted` | Promoted/featured ad? | `false` |

### How to use it

#### Step 1 — Go to Imovirtual and run your search

Visit [imovirtual.com](https://www.imovirtual.com) and filter by:
- Transaction type (buy or rent)
- Property type (apartment, house, land, etc.)
- Location (city, district, parish)

Copy the resulting URL from your browser address bar.

#### Step 2 — Paste the URL into the actor

In the **Start URLs** field, paste one or more Imovirtual search result URLs.

**Example URLs:**
````

https://www.imovirtual.com/pt/resultados/comprar/apartamento/lisboa/lisboa
https://www.imovirtual.com/pt/resultados/arrendar/apartamento/porto/porto
https://www.imovirtual.com/pt/resultados/comprar/moradia/algarve

````

#### Step 3 — Set your limit

Set **Max items** to control how many listings to extract. See the Pricing section below for per-listing costs by plan tier.

#### Step 4 — Run and export

Download results as JSON, CSV, Excel, or XML from the dataset.

### Input parameters

| Parameter | Type | Default | Description |
|---|---|---|---|
| `startUrls` | string[] | (Lisbon apartments) | Imovirtual search result URLs to scrape |
| `maxItems` | integer | `100` | Maximum listings to extract across all URLs |
| `maxRequestRetries` | integer | `3` | Retry attempts for failed HTTP requests |

### Example input

```json
{
  "startUrls": [
    "https://www.imovirtual.com/pt/resultados/comprar/apartamento/lisboa/lisboa",
    "https://www.imovirtual.com/pt/resultados/arrendar/moradia/porto"
  ],
  "maxItems": 500
}
````

### Example output

```json
{
  "listingId": 19100936,
  "url": "https://www.imovirtual.com/pt/ad/t3-na-penha-de-franca-lisboa-ID1i91C",
  "title": "T3 na Penha de França, Lisboa",
  "shortDescription": "Este apartamento T3 situa-se numa das zonas mais centrais de Lisboa...",
  "estate": "FLAT",
  "transaction": "SELL",
  "price": 428000,
  "currency": "EUR",
  "pricePerSqm": 6114,
  "areaM2": 70,
  "terrainAreaM2": null,
  "rooms": "FOUR",
  "floor": null,
  "city": "Penha de França",
  "district": "Lisboa",
  "province": "Lisboa",
  "parish": "Penha de França",
  "street": "Rua Doutor Oliveira Ramos",
  "agencyName": "ComprarCasa Foros de Amora",
  "agencyId": 1277149,
  "isPrivateOwner": false,
  "photos": [
    "https://ireland.apollo.olxcdn.com/v1/files/eyJ...image;s=1280x1024;q=80"
  ],
  "dateCreated": "2026-05-10 10:44:44",
  "pushedUpAt": "2026-05-10T10:44:44+01:00",
  "isPromoted": false
}
```

### How much does it cost to scrape Imovirtual listings?

This actor uses **pay-per-result pricing** — you only pay for listings successfully extracted, never per run.

| Plan tier | Price per listing | Cost per 1,000 | Cost per 10,000 |
|---|---|---|---|
| FREE | $0.000575 | $0.575 | $5.75 |
| BRONZE | $0.0005 | $0.50 | $5.00 |
| SILVER | $0.00039 | $0.39 | $3.90 |
| GOLD | $0.0003 | $0.30 | $3.00 |
| PLATINUM | $0.0002 | $0.20 | $2.00 |
| DIAMOND | $0.00014 | $0.14 | $1.40 |

The [Apify free plan](https://apify.com/pricing) includes **$5/month** in platform credit — enough to extract approximately **8,700 Imovirtual listings** at FREE tier pricing. A typical Lisbon apartment search returns up to 7,000+ listings.

No flat fee per run — you only pay for what you extract.

### Tips

- **Use residential proxies for large-scale runs** — For scraping 1,000+ listings, enable Apify residential proxies in the actor settings. This reduces the chance of temporary IP blocks from Imovirtual.
- **Combine multiple search URLs** — Pass several URLs in `startUrls` to merge results across regions in a single run. The `maxItems` limit applies globally across all URLs.
- **Scope your search with Imovirtual filters first** — Before running, use Imovirtual's web interface to apply price range, area, and room filters. Copy the filtered URL — the actor will respect those filters.
- **Recommended maxItems by use case:**
  - Quick market snapshot: 100–500 items (~$0.05–$0.25 at BRONZE)
  - Regional analysis: 1,000–5,000 items (~$0.50–$2.50 at BRONZE)
  - Full national scrape: 50,000+ items (~$25 at BRONZE, ~$7 at DIAMOND tier)
- **Schedule regular runs** — Use Apify's scheduler to run the actor daily or weekly and track price trends over time.
- **Export to CSV for Excel/Sheets analysis** — Use the dataset's CSV export for quick pivot table analysis in Excel or Google Sheets.

### Integrations

Connect Imovirtual data to the tools your team already uses:

- **Google Sheets** — Use the [Apify → Google Sheets integration](https://apify.com/integrations/google-sheets) to push new listings into a spreadsheet automatically. Great for tracking Lisbon price trends week-over-week.
- **Airtable** — Route extracted listings into an Airtable base as property pipeline records. Filter by parish, price range, or room count using Airtable views.
- **Slack notifications** — Set up a webhook trigger to post new Algarve listings to a Slack channel whenever the actor runs, so your team never misses a fresh deal.
- **Make (Integromat) / n8n** — Wire the actor's dataset output into multi-step automation workflows — filter by price, enrich with Google Maps data, or post to a CRM.
- **BigQuery / data warehouse** — Export large datasets directly to cloud storage via Apify's built-in integrations for long-term price trend analysis.
- **OpenAI / Claude** — Use the MCP integration (see below) to ask AI assistants to analyse the scraped data, generate summaries, or filter listings by natural language criteria.

### Use with AI via MCP

Imovirtual Scraper is compatible with the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp), letting you use it directly from AI assistants like Claude, Cursor, or VS Code Copilot.

#### Claude Code setup

```bash
claude mcp add --transport http "https://mcp.apify.com?tools=automation-lab/imovirtual-scraper&token=YOUR_APIFY_TOKEN"
```

#### Desktop / Cursor / VS Code JSON config

```json
{
  "mcpServers": {
    "apify": {
      "type": "http",
      "url": "https://mcp.apify.com?tools=automation-lab/imovirtual-scraper&token=YOUR_APIFY_TOKEN"
    }
  }
}
```

#### Example AI prompts

Once connected, you can ask your AI assistant:

- *"Scrape all Lisbon apartments for sale under €400,000 and show me the cheapest 10 by price-per-sqm."*
- *"Get the first 200 rental listings in Porto and calculate the average monthly rent by parish."*
- *"Find all private-owner listings in the Algarve — skip agency listings — and export them as a CSV."*

### Limitations

- **Search results only** — The scraper extracts data visible in Imovirtual search result pages. It does not visit individual listing pages, so fields only visible on the detail page (e.g. full description, specific room dimensions, energy rating) are not extracted.
- **Imovirtual Portugal only** — This actor targets `imovirtual.com`. For Spain, use a separate Idealista or Fotocasa scraper.
- **Max 36 listings per page** — Imovirtual paginates at 36 items/page. The actor handles pagination automatically.

### FAQ

**Can I scrape all listings in Portugal?**
Yes — use broad regional URLs (e.g. `/comprar/apartamento/` without a location filter) and set `maxItems` to a high value. Imovirtual has ~200,000+ active listings.

**Does it work for rental listings?**
Yes — use URLs with `/arrendar/` instead of `/comprar/`.

**Can I scrape land and commercial properties?**
Yes — use `/terreno/` or `/comercial/` in the URL path.

**Will it work with proxy?**
Yes — the actor works with Apify's residential and datacenter proxies. For large-scale runs, residential proxies are recommended.

**How fresh is the data?**
Data is live at the time of the run. Imovirtual updates listings continuously.

**What if the scraper returns 0 results?**
Check that your URL points to a search results page (not a listing detail page). Open the URL in a browser and confirm it displays a list of properties. Also verify the URL contains `/resultados/` — detail page URLs won't work.

**Why is my run failing or returning partial results?**
Imovirtual may be temporarily rate-limiting requests from your IP range. Try enabling **residential proxies** in the actor settings (Proxy > Apify Proxy > Residential). For very large runs (10,000+ items), residential proxies are strongly recommended.

### Legality and disclaimer

This actor scrapes publicly accessible data from Imovirtual's website. It does not bypass any authentication or access controls. Users are responsible for ensuring their use of scraped data complies with applicable laws and Imovirtual's terms of service. This tool is intended for research, analysis, and internal business purposes only.

### API usage

You can run this actor programmatically via the Apify API or SDK.

#### Node.js (ApifyClient)

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

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });

const run = await client.actor('automation-lab/imovirtual-scraper').call({
    startUrls: ['https://www.imovirtual.com/pt/resultados/comprar/apartamento/lisboa/lisboa'],
    maxItems: 100,
});

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

#### Python (ApifyClient)

```python
from apify_client import ApifyClient

client = ApifyClient(token='YOUR_API_TOKEN')

run = client.actor('automation-lab/imovirtual-scraper').call(run_input={
    'startUrls': ['https://www.imovirtual.com/pt/resultados/comprar/apartamento/lisboa/lisboa'],
    'maxItems': 100,
})

for item in client.dataset(run['defaultDatasetId']).iterate_items():
    print(item)
```

#### cURL

```bash
curl -X POST \
  'https://api.apify.com/v2/acts/automation-lab~imovirtual-scraper/runs?token=YOUR_API_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{
    "startUrls": ["https://www.imovirtual.com/pt/resultados/comprar/apartamento/lisboa/lisboa"],
    "maxItems": 100
  }'
```

### Related actors

Looking for real estate data from other European portals? Browse the [Apify Store real estate collection](https://apify.com/store?category=ECOMMERCE\&search=real+estate) for scrapers covering Spain, Italy, France, and more.

# Actor input Schema

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

One or more Imovirtual search result URLs to scrape. Example: https://www.imovirtual.com/pt/resultados/comprar/apartamento/lisboa/lisboa

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

Maximum number of listings to extract across all URLs. Each item costs $0.0005.

## `maxRequestRetries` (type: `integer`):

Number of retry attempts for failed HTTP requests.

## Actor input object example

```json
{
  "startUrls": [
    "https://www.imovirtual.com/pt/resultados/comprar/apartamento/lisboa/lisboa"
  ],
  "maxItems": 10,
  "maxRequestRetries": 3
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "startUrls": [
        "https://www.imovirtual.com/pt/resultados/comprar/apartamento/lisboa/lisboa"
    ],
    "maxItems": 10,
    "maxRequestRetries": 3
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/imovirtual-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 = {
    "startUrls": ["https://www.imovirtual.com/pt/resultados/comprar/apartamento/lisboa/lisboa"],
    "maxItems": 10,
    "maxRequestRetries": 3,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/imovirtual-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 '{
  "startUrls": [
    "https://www.imovirtual.com/pt/resultados/comprar/apartamento/lisboa/lisboa"
  ],
  "maxItems": 10,
  "maxRequestRetries": 3
}' |
apify call automation-lab/imovirtual-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Imovirtual Scraper",
        "description": "Scrape property listings from Imovirtual, Portugal's leading real estate portal. Extract price, location, property type, area, rooms, agent info, photos, and more.",
        "version": "0.1",
        "x-build-id": "vryvnv1vHgmiFhscn"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~imovirtual-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-imovirtual-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/automation-lab~imovirtual-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-imovirtual-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/automation-lab~imovirtual-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-imovirtual-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",
                "required": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "One or more Imovirtual search result URLs to scrape. Example: https://www.imovirtual.com/pt/resultados/comprar/apartamento/lisboa/lisboa",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of listings to extract across all URLs. Each item costs $0.0005.",
                        "default": 100
                    },
                    "maxRequestRetries": {
                        "title": "Max request retries",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Number of retry attempts for failed HTTP requests.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
