# Redfin Scraper — Real-Estate Listings & Sold Data (`freshactors/redfin-scraper`) Actor

Reliable, always-fresh Redfin listings: price, beds/baths, sqft, address, lat/long, MLS ID, and more. Paste a Redfin city/zip URL. By FreshActors.

- **URL**: https://apify.com/freshactors/redfin-scraper.md
- **Developed by:** [Martin Čech](https://apify.com/freshactors) (community)
- **Categories:** Developer tools, Real estate, E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

$2.00 / 1,000 listing fetcheds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## Redfin (US Real Estate) Scraper — Listings, Sold Data & Property API

Scrape **Redfin (US real estate)** listings into clean, structured JSON — price, beds, baths, square footage, address, lat/long, MLS ID, property type, days-on-market and more — straight from a Redfin city or ZIP URL. No account, no login, no API key.

![Redfin Scraper example output — 28 fields per listing](https://raw.githubusercontent.com/Freshactors/freshactors-assets/main/redfin-screenshot.png)

> ✅ **Last verified working: 2026-06-01.** Monitored by an automated daily canary. When Redfin changes something, we patch fast and log it in the changelog below.

---

### Why this Redfin (US real estate) scraper

Most Redfin scrapers on the store are abandoned — stale code, a handful of users, low ratings — and they break the moment Redfin tweaks its internal data API. This one is **maintained, monitored, and built to stay working**:

- **A daily canary runs the actor against live Redfin** and alerts us the moment a field drifts or a block pattern changes. That's the "always-fresh" promise — and why the "Last verified working" badge above is a real date, not marketing.
- **Block-resistant by design.** Redfin's GIS data API returns a "Success" envelope *even when it's bot-blocked*, which is how naive scrapers silently return zero rows. This actor distinguishes a genuine zero-result from a soft block and **retries with backoff + IP rotation** instead of handing you an empty dataset.
- **Paste-a-URL simplicity.** Give it a Redfin city, ZIP, county or neighborhood URL — the region is parsed straight from the URL. No hunting for internal Redfin region IDs.
- **Stable, versioned output** (`_schemaVersion`). Fields don't silently disappear between runs; schema changes are logged.
- **Fast patches.** Open an issue and it gets answered. Reliability is the entire product.

If you've been burned by a "Redfin API" actor that returns nothing on a Monday morning, this is the fix.

### What data you get

Each row is one property listing. Real fields emitted by the actor:

| Field | Type | Description |
|---|---|---|
| `listingId` | number | Redfin internal listing ID |
| `propertyId` | number | Redfin internal property ID |
| `mlsId` | string | MLS number for the listing |
| `mlsStatus` | string | MLS status (e.g. Active, Sold) |
| `address` | string | Street line |
| `unit` | string | Unit / apartment number (if any) |
| `city` | string | City |
| `state` | string | US state code |
| `zip` | string | ZIP code |
| `price` | number | List price (or sold price) in USD |
| `hoa` | number | Monthly HOA dues, if reported |
| `beds` | number | Bedrooms |
| `baths` | number | Bathrooms |
| `sqft` | number | Interior square footage |
| `lotSize` | number | Lot size |
| `pricePerSqFt` | number | Price per square foot |
| `yearBuilt` | number | Year built |
| `propertyType` | string | e.g. Single Family Residential, Condo/Co-op, Townhouse |
| `latitude` | number | Latitude |
| `longitude` | number | Longitude |
| `daysOnMarket` | number | Days on Redfin |
| `soldDate` | string | ISO date (sold listings) |
| `listingType` | string | Listing type flag from Redfin |
| `url` | string | Canonical Redfin listing URL |
| `_schemaVersion` | string | Output schema version |
| `_scrapedAt` | string | ISO timestamp of the scrape |

**Two modes**, set with `listingType`:

- `forSale` — active for-sale listings (default).
- `sold` — recently sold homes (includes `soldDate`), for comps and sold-price analysis.

You can also choose the **sort order** (Redfin-recommended, price asc/desc, days-on-market asc/desc, or square-footage desc) and scrape **multiple regions in a single run**.

### Use cases

- **Real-estate investors & flippers** building a deal pipeline. Search intent: *"Redfin scraper", "scrape Redfin listings", "Redfin sold data export"*. Pull all for-sale homes in a metro, filter by `pricePerSqFt` and `daysOnMarket`, and surface underpriced inventory.
- **Proptech & CMA tools** needing a **Redfin API** alternative. Search intent: *"Redfin API", "Redfin data API no key"*. Feed `sold` listings with `soldDate` and `price` into your comparative-market-analysis or AVM model.
- **Data & analytics teams** doing market research. Search intent: *"how to scrape Redfin", "Redfin real estate data to CSV/JSON"*. Track median price, inventory and days-on-market across cities over time via scheduled runs.
- **Lead-gen & local agents** monitoring a farm area. Search intent: *"Redfin listings scraper by ZIP"*. Watch a ZIP or neighborhood for new or price-dropped listings and trigger outreach.

### Input

| Field | Type | Notes |
|---|---|---|
| `redfinUrls` | string[] | Redfin city / ZIP / county / neighborhood URLs. The region is read from the URL. |
| `regions` | object[] | Advanced alternative: `{ "region_id": "30818", "region_type": 6 }` (6=city, 2=zip, 5=county, 1=neighborhood). |
| `listingType` | string | `forSale` (default) or `sold`. |
| `sort` | string | `redfin-recommended-asc`, `price-asc`, `price-desc`, `days-on-redfin-asc`, `days-on-redfin-desc`, `square-footage-desc`. |
| `maxListings` | int | Cap total listings across all regions. Default `1000`, max `17500`. |
| `numHomesPerPage` | int | Advanced — listings per request page. Default `350`. Leave at default. |

**For-sale by URL:**

```json
{
  "redfinUrls": ["https://www.redfin.com/city/30818/TX/Austin"],
  "listingType": "forSale",
  "sort": "price-desc",
  "maxListings": 500
}
````

**Sold comps by ZIP, using the advanced `regions` input:**

```json
{
  "regions": [{ "region_id": "78701", "region_type": 2 }],
  "listingType": "sold",
  "sort": "days-on-redfin-asc",
  "maxListings": 250
}
```

### Output sample

```json
{
  "_type": "listing",
  "_schemaVersion": "1.0",
  "listingId": 216197035,
  "propertyId": 31845362,
  "mlsId": "2116358131372161577",
  "mlsStatus": "Active",
  "address": "4602 Indian Wells Dr",
  "unit": null,
  "city": "Austin",
  "state": "TX",
  "zip": "78747",
  "price": 560000,
  "hoa": 45,
  "beds": 3,
  "baths": 2,
  "sqft": 2097,
  "lotSize": 7405,
  "pricePerSqFt": 267,
  "yearBuilt": 2019,
  "propertyType": "Single Family Residential",
  "latitude": 30.1327479,
  "longitude": -97.79,
  "daysOnMarket": 12,
  "soldDate": null,
  "listingType": null,
  "url": "https://www.redfin.com/TX/Austin/4602-Indian-Wells-Dr-78747/home/31845362",
  "_scrapedAt": "2026-06-01T08:08:20.543Z"
}
```

### Pricing

Pay-per-result, no subscription. You're charged **$0.002 per listing returned** (the `listing-fetched` event) — that's it. You only pay for rows that actually land in your dataset.

**How much does 100 results cost?** 100 × $0.002 = **$0.20**.

A few more reference points:

- 500 listings → **$1.00**
- 1,000 listings → **$2.00**
- 10,000 listings → **$20.00**

Set `maxListings` to keep any single run within your budget.

### FAQ

**Is scraping Redfin (US real estate) legal?**
This actor collects **publicly visible** listing data. Scraping public data is broadly permitted in many jurisdictions, but you're responsible for complying with Redfin's terms and applicable laws. Note that some MLS listings are excluded from Redfin's public data per local MLS rules — Redfin itself flags this — so those won't appear.

**Do I need an API key or a Redfin account?**
No. There's no Redfin account, login or API key. You paste a Redfin URL (or region IDs) and run the actor.

**Is there an official Redfin API?**
Redfin doesn't offer a public listings API. This actor is the practical substitute: structured JSON with the fields most people want, callable from the Apify API/SDK.

**How do I get sold listings instead of for-sale?**
Set `listingType` to `sold`. Sold rows include a `soldDate` field, which is what you want for comps and sold-price trends.

**How do I scrape a specific city or ZIP?**
Paste the Redfin URL for it — e.g. `https://www.redfin.com/city/30818/TX/Austin` or `https://www.redfin.com/zipcode/78701`. The region is parsed from the URL automatically. For programmatic control, use the advanced `regions` input with `region_id` + `region_type`.

**How many listings can I get per run?**
Up to `maxListings`, which defaults to 1,000 and can go up to 17,500. You can also include multiple URLs/regions in one run; the cap applies across all of them.

**How often is the data updated?**
The actor reads **live** from Redfin every time you run it, so data is as fresh as Redfin's own site at run time. Schedule runs (hourly/daily) for ongoing monitoring.

**Why do some scrapers return zero results — does this one?**
Redfin's data endpoint returns a "Success" envelope even when it's quietly blocking bots, so naive scrapers return empty datasets. This actor detects that soft-block pattern and retries with backoff and IP rotation, so a real zero-result is distinguished from a block.

**What's the difference between `redfinUrls` and `regions`?**
`redfinUrls` is the easy path — paste any Redfin region page URL. `regions` is the advanced path for when you already know Redfin's internal `region_id` and `region_type` and want to script them directly.

**Can I export to CSV or Excel?**
Yes. Results go to a standard Apify dataset, which you can export as JSON, CSV, Excel, or HTML, or pull via the API.

### Other FreshActors tools

| FreshActors actor | What it scrapes |
|---|---|
| [App Store Scraper](https://apify.com/freshactors/app-store-scraper) | Apple App Store — app details, search, reviews |
| [Google Play Scraper](https://apify.com/freshactors/google-play-scraper) | Google Play — app details + reviews |
| [Shopify App Store Scraper](https://apify.com/freshactors/shopify-app-store-scraper) | Shopify App Store — app details, reviews, discovery |
| [Redfin Scraper](https://apify.com/freshactors/redfin-scraper) | Redfin — US real-estate listings |
| [Greenhouse & Lever Jobs Scraper](https://apify.com/freshactors/greenhouse-lever-jobs-scraper) | Greenhouse + Lever — normalized job postings |

### Reliability

A scheduled **daily canary** runs this actor against live Redfin and checks that listings still parse and the expected fields are present. When Redfin changes its data API or block behavior, we patch quickly and record it in the changelog below, then bump the "Last verified working" date at the top. That feedback loop — *monitor, detect, patch, log* — is the whole point of FreshActors: an actor you can build a pipeline on without it quietly going stale.

**Changelog**

- **2026-06-01** — v1.0 launch. For-sale + sold listings, URL-based region resolution, block-aware retry engine, daily canary monitoring.

**Legal note.** This actor scrapes **public** real-estate listing data. Some MLS listings are excluded per local MLS rules. Use the data responsibly and in line with Redfin's terms and applicable laws.

*Found a problem? Open an issue — answered fast. Staying fresh is the whole point.*

# Actor input Schema

## `redfinUrls` (type: `array`):

Paste Redfin search/city/zip URLs, e.g. https://www.redfin.com/city/30818/TX/Austin or https://www.redfin.com/zipcode/78701. The region is read from the URL.

## `regions` (type: `array`):

Alternative to URLs: objects like { "region\_id": "30818", "region\_type": 6 } (6=city, 2=zip, 5=county, 1=neighborhood).

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

Scrape active for-sale listings or recently sold homes.

## `sort` (type: `string`):

Order in which listings are returned.

## `maxListings` (type: `integer`):

Cap total listings returned across all regions.

## `numHomesPerPage` (type: `integer`):

Listings fetched per request page (advanced; leave at default).

## Actor input object example

```json
{
  "redfinUrls": [
    "https://www.redfin.com/city/30818/TX/Austin"
  ],
  "listingType": "forSale",
  "sort": "redfin-recommended-asc",
  "maxListings": 1000,
  "numHomesPerPage": 350
}
```

# Actor output Schema

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

Real-estate listings with price, beds/baths, sqft, address, and more.

# 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 = {
    "redfinUrls": [
        "https://www.redfin.com/city/30818/TX/Austin"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("freshactors/redfin-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 = { "redfinUrls": ["https://www.redfin.com/city/30818/TX/Austin"] }

# Run the Actor and wait for it to finish
run = client.actor("freshactors/redfin-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 '{
  "redfinUrls": [
    "https://www.redfin.com/city/30818/TX/Austin"
  ]
}' |
apify call freshactors/redfin-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Redfin Scraper — Real-Estate Listings & Sold Data",
        "description": "Reliable, always-fresh Redfin listings: price, beds/baths, sqft, address, lat/long, MLS ID, and more. Paste a Redfin city/zip URL. By FreshActors.",
        "version": "1.0",
        "x-build-id": "Tm5b9cPMpYAyDUe15"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/freshactors~redfin-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-freshactors-redfin-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/freshactors~redfin-scraper/runs": {
            "post": {
                "operationId": "runs-sync-freshactors-redfin-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/freshactors~redfin-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-freshactors-redfin-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": {
                    "redfinUrls": {
                        "title": "Redfin URLs",
                        "type": "array",
                        "description": "Paste Redfin search/city/zip URLs, e.g. https://www.redfin.com/city/30818/TX/Austin or https://www.redfin.com/zipcode/78701. The region is read from the URL.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "regions": {
                        "title": "Regions (advanced)",
                        "type": "array",
                        "description": "Alternative to URLs: objects like { \"region_id\": \"30818\", \"region_type\": 6 } (6=city, 2=zip, 5=county, 1=neighborhood)."
                    },
                    "listingType": {
                        "title": "Listing type",
                        "enum": [
                            "forSale",
                            "sold"
                        ],
                        "type": "string",
                        "description": "Scrape active for-sale listings or recently sold homes.",
                        "default": "forSale"
                    },
                    "sort": {
                        "title": "Sort order",
                        "enum": [
                            "redfin-recommended-asc",
                            "price-asc",
                            "price-desc",
                            "days-on-redfin-asc",
                            "days-on-redfin-desc",
                            "square-footage-desc"
                        ],
                        "type": "string",
                        "description": "Order in which listings are returned.",
                        "default": "redfin-recommended-asc"
                    },
                    "maxListings": {
                        "title": "Max listings",
                        "minimum": 1,
                        "maximum": 17500,
                        "type": "integer",
                        "description": "Cap total listings returned across all regions.",
                        "default": 1000
                    },
                    "numHomesPerPage": {
                        "title": "Homes per page (advanced)",
                        "minimum": 1,
                        "maximum": 350,
                        "type": "integer",
                        "description": "Listings fetched per request page (advanced; leave at default).",
                        "default": 350
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
