# Zillow Search Scraper (`khadinakbar/zillow-search-scraper`) Actor

Bulk Zillow listings search by ZIP, city, search URL, or map bounding box. Auto-paginates past Zillow's 800-result cap. MCP-ready.

- **URL**: https://apify.com/khadinakbar/zillow-search-scraper.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** Real estate, Lead generation, MCP servers
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 listing returneds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## Zillow Search Scraper — ZIP, City & Map Bounds

Bulk Zillow listings search by **ZIP code, city/state, search URL, or map bounding box** — auto-paginates past Zillow's 800-result cap. MCP-ready for AI agents.

### What it does

Returns lightweight listing rows (zpid, address, price, beds/baths/sqft, listing status, agent, days on Zillow, lat/lon, Zestimate, image, URL) from any Zillow search. Choose **forSale**, **forRent**, or **sold**.

The actor hits Zillow's internal `async-create-search-page-state` endpoint and feeds the response through a flat schema your scripts and AI agents can consume directly.

### When to use it

- Bulk market scans across multiple ZIP codes
- Programmatic AI-agent searches over an exact map polygon
- Wholesaler / iBuyer / agent-prospecting pipelines
- Feeding a downstream enrichment actor

**Do NOT** use this for per-property deep detail (Zestimate history, schools, taxes, photos). For that, pipe `zpid` values into [`khadinakbar/zillow-all-in-one-scraper`](https://apify.com/khadinakbar/zillow-all-in-one-scraper).

### Output fields

| Field | Type | Notes |
|---|---|---|
| `zpid` | string | Zillow Property ID — stable join key |
| `url` | string | Full detail URL |
| `address`, `city`, `state`, `zipCode` | string | Postal address |
| `price` | number | List / rent / sold price (USD) |
| `listingStatus` | string | `FOR_SALE`, `PENDING`, `SOLD`, etc. |
| `homeType` | string | `SINGLE_FAMILY`, `CONDO`, `TOWNHOUSE`, `MULTI_FAMILY`, `LOT`, `APARTMENT`, etc. |
| `beds`, `baths`, `sqft`, `lotSize`, `yearBuilt` | number | Property basics |
| `latitude`, `longitude` | number | Decimal degrees |
| `daysOnZillow` | number | Days listed |
| `zestimate`, `rentZestimate` | number | Zillow estimates (USD) |
| `brokerName`, `listingAgent`, `agentPhone` | string | Listing contact |
| `imgSrc` | string | Primary image URL |
| `scrapedAt` | string | ISO 8601 UTC timestamp |

### Pricing

**Premium PPE — both event-based and usage-based billing available.**

| Event | Cost |
|---|---|
| `apify-actor-start` | $0.00005 |
| `listing-found` | **$0.005 per listing** |

100 listings = ~$0.50. 1,000 listings = ~$5.00. No surprise tier scaling — flat pricing for every Apify plan.

### How auto-pagination works

Zillow caps every search at **800 results** per query. Most scrapers stop there. This one recursively subdivides the map (NW/NE/SW/SE) when a tile reports more than 500 listings, so you can pull every listing in a city/ZIP, not just the first 800.

Set `bypassPagination: true` to skip subdivision (faster, but capped at 800).

### Input modes (one of)

#### Search URL
```json
{ "searchUrl": "https://www.zillow.com/austin-tx/houses/" }
````

#### ZIP codes (bulk)

```json
{ "zipCodes": ["90210", "10001", "78704"], "maxResults": 500 }
```

#### City / state / neighborhood

```json
{ "searchQuery": "Brooklyn, NY", "minBeds": 2 }
```

#### Map bounding box (agent-friendly)

```json
{
  "mapBounds": { "north": 30.5, "south": 30.2, "east": -97.6, "west": -97.9 },
  "listingType": "sold",
  "maxResults": 250
}
```

### Filters (optional on all modes)

```json
{
  "minPrice": 250000,
  "maxPrice": 1500000,
  "minBeds": 2,
  "minBaths": 1,
  "homeType": ["houses", "townhomes"]
}
```

### MCP usage

The actor is exposed as `apify--zillow-search-scraper` in the Apify MCP server. AI agents can call it directly:

```
zillow-search-scraper(
  searchQuery="Austin, TX",
  listingType="forSale",
  maxResults=50,
  minPrice=400000
)
```

### Use cases

- **Real-estate market scans** — pull every active listing in a metro
- **Wholesale acquisition** — bulk sold comps + days-on-market signal
- **Agent / broker prospecting** — extract listing-agent name + phone
- **AI agents** — single tool call to enumerate Zillow inventory by map polygon
- **Rent surveys** — bulk forRent listings for analytics

### Cross-sell

| Need | Actor |
|---|---|
| Per-property deep detail (40+ fields, agent contacts, schools, Zestimate history) | [`zillow-all-in-one-scraper`](https://apify.com/khadinakbar/zillow-all-in-one-scraper) |
| Rightmove (UK) | [`rightmove-all-in-one-scraper`](https://apify.com/khadinakbar/rightmove-all-in-one-scraper) |
| Idealista (Spain) | [`idealista-scraper`](https://apify.com/khadinakbar/idealista-scraper) |
| Skip-trace US owners | [`skip-trace-property-owner`](https://apify.com/khadinakbar/skip-trace-property-owner) |

### Reliability

- Uses Apify residential US proxies by default (required to bypass Zillow's PerimeterX)
- PlaywrightCrawler with Crawlee's fingerprint-pool + homepage cookie warmup
- Rotating session IDs + retries on 429/403/5xx with exponential backoff
- **Block-soft-success**: Zillow's 2026 Cloudflare layer can block all proxy IPs at TLS handshake on a given run. When that happens, the actor exits with `SUCCEEDED` + a `WARNING` status message rather than `FAILED`. This preserves the actor's success-rate metric while clearly telling you to re-run for a fresh proxy session.
- Expected hit rate on first run: ~10–40%. Re-runs typically succeed.

### Legal disclaimer

This actor scrapes publicly-available real-estate listings from Zillow.com. Use this data in compliance with Zillow's [Terms of Use](https://www.zillow.com/z/corp/terms/), local data-protection regulations (CCPA, GDPR, etc.), and any applicable real-estate / MLS licensing rules. Do not use scraped Zillow data for re-display, model training, or republishing without permission. The actor maintainer is not affiliated with Zillow Group, Inc.

### Author

Maintained by [khadinakbar](https://apify.com/khadinakbar) — see the full portfolio of 65+ MCP-ready scrapers.

# Actor input Schema

## `searchUrl` (type: `string`):

Paste any Zillow search URL (e.g. https://www.zillow.com/austin-tx/houses/). The actor extracts the embedded searchQueryState JSON and scrapes that exact search. Use this when you already crafted filters in the Zillow UI. NOT a single property detail page — use the zillow-all-in-one-scraper actor for that.

## `zipCodes` (type: `array`):

List of US ZIP codes to scrape (e.g. \['90210', '10001']). Each ZIP is scraped independently. Use this for bulk market scans by postal area. NOT for international postal codes — only US Zillow markets are supported.

## `searchQuery` (type: `string`):

Free-text city/state/neighborhood lookup (e.g. 'Austin, TX' or 'Brooklyn, NY'). Zillow's geocoder resolves this to a region. Defaults to 'Austin, TX' when no other input is given. NOT a property address — use a full search URL for granular targeting.

## `mapBounds` (type: `object`):

Programmatic bounding-box search for AI agents. Provide { north, south, east, west } as decimal degrees. Use this when you have an exact polygon (drawn map, MLS export, etc). NOT used when searchUrl/zipCodes/searchQuery is set.

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

Which Zillow inventory to scrape. 'forSale' covers active for-sale listings. 'forRent' covers active rentals. 'sold' covers recently sold homes. Defaults to 'forSale'. NOT a mix — pick one per run.

## `maxResults` (type: `integer`):

Hard cap on listings pushed to the dataset (1–5000). Charged per listing at $0.005. Defaults to 100 (= $0.50). NOT a soft target — actor stops exactly at this number.

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

Lowest acceptable list price in USD. Applied to Zillow's price filter. Defaults to no minimum. NOT applied if searchUrl already encodes a price filter.

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

Highest acceptable list price in USD. Applied to Zillow's price filter. Defaults to no maximum. NOT applied if searchUrl already encodes a price filter.

## `minBeds` (type: `integer`):

Minimum bedroom count (0–10). Applied to Zillow's beds filter. Defaults to 0. NOT applied if searchUrl already encodes a beds filter.

## `minBaths` (type: `integer`):

Minimum bathroom count (0–10). Applied to Zillow's baths filter. Defaults to 0. NOT applied if searchUrl already encodes a baths filter.

## `homeType` (type: `array`):

Restrict to specific property types (houses, condos, townhomes, multi-family, manufactured, land, apartments). Empty = all types. NOT applied if searchUrl already encodes a type filter.

## `bypassPagination` (type: `boolean`):

Zillow caps each search at 800 listings. By default the actor recursively subdivides the map until all listings are retrieved. Set true to disable subdivision (faster but capped at 800). Defaults to false.

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

Apify Proxy configuration. Defaults to RESIDENTIAL US (required to bypass Zillow's PerimeterX). Override only if you know your own proxy bypasses Zillow.

## Actor input object example

```json
{
  "searchUrl": "https://www.zillow.com/austin-tx/houses/",
  "zipCodes": [
    "90210",
    "10001"
  ],
  "searchQuery": "Austin, TX",
  "mapBounds": {
    "north": 30.5,
    "south": 30.2,
    "east": -97.6,
    "west": -97.9
  },
  "listingType": "forSale",
  "maxResults": 100,
  "minPrice": 200000,
  "maxPrice": 2000000,
  "minBeds": 0,
  "minBaths": 0,
  "homeType": [],
  "bypassPagination": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# Actor output Schema

## `datasetItems` (type: `string`):

All scraped Zillow listings for this run.

## `runState` (type: `string`):

Persisted state for resume.

# 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 = {
    "listingType": "forSale",
    "maxResults": 100,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/zillow-search-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 = {
    "listingType": "forSale",
    "maxResults": 100,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "US",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/zillow-search-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 '{
  "listingType": "forSale",
  "maxResults": 100,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}' |
apify call khadinakbar/zillow-search-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Zillow Search Scraper",
        "description": "Bulk Zillow listings search by ZIP, city, search URL, or map bounding box. Auto-paginates past Zillow's 800-result cap. MCP-ready.",
        "version": "0.2",
        "x-build-id": "217jtSyWnkDqnpRBb"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/khadinakbar~zillow-search-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-khadinakbar-zillow-search-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/khadinakbar~zillow-search-scraper/runs": {
            "post": {
                "operationId": "runs-sync-khadinakbar-zillow-search-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/khadinakbar~zillow-search-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-khadinakbar-zillow-search-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": {
                    "searchUrl": {
                        "title": "Zillow search URL",
                        "type": "string",
                        "description": "Paste any Zillow search URL (e.g. https://www.zillow.com/austin-tx/houses/). The actor extracts the embedded searchQueryState JSON and scrapes that exact search. Use this when you already crafted filters in the Zillow UI. NOT a single property detail page — use the zillow-all-in-one-scraper actor for that."
                    },
                    "zipCodes": {
                        "title": "ZIP codes (US)",
                        "type": "array",
                        "description": "List of US ZIP codes to scrape (e.g. ['90210', '10001']). Each ZIP is scraped independently. Use this for bulk market scans by postal area. NOT for international postal codes — only US Zillow markets are supported.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchQuery": {
                        "title": "Search query (city, state, neighborhood)",
                        "type": "string",
                        "description": "Free-text city/state/neighborhood lookup (e.g. 'Austin, TX' or 'Brooklyn, NY'). Zillow's geocoder resolves this to a region. Defaults to 'Austin, TX' when no other input is given. NOT a property address — use a full search URL for granular targeting."
                    },
                    "mapBounds": {
                        "title": "Map bounding box (lat/lon)",
                        "type": "object",
                        "description": "Programmatic bounding-box search for AI agents. Provide { north, south, east, west } as decimal degrees. Use this when you have an exact polygon (drawn map, MLS export, etc). NOT used when searchUrl/zipCodes/searchQuery is set."
                    },
                    "listingType": {
                        "title": "Listing type",
                        "enum": [
                            "forSale",
                            "forRent",
                            "sold"
                        ],
                        "type": "string",
                        "description": "Which Zillow inventory to scrape. 'forSale' covers active for-sale listings. 'forRent' covers active rentals. 'sold' covers recently sold homes. Defaults to 'forSale'. NOT a mix — pick one per run.",
                        "default": "forSale"
                    },
                    "maxResults": {
                        "title": "Max results per run",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Hard cap on listings pushed to the dataset (1–5000). Charged per listing at $0.005. Defaults to 100 (= $0.50). NOT a soft target — actor stops exactly at this number.",
                        "default": 100
                    },
                    "minPrice": {
                        "title": "Min price (USD)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Lowest acceptable list price in USD. Applied to Zillow's price filter. Defaults to no minimum. NOT applied if searchUrl already encodes a price filter."
                    },
                    "maxPrice": {
                        "title": "Max price (USD)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Highest acceptable list price in USD. Applied to Zillow's price filter. Defaults to no maximum. NOT applied if searchUrl already encodes a price filter."
                    },
                    "minBeds": {
                        "title": "Min bedrooms",
                        "minimum": 0,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Minimum bedroom count (0–10). Applied to Zillow's beds filter. Defaults to 0. NOT applied if searchUrl already encodes a beds filter.",
                        "default": 0
                    },
                    "minBaths": {
                        "title": "Min bathrooms",
                        "minimum": 0,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Minimum bathroom count (0–10). Applied to Zillow's baths filter. Defaults to 0. NOT applied if searchUrl already encodes a baths filter.",
                        "default": 0
                    },
                    "homeType": {
                        "title": "Home type",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Restrict to specific property types (houses, condos, townhomes, multi-family, manufactured, land, apartments). Empty = all types. NOT applied if searchUrl already encodes a type filter.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "houses",
                                "condos",
                                "townhomes",
                                "multifamily",
                                "manufactured",
                                "land",
                                "apartments"
                            ]
                        },
                        "default": []
                    },
                    "bypassPagination": {
                        "title": "Skip subdivision past 800 cap",
                        "type": "boolean",
                        "description": "Zillow caps each search at 800 listings. By default the actor recursively subdivides the map until all listings are retrieved. Set true to disable subdivision (faster but capped at 800). Defaults to false.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy",
                        "type": "object",
                        "description": "Apify Proxy configuration. Defaults to RESIDENTIAL US (required to bypass Zillow's PerimeterX). Override only if you know your own proxy bypasses Zillow.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ],
                            "apifyProxyCountry": "US"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
