# Zoopla UK Property Listings Scraper (`parseforge/zoopla-scraper`) Actor

Extract UK property listings from Zoopla — prices, bedrooms, bathrooms, square footage, property type, tenure, agent info, images, and full descriptions. Free preview caps at 10 listings. Perfect for estate agents, property researchers, and data analysts.

- **URL**: https://apify.com/parseforge/zoopla-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Automation, Marketing, Real estate
- **Stats:** 1 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
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

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 🏠 Zoopla Property Scraper

Scrape UK property listings from Zoopla.co.uk without coding. This scraper extracts property prices, addresses, bedrooms, bathrooms, square footage, property type, agent info, images, and features for both sales and rental listings. Perfect for investors tracking UK property markets, estate agents monitoring competitor listings, or researchers analyzing housing trends.

> **The Zoopla Property Scraper collects UK property listings with up to 24 data fields per property, including GPS coordinates, floor plans, and agent details.**

### ✨ What Does It Do

- 💷 **Price** - Track asking prices for sales and monthly rent for lettings
- 🏠 **Property Details** - Bedrooms, bathrooms, reception rooms, square footage, and property type
- 📍 **Location** - Full display address, postcode, latitude, and longitude coordinates
- 🏗️ **Property Type** - Detached, semi-detached, terraced, flat, bungalow, and more
- 📋 **Description** - Full property description text from the listing
- ✅ **Features** - Key features list (garden, parking, garage, etc.)
- 📸 **Images** - All property image URLs from the gallery
- 🏢 **Agent Info** - Estate agent name and logo
- 📊 **Listing Status** - For sale, under offer, sold STC, to rent

### 🔧 Input

- **Start URL** - Direct Zoopla listing page URL (overrides all filters below)
- **Listing Type** - Search for properties for sale or to rent
- **Location** - City, area, or postcode (e.g. London, Manchester, SW1A 1AA)
- **Price Range** - Minimum and maximum price filters
- **Bedrooms** - Minimum and maximum bedroom count
- **Property Type** - Filter by detached, semi-detached, terraced, flat, etc.
- **Include Details** - Fetch extra data from each property's detail page (features, images, floor plans)
- **Max Items** - How many property listings to collect per run

