# Zillow Scraper (`reefapi/zillow-scraper`) Actor

Scrape Zillow real-estate listings as clean JSON — search homes for sale, for rent and recently sold by location, map bounds or a Zillow search URL. Get price, beds, baths, sqft, lot size, address, coordinates, Zestimate, photos, days-on-market and broker. No proxies, no CAPTCHAs, no login.

- **URL**: https://apify.com/reefapi/zillow-scraper.md
- **Developed by:** [ReefAPI](https://apify.com/reefapi) (community)
- **Categories:** Real estate, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-usage

## 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 Scraper — Search Homes for Sale, Rent & Sold as JSON

> 📮 **Need help, hit a problem, want a new feature, or a field that's missing from the output?** Email **support@reefapi.com** or open an issue on the **Issues** tab of this Actor — we reply fast and take feature requests seriously.

Scrape **Zillow real-estate listings** as clean, structured JSON. Search homes **for sale, for rent and recently sold** by location, map bounds or a **Zillow search URL**, with full filters — price, beds, baths, sqft, lot size, home type, year built, HOA, days-on-market and keywords. Every listing comes back with price, **Zestimate**, beds/baths/sqft, address, coordinates, broker and photos. **No proxies, no CAPTCHAs, no login, no daily call limits** — just send a location and get the data.

### What is the Zillow Scraper?

The Zillow Scraper is a fast, no-code **Zillow data API** that turns any Zillow search into a downloadable dataset. Instead of copy-pasting listings by hand or fighting bot walls, you send a location (or a Zillow URL, or a map bounding box) and get back every matching property as flat JSON, CSV or Excel. It's the easiest way to **scrape Zillow** listings for real-estate lead lists, market research, comps and property-tech products — whether you want to **search Zillow homes for sale**, pull **for-rent** inventory, or collect **recently sold** history. Point it at a city, ZIP, neighborhood or county and it handles paging, filters and the ~860-result cap for you.

### What can this Zillow Scraper do?

- 🔎 **Search listings** — for-sale / for-rent / sold homes in any city, ZIP, neighborhood or county, with 15+ filters.
- 🔗 **Search by Zillow URL** — paste a Zillow results URL (`?searchQueryState=...`) and replay it exactly.
- 🗺️ **Search by map bounds** — pass a lat/long bounding box for precise map-area coverage.
- 🏷️ **Recently sold** — sold listings with sale price (where the state discloses it) and sold date.
- 💬 **Location autocomplete** — turn partial text (`"austi"`) into Zillow regions.
- 🔓 **Bypass the ~860 cap** — set `fetch_all: true` to subdivide dense areas and return **every** listing.
- 💵 **Rich fields per home** — list price, Zestimate, rent Zestimate, tax-assessed value, beds/baths/sqft, lot size, days-on-market, broker and photos.

### 🔓 Beyond the ~860-result cap

Zillow caps a normal search at roughly 860 results. Set **`fetch_all: true`** and the scraper subdivides dense areas to return **every** listing in the region — ideal for full-market pulls, investor lead lists and complete inventory snapshots. It's slower but complete; combine it with **Max results** to control run size.

### What data can I extract?

Each listing is returned as a flat record. Key fields (real output shown below):

| Field | What it is |
|---|---|
| `zpid` | Zillow property id (stable key for a home) |
| `url` | Direct link to the Zillow listing page |
| `list_price_usd` / `price_display` | Numeric list price + formatted string (`$750,000`) |
| `status` / `status_text` | `FOR_SALE` / `FOR_RENT` / `SOLD` + human status (`Active`) |
| `property_type` | `SINGLE_FAMILY`, `CONDO`, `TOWNHOUSE`, `MULTI_FAMILY`, `LAND`, … |
| `beds` / `baths` | Bedroom and bathroom counts |
| `sqft` / `lot_sqft` | Living area and lot size in square feet |
| `zestimate_usd` | Zillow's estimated market value (when published) |
| `rent_zestimate_usd` | Estimated monthly rent (when published) |
| `tax_assessed_value_usd` | Tax-assessed value |
| `days_on_market` | Days the listing has been live |
| `address_line` / `address` | Street line + full formatted address |
| `city` / `state_code` / `postal_code` | Location breakdown |
| `latitude` / `longitude` | Exact coordinates for mapping |
| `broker_name` | Listing brokerage |
| `is_showcase` | Whether it's a Zillow Showcase listing |
| `photos` | Array of listing photo URLs |

> Field availability can vary — Zillow doesn't publish a Zestimate, rent Zestimate or tax value for every home, and can change its page structure at any time. Core fields (price, address, beds/baths/sqft, coordinates, URL) are always present.

### How do I scrape Zillow?

1. Open the Actor and go to the **Input** tab.
2. Pick an **Action** (Search listings is the default).
3. Type a **Location** (e.g. `Austin, TX`), choose **Listing status**, and add any filters (price, beds, baths, home type, days-on-market, keywords).
4. Optionally tick **Fetch ALL listings** to go beyond the ~860 cap, and set **Max results**.
5. Click **Start**. When the run finishes, download the results as **JSON, CSV, Excel or HTML** from the **Dataset** tab, or pull them via the Apify API.

### Input

```json
{
  "action": "search",
  "location": "Austin, TX",
  "status": "for_sale",
  "price_max": 700000,
  "beds_min": 3,
  "max_results": 200
}
````

- `location` — city / ZIP / neighborhood / county (search & sold).
- `status` — `for_sale` · `for_rent` · `sold`.
- `fetch_all` — bypass the ~860 cap (slower, complete).
- `price_min` / `price_max`, `beds_min`, `baths_min`, `home_type`, `days_on_max`, `keywords`.
- `url` — for **Search by Zillow URL**; `map_bounds` — `{north, south, east, west}` for **Search by map bounds**.
- `query` — for **Location autocomplete**.
- `params` — advanced JSON: `sqft_min/max`, `lot_min/max`, `year_built_min/max`, `max_hoa`, `max_pages`, …

### Output

Real response (trimmed to one representative listing):

```json
{
  "zpid": 337141915,
  "source": "zillow",
  "url": "https://www.zillow.com/homedetails/4907-Watusi-Bnd-2-Austin-TX-78732/337141915_zpid/",
  "list_price_usd": 750000.0,
  "price_display": "$750,000",
  "status": "FOR_SALE",
  "status_text": "Active",
  "property_type": "SINGLE_FAMILY",
  "beds": 4.0,
  "baths": 3.0,
  "sqft": 2586.0,
  "lot_sqft": 24668.03,
  "zestimate_usd": null,
  "rent_zestimate_usd": null,
  "tax_assessed_value_usd": 732733.0,
  "days_on_market": 8,
  "address_line": "4907 Watusi Bnd #2",
  "city": "Austin",
  "state_code": "TX",
  "postal_code": "78732",
  "address": "4907 Watusi Bnd #2, Austin, TX 78732",
  "latitude": 30.388262,
  "longitude": -97.8774,
  "broker_name": "Keller Williams Realty",
  "is_showcase": true,
  "photos": ["https://photos.zillowstatic.com/fp/a8b0cc525925715ca3b3eac45a19ca60-p_e.jpg"]
}
```

### Use cases

- **Real-estate lead lists** — build buyer / seller / investor pipelines by area and filters.
- **Market analysis & comps** — pull for-sale + sold inventory to model pricing per ZIP.
- **Property tech & portals** — power search, map and listing features with fresh data.
- **Investment screening** — filter by price, Zestimate, rent Zestimate and days-on-market.
- **Rental market research** — track for-rent inventory, rent Zestimates and availability.
- **Full-market snapshots** — use `fetch_all` to capture every listing in a metro for a point-in-time dataset.

### FAQ

**Is there an official Zillow API?**
Zillow retired most of its public listing APIs, and the remaining partner programs are limited and gated. This Actor is the practical way to get Zillow search data as structured JSON without a partnership.

**Why scrape Zillow?**
Zillow is the largest US real-estate marketplace. Its listing, price, Zestimate and sold data powers lead generation, comps, valuation models, market dashboards and property-tech products — none of which you can get in bulk through the front end.

**How much does it cost?**
This Actor runs on Apify's pay-as-you-go model — you're billed for what you use (benchmarked to be competitive with other Zillow scrapers). See the **Pricing** section on this Actor's page for the current rate.

**Can I integrate it with my app or spreadsheet?**
Yes. Run it from the Apify **API** or the official **Python / Node.js clients**, schedule it, and connect the output to **Make, Zapier, n8n, Google Sheets, Slack, webhooks** or your database via Apify integrations.

**Is it legal to scrape Zillow?**
Scraping publicly available data is generally lawful, and this Actor only reads public listing pages (no login, no personal accounts). Listing data can include agent/broker names — treat any personal data responsibly and in line with GDPR/CCPA. This is not legal advice; if in doubt, consult a lawyer.

***

Unofficial — not affiliated with Zillow. Public data only.

# Actor input Schema

## `action` (type: `string`):

What to run: search listings, replay a Zillow URL, search by map bounds, recently-sold, or location autocomplete.

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

Where to search — city, ZIP, neighborhood or county. e.g. 'Austin, TX', '78704', 'Brooklyn, NY'. (search / sold)

## `status` (type: `string`):

Which listings to return.

## `url` (type: `string`):

A Zillow search-results URL (with ?searchQueryState=...) or a property URL to replay. Used by the 'Search by Zillow URL' action.

## `map_bounds` (type: `object`):

Bounding box for a map search: {"north":.., "south":.., "east":.., "west":..}. Used by 'Search by map bounds'.

## `query` (type: `string`):

Partial location text for the 'Location autocomplete' action. e.g. 'austi'.

## `fetch_all` (type: `boolean`):

Return EVERY listing in the area by subdividing dense zones — goes beyond Zillow's standard ~860-result cap. Slower; combine with Max results.

## `max_results` (type: `integer`):

Stop after this many listings (a single page ~41 is always returned in full).

## `price_min` (type: `integer`):

Minimum list price.

## `price_max` (type: `integer`):

Maximum list price.

## `beds_min` (type: `integer`):

Minimum bedrooms (3 = 3+).

## `baths_min` (type: `integer`):

Minimum bathrooms (2 = 2+).

## `home_type` (type: `string`):

Property type(s), comma-separated: house, condo, townhouse, multi\_family, land, manufactured, apartment.

## `days_on_max` (type: `integer`):

Only listings live at most this many days (7 = new this week).

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

Free-text listing filter, e.g. 'pool', 'waterfront', 'guest house'.

## `params` (type: `object`):

Any extra parameters as key/value JSON (sqft\_min/max, lot\_min/max, year\_built\_min/max, max\_hoa, max\_pages, …). Merged into the request.

## Actor input object example

```json
{
  "action": "search",
  "location": "Austin, TX",
  "status": "for_sale",
  "fetch_all": false,
  "max_results": 200
}
```

# Actor output Schema

## `listings` (type: `string`):

The Zillow listings scraped (one item per property).

# 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 = {
    "location": "Austin, TX",
    "max_results": 200
};

// Run the Actor and wait for it to finish
const run = await client.actor("reefapi/zillow-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 = {
    "location": "Austin, TX",
    "max_results": 200,
}

# Run the Actor and wait for it to finish
run = client.actor("reefapi/zillow-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 '{
  "location": "Austin, TX",
  "max_results": 200
}' |
apify call reefapi/zillow-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Zillow Scraper",
        "description": "Scrape Zillow real-estate listings as clean JSON — search homes for sale, for rent and recently sold by location, map bounds or a Zillow search URL. Get price, beds, baths, sqft, lot size, address, coordinates, Zestimate, photos, days-on-market and broker. No proxies, no CAPTCHAs, no login.",
        "version": "0.1",
        "x-build-id": "onCjEj9l1cTp1jCGs"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/reefapi~zillow-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-reefapi-zillow-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/reefapi~zillow-scraper/runs": {
            "post": {
                "operationId": "runs-sync-reefapi-zillow-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/reefapi~zillow-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-reefapi-zillow-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": {
                    "action": {
                        "title": "Action",
                        "enum": [
                            "search",
                            "search_by_url",
                            "search_by_coordinates",
                            "sold",
                            "autocomplete"
                        ],
                        "type": "string",
                        "description": "What to run: search listings, replay a Zillow URL, search by map bounds, recently-sold, or location autocomplete.",
                        "default": "search"
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Where to search — city, ZIP, neighborhood or county. e.g. 'Austin, TX', '78704', 'Brooklyn, NY'. (search / sold)"
                    },
                    "status": {
                        "title": "Listing status",
                        "enum": [
                            "for_sale",
                            "for_rent",
                            "sold"
                        ],
                        "type": "string",
                        "description": "Which listings to return.",
                        "default": "for_sale"
                    },
                    "url": {
                        "title": "Zillow URL (search_by_url)",
                        "type": "string",
                        "description": "A Zillow search-results URL (with ?searchQueryState=...) or a property URL to replay. Used by the 'Search by Zillow URL' action."
                    },
                    "map_bounds": {
                        "title": "Map bounds (search_by_coordinates)",
                        "type": "object",
                        "description": "Bounding box for a map search: {\"north\":.., \"south\":.., \"east\":.., \"west\":..}. Used by 'Search by map bounds'."
                    },
                    "query": {
                        "title": "Query (autocomplete)",
                        "type": "string",
                        "description": "Partial location text for the 'Location autocomplete' action. e.g. 'austi'."
                    },
                    "fetch_all": {
                        "title": "Fetch ALL listings (bypass ~860 cap)",
                        "type": "boolean",
                        "description": "Return EVERY listing in the area by subdividing dense zones — goes beyond Zillow's standard ~860-result cap. Slower; combine with Max results.",
                        "default": false
                    },
                    "max_results": {
                        "title": "Max results",
                        "type": "integer",
                        "description": "Stop after this many listings (a single page ~41 is always returned in full)."
                    },
                    "price_min": {
                        "title": "Min price (USD)",
                        "type": "integer",
                        "description": "Minimum list price."
                    },
                    "price_max": {
                        "title": "Max price (USD)",
                        "type": "integer",
                        "description": "Maximum list price."
                    },
                    "beds_min": {
                        "title": "Min beds",
                        "type": "integer",
                        "description": "Minimum bedrooms (3 = 3+)."
                    },
                    "baths_min": {
                        "title": "Min baths",
                        "type": "integer",
                        "description": "Minimum bathrooms (2 = 2+)."
                    },
                    "home_type": {
                        "title": "Home type",
                        "type": "string",
                        "description": "Property type(s), comma-separated: house, condo, townhouse, multi_family, land, manufactured, apartment."
                    },
                    "days_on_max": {
                        "title": "Max days on Zillow",
                        "type": "integer",
                        "description": "Only listings live at most this many days (7 = new this week)."
                    },
                    "keywords": {
                        "title": "Keywords",
                        "type": "string",
                        "description": "Free-text listing filter, e.g. 'pool', 'waterfront', 'guest house'."
                    },
                    "params": {
                        "title": "Advanced parameters",
                        "type": "object",
                        "description": "Any extra parameters as key/value JSON (sqft_min/max, lot_min/max, year_built_min/max, max_hoa, max_pages, …). Merged into the request."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
