# Rightmove Property Listings Scraper UK Data (`fetch_cat/rightmove-property-listings-scraper`) Actor

Scrape Rightmove sale, rent, new-build, and commercial listings with prices, addresses, agents, images, and dates for UK property research workflows.

- **URL**: https://apify.com/fetch\_cat/rightmove-property-listings-scraper.md
- **Developed by:** [Hanna Nosova](https://apify.com/fetch_cat) (community)
- **Categories:** Real estate, Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.30 / 1,000 property 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

## Rightmove Property Listings Scraper

Scrape Rightmove residential and commercial property search results into clean datasets with listing IDs, prices, addresses, property types, bedroom counts when available, agents, summaries, images, and listing freshness signals.

Use it for UK residential sales, rental, new-build, and commercial property monitoring, lead generation, price research, portfolio sourcing, and property-data enrichment.

### What does Rightmove Property Listings Scraper do?

Rightmove Property Listings Scraper turns public Rightmove residential and commercial search result pages into structured rows.

It helps you collect:

- 🏠 Residential, new-build, and commercial property listing URLs and Rightmove listing IDs
- 💷 Display prices and numeric price values
- 🛏️ Bedroom and bathroom counts when available
- 📍 Addresses, postcodes, outcodes, and coordinates
- 🏢 Estate agent names, branch names, phone numbers, and agent page URLs
- 🖼️ Main image and optional image URL arrays
- 🕒 Date-added and listing-update signals
- 🔎 Source search URL for traceability

### Who is it for?

This actor is useful for teams that need repeatable UK property-listing data.

- 🏘️ Estate agents tracking competing stock
- 📈 Property investors monitoring new opportunities
- 🧭 Proptech teams enriching search or valuation products
- 🧪 Market researchers studying prices and supply
- 📣 Lead-generation teams finding active agents and listings
- 🏗️ Developers monitoring new-build, resale, and commercial availability
- 🧾 Analysts building dashboards for local market trends

### Why use this actor?

Rightmove search pages are designed for people, not spreadsheets. This actor saves time by converting public search result pages into export-ready data.

You can run it repeatedly with the same search URLs to track changes over time, compare areas, or watch new listing activity.

### Scrape Rightmove sale, rent, and commercial listings

Collect public Rightmove residential sale, residential rent, new-build, commercial to-let, and commercial for-sale search results from the URLs you already use in a browser.

### Typical use cases

- Monitor all two-bedroom flats in a target London region
- Collect property prices for a specific postcode area
- Track rental listings for yield analysis
- Build a daily feed of new sale listings
- Track commercial property to let or for sale in a target market
- Compare estate-agent and commercial-agent stock by area
- Create lead lists of agents advertising active properties
- Power a property-market dashboard

### Monitor new Rightmove listings and price changes

Run the same search URLs on a schedule and compare `listingId`, `displayPrice`, `price`, date-added fields, and agent data to spot new inventory or price movements.

### Export Rightmove property data to spreadsheets or BI tools

Send listing IDs, prices, addresses, agents, images, and freshness signals to CSV, Google Sheets, BigQuery, Snowflake, dashboards, or lead-generation workflows.

### Rightmove Property Listings API and MCP usage

Use Apify API clients for automated Rightmove data pipelines or Apify MCP to run the actor from AI tools that support MCP.

### How much does it cost to scrape Rightmove property listings?

This actor uses pay-per-event pricing.

- A small start event is charged once per run.
- A result event is charged for each saved property listing.
- Final pricing is shown on the Apify actor page before you run it.

The default prefill is intentionally small so first tests stay inexpensive.

### Input overview

Provide one or more public Rightmove search result URLs. Residential sale/rent, new homes, commercial to-let, and commercial for-sale search URLs are supported when Rightmove exposes listings in the public search response.

Example residential search URL:

```text
https://www.rightmove.co.uk/property-for-sale/find.html?locationIdentifier=REGION%5E87490&maxBedrooms=2&sortType=6
````

Example commercial search URL:

```text
https://www.rightmove.co.uk/commercial-property-to-let/find.html?locationIdentifier=REGION%5E87490&sortType=6
```

The actor follows search pagination until it reaches your listing limit or page limit.

### Input fields

| Field | Type | Description |
| --- | --- | --- |
| `startUrls` | array | Rightmove residential or commercial search result URLs to scrape |
| `maxItems` | integer | Maximum listings to save across all URLs |
| `maxPagesPerSearch` | integer | Maximum pages to visit per search URL |
| `includeImages` | boolean | Include image URL arrays when available |

### Output data

Each dataset row represents one Rightmove property listing.

| Field | Description |
| --- | --- |
| `listingId` | Rightmove listing ID |
| `url` | Full listing URL |
| `displayPrice` | Human-readable price |
| `price` | Numeric price when available |
| `propertyType` | Property subtype, such as Flat or Terraced |
| `bedrooms` | Bedroom count |
| `bathrooms` | Bathroom count |
| `address` | Display address |
| `postcode` | Full postcode when visible |
| `outcode` | Postcode outcode when visible |
| `agentName` | Estate agent or brand name |
| `agentPhone` | Agent phone number when shown |
| `agentUrl` | Agent page URL |
| `listingType` | Sale/rent channel signal |
| `summary` | Listing summary text |
| `images` | Image URLs when enabled and available |
| `dateAdded` | First visible or added date |
| `sourceSearchUrl` | Search URL that produced the listing |
| `scrapedAt` | Timestamp for the scrape |

### Example output

```json
{
  "listingId": "174822635",
  "url": "https://www.rightmove.co.uk/properties/174822635#/?channel=RES_BUY",
  "displayPrice": "£98,000",
  "price": 98000,
  "propertyType": "Flat",
  "bedrooms": 1,
  "bathrooms": 1,
  "address": "Park View Court, London E3 3AN, E3 3AN",
  "postcode": "E3 3AN",
  "agentName": "KEAZE LIMITED",
  "listingType": "buy",
  "scrapedAt": "2026-06-19T00:00:00.000Z"
}
```

### How to run

1. Open the actor on Apify.
2. Paste one or more Rightmove search URLs into `startUrls`.
3. Set `maxItems` to your desired limit.
4. Keep `maxPagesPerSearch` modest for test runs.
5. Click **Start**.
6. Download results from the dataset as JSON, CSV, Excel, XML, or RSS.

### Tips for best results

- Start with one search URL and 25 listings.
- Use Rightmove filters in your browser first, then copy the final search URL.
- Run separate searches for residential sale, residential rent, commercial sale, and commercial rent if you need separate datasets.
- Keep `maxPagesPerSearch` aligned with your `maxItems` limit.
- Disable image arrays if you only need prices and addresses.
- Save `sourceSearchUrl` so you can audit where each listing came from.

### Supported Rightmove pages

The actor is intended for standard public Rightmove search result pages, including:

- Residential property for sale searches
- Residential property to rent searches
- New homes searches
- Commercial property for sale searches
- Commercial property to let searches
- Filtered area searches
- Bedroom-count filters
- Price filters
- Sorted result pages

### Data freshness

Rightmove listings change frequently. For monitoring workflows, run the actor on a schedule and compare rows by `listingId`, `displayPrice`, and `listingUpdateDate`.

The actor includes `scrapedAt` on every row so downstream systems can track when each snapshot was collected.

### Integrations

You can connect the actor to many Apify and external workflows:

- 📊 Send results to Google Sheets for market dashboards
- 🧱 Store rows in BigQuery or Snowflake for analysis
- 🔔 Trigger alerts when new listings appear under a target price
- 🧩 Enrich CRM records with active agent data
- 📨 Send daily listing summaries to Slack or email
- 🗺️ Map listings using latitude and longitude

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('fetch_cat/rightmove-property-listings-scraper').call({
  startUrls: [{ url: 'https://www.rightmove.co.uk/property-for-sale/find.html?locationIdentifier=REGION%5E87490' }],
  maxItems: 25,
});

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

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('fetch_cat/rightmove-property-listings-scraper').call(run_input={
    'startUrls': [{'url': 'https://www.rightmove.co.uk/property-for-sale/find.html?locationIdentifier=REGION%5E87490'}],
    'maxItems': 25,
})

items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### API usage with cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/fetch_cat~rightmove-property-listings-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{
    "startUrls": [{"url": "https://www.rightmove.co.uk/property-for-sale/find.html?locationIdentifier=REGION%5E87490"}],
    "maxItems": 25
  }'
```

### MCP integration

Use Apify MCP to run this actor from AI tools that support MCP.

MCP URL:

```text
https://mcp.apify.com/?tools=fetch_cat/rightmove-property-listings-scraper
```

Claude Code setup:

```bash
claude mcp add apify-rightmove https://mcp.apify.com/?tools=fetch_cat/rightmove-property-listings-scraper
```

MCP JSON configuration:

```json
{
  "mcpServers": {
    "apify-rightmove": {
      "url": "https://mcp.apify.com/?tools=fetch_cat/rightmove-property-listings-scraper"
    }
  }
}
```

Example prompts:

- "Scrape 50 Rightmove listings from this search URL and summarize median price."
- "Find properties with at least two bedrooms from this Rightmove search."
- "Compare estate agents represented in these Rightmove results."

### Scheduling

For monitoring, schedule the actor daily or weekly with the same search URLs.

Recommended scheduled workflow:

1. Keep the same `startUrls` list.
2. Use a stable `maxItems` limit.
3. Export each run to your warehouse.
4. Compare by `listingId` and `displayPrice`.
5. Alert on new listings or price changes.

### Limits and caveats

- Only public data visible on Rightmove search pages is returned.
- Some fields may be missing when Rightmove does not show them.
- Search-result data can differ from full detail-page data.
- Very large searches should be split into area-specific URLs.
- Removed or unavailable listings may disappear between runs.

### FAQ

#### Can I scrape both residential and commercial listings?

Yes. Add residential sale/rent and commercial sale/to-let search URLs as separate `startUrls`, or run separate actor runs if you want separate datasets.

#### Can I scrape Rightmove commercial property listings?

Yes. Commercial property for-sale and to-let search URLs are supported when Rightmove exposes listings in the public search response.

#### Can I monitor new Rightmove listings on a schedule?

Yes. Create a daily or weekly Apify schedule with stable search URLs and compare output by `listingId` and price fields.

#### Can I export Rightmove prices and agent data?

Yes. Dataset exports include pricing, address, agent, image, and source URL fields when available.

#### What Rightmove search URLs are supported?

Use public Rightmove residential sale/rent, new homes, commercial for-sale, commercial to-let, and filtered area search result URLs.

#### Does this actor scrape private account data?

No. It is designed for public Rightmove search result pages only.

### Troubleshooting

#### Why did I get fewer listings than requested?

The search may contain fewer visible results than your `maxItems` limit, or your `maxPagesPerSearch` value may be too low. Increase the page limit if the Rightmove search has more pages.

#### Why are some postcode fields empty?

Rightmove sometimes displays broad addresses or partial areas. The actor extracts postcodes when they are visible in the listing card data.

#### Why are image arrays large?

Some listings include many photos. Set `includeImages` to `false` if you only need listing facts.

### Legality and responsible use

This actor extracts public web data. You are responsible for using results lawfully and respecting applicable laws, platform terms, privacy rules, and data-protection obligations.

Do not use scraped data for unlawful discrimination, harassment, spam, or other prohibited purposes.

### Related actors

Explore other Apify actors from the same catalog for listings, market-data, and lead-generation workflows:

- [Airbnb Listings Scraper](https://apify.com/fetch_cat/airbnb-listings-scraper)
- [Craigslist Classifieds Scraper](https://apify.com/fetch_cat/craigslist-classifieds-scraper)

### Changelog

#### 0.1

- Initial public-search listing extraction.
- Added structured prices, addresses, agents, images, and freshness fields.
- Clarified residential and commercial Rightmove search coverage.

### Support

If a Rightmove search URL does not work as expected, include the actor run ID, input JSON, and a short description of the missing data when contacting support.

# Actor input Schema

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

Public Rightmove property search result URLs to scrape. Use residential sale, residential rent, new homes, commercial sale, commercial rent, or other standard public search result pages.

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

Maximum number of property listings to save across all search URLs.

## `maxPagesPerSearch` (type: `integer`):

Safety limit for pagination per search URL. Rightmove usually returns about 24 listings per page.

## `includeImages` (type: `boolean`):

Save listing image URLs when Rightmove exposes them in search results.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.rightmove.co.uk/property-for-sale/find.html?locationIdentifier=REGION%5E87490&maxBedrooms=2&sortType=6"
    },
    {
      "url": "https://www.rightmove.co.uk/commercial-property-to-let/find.html?locationIdentifier=REGION%5E87490&sortType=6"
    }
  ],
  "maxItems": 20,
  "maxPagesPerSearch": 2,
  "includeImages": true
}
```

# 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": [
        {
            "url": "https://www.rightmove.co.uk/property-for-sale/find.html?locationIdentifier=REGION%5E87490&maxBedrooms=2&sortType=6"
        },
        {
            "url": "https://www.rightmove.co.uk/commercial-property-to-let/find.html?locationIdentifier=REGION%5E87490&sortType=6"
        }
    ],
    "maxItems": 20,
    "maxPagesPerSearch": 2
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/rightmove-property-listings-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": [
        { "url": "https://www.rightmove.co.uk/property-for-sale/find.html?locationIdentifier=REGION%5E87490&maxBedrooms=2&sortType=6" },
        { "url": "https://www.rightmove.co.uk/commercial-property-to-let/find.html?locationIdentifier=REGION%5E87490&sortType=6" },
    ],
    "maxItems": 20,
    "maxPagesPerSearch": 2,
}

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/rightmove-property-listings-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": [
    {
      "url": "https://www.rightmove.co.uk/property-for-sale/find.html?locationIdentifier=REGION%5E87490&maxBedrooms=2&sortType=6"
    },
    {
      "url": "https://www.rightmove.co.uk/commercial-property-to-let/find.html?locationIdentifier=REGION%5E87490&sortType=6"
    }
  ],
  "maxItems": 20,
  "maxPagesPerSearch": 2
}' |
apify call fetch_cat/rightmove-property-listings-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Rightmove Property Listings Scraper UK Data",
        "description": "Scrape Rightmove sale, rent, new-build, and commercial listings with prices, addresses, agents, images, and dates for UK property research workflows.",
        "version": "0.1",
        "x-build-id": "QAjrSZiPuwciy7Kjx"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fetch_cat~rightmove-property-listings-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fetch_cat-rightmove-property-listings-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/fetch_cat~rightmove-property-listings-scraper/runs": {
            "post": {
                "operationId": "runs-sync-fetch_cat-rightmove-property-listings-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/fetch_cat~rightmove-property-listings-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-fetch_cat-rightmove-property-listings-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": "Rightmove search URLs",
                        "type": "array",
                        "description": "Public Rightmove property search result URLs to scrape. Use residential sale, residential rent, new homes, commercial sale, commercial rent, or other standard public search result pages.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum listings",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of property listings to save across all search URLs.",
                        "default": 20
                    },
                    "maxPagesPerSearch": {
                        "title": "Maximum pages per search",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Safety limit for pagination per search URL. Rightmove usually returns about 24 listings per page.",
                        "default": 5
                    },
                    "includeImages": {
                        "title": "Include image URLs",
                        "type": "boolean",
                        "description": "Save listing image URLs when Rightmove exposes them in search results.",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```