Example input:
```json
{
  "location": "london",
  "listingType": "for-sale",
  "minBedrooms": 2,
  "maxPrice": 500000,
  "maxItems": 10
}
````

### 📊 Output

Each property listing includes up to 24 data fields. Download as JSON, CSV, or Excel.

| 📸 Image | 🆔 Listing ID | 📝 Title |
|---|---|---|
| 🔗 URL | 💷 Price | 📍 Address |
| 📮 Postcode | 🌐 Latitude | 🌐 Longitude |
| 🛏️ Bedrooms | 🛁 Bathrooms | 🛋️ Reception Rooms |
| 📐 Square Feet | 🏠 Property Type | 📜 Tenure |
| 📊 Listing Status | 🏗️ New Build | 📋 Description |
| ✅ Features | 📸 Images | 🏢 Agent Name |
| 🏢 Agent Logo | ⏰ Scraped At | |

### 💎 Why Choose the Zoopla Property Scraper?

| Feature | Our Actor |
|---|---|
| Sales and rental listings from Zoopla | ✔️ |
| GPS coordinates (latitude/longitude) per property | ✔️ |
| Full property gallery image URLs | ✔️ |
| Key features extraction | ✔️ |
| Estate agent info with logo | ✔️ |
| Filter by price, bedrooms, property type | ✔️ |
| CSV, Excel, and JSON export | ✔️ |
| Cloudflare bypass with browser automation | ✔️ |
| Support for large-scale collection (1 million+ items) | ✔️ |
| Postcode and tenure data | ✔️ |

### 📋 How to Use

No technical skills required. Follow these simple steps:

1. **Sign Up** - [Create a free account with $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp)
2. **Find the Tool** - Search for "Zoopla Property Scraper" in the Apify Store and set your location and filters
3. **Run It** - Click "Start" and watch your results appear

That's it. No coding, no setup needed. Export your data in CSV, Excel, or JSON format.

### 🎯 Business Use Cases

- 🏠 **Property Investor** - Monitor asking prices in target areas daily to spot undervalued properties before competitors
- 🏢 **Estate Agent** - Track competitor listings and pricing strategies across your local market
- 📊 **Market Researcher** - Analyze UK housing trends, price movements, and supply levels by region

### ❓ FAQ

**🔍 How does this scraper work?**
The scraper uses a Camoufox browser to load Zoopla pages, bypass Cloudflare protection, and extract property data from JSON-LD structured data embedded in the page.

**📊 How accurate is the price data?**
Prices come directly from the listing pages on Zoopla. The scraper captures the displayed asking price or monthly rent exactly as shown on the site.

**📅 Can I schedule this to run automatically?**
Yes. Use the Apify scheduler to run this actor on a daily, weekly, or monthly basis. You can also integrate it with Make, Zapier, or GitHub Actions for automated property monitoring.

**⚖️ Is scraping Zoopla allowed?**
Zoopla is a public property listing website. You are collecting publicly visible data. Always review the site terms of service and ensure your use case complies with local laws and regulations.

**🛡️ Will Zoopla block me?**
Zoopla uses Cloudflare protection. This scraper uses a specialized browser to handle challenges automatically. Residential proxies are recommended for best results.

**⚡ How long does a run take?**
A run collecting 10 properties takes about 30-60 seconds including Cloudflare challenge resolution. Larger collections scale based on the number of pages and whether detail page enrichment is enabled.

**⚠️ Are there any limits?**
Free users get up to 10 items. Paid users can collect up to 1,000,000 results.

### 🔗 Integrate Zoopla Property Scraper with any app

- [Make](https://docs.apify.com/platform/integrations/make) - Automate workflows
- [Zapier](https://docs.apify.com/platform/integrations/zapier) - Connect 5000+ apps
- [GitHub](https://docs.apify.com/platform/integrations/github) - Version control integration
- [Slack](https://docs.apify.com/platform/integrations/slack) - Get notifications
- [Airbyte](https://docs.apify.com/platform/integrations/airbyte) - Data pipelines
- [Google Drive](https://docs.apify.com/platform/integrations/drive) - Export to spreadsheets

### 💡 More ParseForge Actors

- [Rightmove Scraper](https://apify.com/parseforge/rightmove-scraper) - Scrape UK property listings from Rightmove
- [Realtor.com Scraper](https://apify.com/parseforge/realtor-scraper) - Extract US property listings and agent data
- [Auction.com Property Scraper](https://apify.com/parseforge/auction-com-property-scraper) - Collect property auction data
- [OnTheMarket Scraper](https://apify.com/parseforge/onthemarket-scraper) - Scrape UK property listings from OnTheMarket
- [RealEstateView Scraper](https://apify.com/parseforge/realestateview-scraper) - Collect Australian property listings

Browse our complete collection of [data extraction tools](https://apify.com/parseforge) for more.

### 🚀 Ready to Start?

[Create a free account with $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp) and collect your first 10 results for free. No coding, no setup.

### 🆘 Need Help?

- Check the FAQ section above for common questions
- Visit the [Apify support page](https://docs.apify.com) for documentation and tutorials
- Contact us to request a new scraper, propose a custom project, or report an issue at [Tally contact form](https://tally.so/r/BzdKgA)

### ⚠️ Disclaimer

> This Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by Zoopla or any of its subsidiaries. All trademarks mentioned are the property of their respective owners.

# Actor input Schema

## `startUrl` (type: `string`):

Direct Zoopla listing page URL to scrape. If provided, all filters below are ignored.

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

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000.

## `listingType` (type: `string`):

Whether to search properties for sale or to rent.

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

City, area, or postcode to search in (e.g. 'London', 'Manchester', 'SW1A 1AA').

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

Minimum property price in GBP.

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

Maximum property price in GBP.

## `minBedrooms` (type: `integer`):

Minimum number of bedrooms.

## `maxBedrooms` (type: `integer`):

Maximum number of bedrooms.

## `propertyType` (type: `string`):

Type of property to search for.

## `radius` (type: `number`):

Search radius in miles from the specified location (e.g. 0.25, 0.5, 1, 3, 5, 10, 20).

## `addedSince` (type: `string`):

Only show listings added within this time period.

## `keywords` (type: `string`):

Keywords to search within property descriptions (e.g. 'garden', 'garage', 'period').

## `furnishingType` (type: `string`):

Furnishing preference for rental properties only.

## `includeDetails` (type: `boolean`):

When enabled, fetches the full property detail page for each listing to extract additional fields (description, features, floor plans, transport links, nearby schools).

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

Proxy settings. Residential proxies are required for Zoopla (Cloudflare-protected).

## Actor input object example

```json
{
  "maxItems": 10,
  "listingType": "for-sale",
  "location": "London",
  "includeDetails": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `results` (type: `string`):

Dataset with all scraped items

# 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 = {
    "maxItems": 10,
    "listingType": "for-sale",
    "location": "London",
    "includeDetails": false,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/zoopla-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 = {
    "maxItems": 10,
    "listingType": "for-sale",
    "location": "London",
    "includeDetails": False,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/zoopla-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 '{
  "maxItems": 10,
  "listingType": "for-sale",
  "location": "London",
  "includeDetails": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call parseforge/zoopla-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Zoopla UK Property Listings Scraper",
        "description": "Extract UK property listings from Zoopla — prices, bedrooms, bathrooms, square footage, property type, tenure, agent info, images, and full descriptions. Free preview caps at 10 listings. Perfect for estate agents, property researchers, and data analysts.",
        "version": "1.0",
        "x-build-id": "vSsJSJA9sF9bYaIzl"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~zoopla-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-zoopla-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/parseforge~zoopla-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-zoopla-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/parseforge~zoopla-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-zoopla-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": {
                    "startUrl": {
                        "title": "Start URL",
                        "type": "string",
                        "description": "Direct Zoopla listing page URL to scrape. If provided, all filters below are ignored."
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000."
                    },
                    "listingType": {
                        "title": "Listing Type",
                        "enum": [
                            "for-sale",
                            "to-rent"
                        ],
                        "type": "string",
                        "description": "Whether to search properties for sale or to rent."
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "City, area, or postcode to search in (e.g. 'London', 'Manchester', 'SW1A 1AA')."
                    },
                    "minPrice": {
                        "title": "Min Price (£)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum property price in GBP."
                    },
                    "maxPrice": {
                        "title": "Max Price (£)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum property price in GBP."
                    },
                    "minBedrooms": {
                        "title": "Min Bedrooms",
                        "minimum": 0,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Minimum number of bedrooms."
                    },
                    "maxBedrooms": {
                        "title": "Max Bedrooms",
                        "minimum": 0,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Maximum number of bedrooms."
                    },
                    "propertyType": {
                        "title": "Property Type",
                        "enum": [
                            "",
                            "detached",
                            "semi-detached",
                            "terraced",
                            "flat",
                            "bungalow",
                            "land",
                            "park-home"
                        ],
                        "type": "string",
                        "description": "Type of property to search for."
                    },
                    "radius": {
                        "title": "Radius (miles)",
                        "minimum": 0,
                        "maximum": 40,
                        "type": "number",
                        "description": "Search radius in miles from the specified location (e.g. 0.25, 0.5, 1, 3, 5, 10, 20)."
                    },
                    "addedSince": {
                        "title": "Added Since",
                        "enum": [
                            "",
                            "24-hours",
                            "3-days",
                            "1-week",
                            "2-weeks",
                            "1-month"
                        ],
                        "type": "string",
                        "description": "Only show listings added within this time period."
                    },
                    "keywords": {
                        "title": "Keywords",
                        "type": "string",
                        "description": "Keywords to search within property descriptions (e.g. 'garden', 'garage', 'period')."
                    },
                    "furnishingType": {
                        "title": "Furnishing Type (Rentals Only)",
                        "enum": [
                            "",
                            "furnished",
                            "unfurnished",
                            "part-furnished"
                        ],
                        "type": "string",
                        "description": "Furnishing preference for rental properties only."
                    },
                    "includeDetails": {
                        "title": "Include Full Details",
                        "type": "boolean",
                        "description": "When enabled, fetches the full property detail page for each listing to extract additional fields (description, features, floor plans, transport links, nearby schools).",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings. Residential proxies are required for Zoopla (Cloudflare-protected)."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
