# Redfin Property Scraper - Homes for Sale, Rent, and Sold Data (`cirkit/redfin-property-scraper`) Actor

Fast, low-cost Redfin scraper for homes for sale, rentals, sold, coming-soon, and pending listings. Returns 50+ fields per home (price, beds, baths, sqft, lat/long, photos, MLS, key facts) with rich filters. 350 results per request.

- **URL**: https://apify.com/cirkit/redfin-property-scraper.md
- **Developed by:** [Crikit](https://apify.com/cirkit) (community)
- **Categories:** Real estate
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.35 / 1,000 results

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

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 Property Scraper

Redfin Property Scraper is a fast and low-cost Apify Actor that extracts complete property data from Redfin search results. The Actor returns homes for sale, recently sold properties, coming-soon homes, and pending sales for any U.S. city, county, zip code, or neighborhood. Each result includes 50+ property fields plus derived values like absolute home URL, full address, decoded photo CDN URLs, ISO sold dates, decoded property type and listing status, and arrays of key facts and listing sashes.

The Redfin Property Scraper is built directly on top of Redfin's own internal search API. It does not run a browser, does not execute JavaScript, and does not parse HTML. That makes it about 5 to 10 times cheaper than browser-based Redfin scrapers, while extracting more data per result and returning 350 properties per single request. The scraper paginates automatically up to the Redfin API ceiling and skips duplicate property IDs across pages and regions.

### Features

- Bulk scrape Redfin search results: 350 homes per request, up to several thousand per region
- Four listing modes: for sale, sold, coming soon, and pending
- Rich filters: price range, minimum beds, minimum baths, square footage range, year built range, property type, has garage
- Multiple input formats: paste a Redfin city or zip code URL, send a list of region IDs, or pass free-text locations like "Austin, TX"
- 50+ fields per property, plus derived/enriched values
- Decoded photo URLs that point to Redfin's high-quality CDN photos
- Stable, low-cost extraction: $0.00035 per Redfin property result with no per-run base fee

### Input

The Redfin Property Scraper accepts the following input parameters. The most common entrypoint is a list of Redfin search URLs.

#### Redfin search URLs

Pass any combination of the following Redfin URL types in the `searchUrls` field. Copy any URL straight from your browser's address bar after navigating to the area on redfin.com:

- City URLs: `https://www.redfin.com/city/30749/NY/New-York`
- Zip code URLs: `https://www.redfin.com/zipcode/10001`
- County URLs: `https://www.redfin.com/county/325/CA/Mendocino-County`
- Neighborhood URLs: `https://www.redfin.com/neighborhood/2657/CA/San-Francisco/Sunset-District`

You can also pass a 5-digit U.S. zip code as a free-text `searches` entry — for example `{ "searches": ["10001"] }`. For other free-text locations, copy the URL from redfin.com instead.

#### Filters

You can narrow results with the same filters Redfin offers in their UI:

- `listingType` - one of `forSale`, `sold`, `comingSoon`, `pending`
- `sortBy` - one of `redfinRecommended`, `newest`, `oldest`, `priceLow`, `priceHigh`, `sqftHigh`, `sqftLow`, `pricePerSqftLow`, `pricePerSqftHigh`
- `propertyTypes` - one or more of house, condo, townhouse, multi-family, land, mobile, co-op, other
- Price range, minimum beds, minimum baths, sqft range, year built range
- Has garage
- `soldWithinDays` for sold listings
- `maxItems` and `maxPagesPerRegion` to cap dataset size

#### Example input

```json
{
    "searchUrls": [
        { "url": "https://www.redfin.com/city/30749/NY/New-York" }
    ],
    "listingType": "forSale",
    "sortBy": "newest",
    "minPrice": 500000,
    "maxPrice": 2000000,
    "minBeds": 2,
    "maxItems": 1000
}
````

### Output

Each dataset record represents a single Redfin property. Below is a real, abbreviated record produced by the Redfin Property Scraper.

```json
{
    "propertyId": 56134321,
    "listingId": 215233237,
    "homeUrl": "https://www.redfin.com/NY/Staten-Island/51-Evans-St-10314/home/56134321",
    "mlsNumber": "2602640",
    "mlsStatus": "Active",
    "listingStatus": "Active",
    "listingTypeName": "For Sale",
    "propertyTypeName": "Single Family Home",
    "priceUsd": 889000,
    "pricePerSqFtUsd": 467,
    "sqFt": 1904,
    "lotSizeSqFt": 2600,
    "beds": 3,
    "baths": 2.5,
    "yearBuilt": 1980,
    "addressFull": "51 Evans St, Staten Island, NY 10314",
    "city": "Staten Island",
    "state": "NY",
    "zip": "10314",
    "latitude": 40.587424,
    "longitude": -74.1498772,
    "daysOnRedfin": 1,
    "isNewConstruction": false,
    "has3DTour": false,
    "keyFacts": ["2,600 sq ft lot", "Garage", "Built 1980"],
    "sashes": ["New"],
    "listingRemarks": "Welcome to 51 Evans Street...",
    "primaryPhotoUrl": "https://ssl.cdn-redfin.com/photo/187/bcsphoto/640/genBcs.2602640_0.webp",
    "photoUrls": ["https://ssl.cdn-redfin.com/photo/187/bcsphoto/640/genBcs.2602640_0.webp"]
}
```

Set `flattenFields: false` to receive the original Redfin object verbatim, or `includeRaw: true` to receive both the flattened record and the raw object nested under `raw`.

### Pricing

The Redfin Property Scraper uses pay-per-result pricing at **$0.00035 per Redfin property result**. There is no run start fee and no monthly base fee. You only pay for results actually delivered. Apify's discount tiers (Bronze, Silver, Gold, Platinum, Diamond) apply on top, so volume subscribers pay even less per result.

A 1,000 home extraction costs about **$0.35**. A 10,000 home extraction costs about **$3.50**. Compared with browser-based Redfin scrapers that often run 5-10x slower at similar or higher per-result pricing, the Redfin Property Scraper is the most cost effective way to scrape Redfin at scale.

### Use cases

The Redfin Property Scraper is built for:

- Real estate market analysis and competitive intelligence
- Comparative market analysis and comp generation for agents
- Lead generation for property investors and house flippers
- Building real estate aggregator websites or apps
- Tracking new listings and price changes by zip code
- Training real estate machine learning and AI models on accurate, structured U.S. property data
- Bulk data export for investment research, portfolio analysis, and market reporting

### Notes and limits

Redfin caps API responses at 350 results per request. The Redfin Property Scraper paginates through results automatically up to about 3,150 homes per region. For larger areas, split the search into smaller geographies (counties or zip codes) or supply multiple input URLs.

This Actor scrapes only publicly-available Redfin search data. It does not require login, cookies, or proxies (but Apify proxy is available for high-volume runs). Please respect Redfin's terms of service and use the data responsibly.

### Feedback and support

This scraper is actively maintained. Send feedback, feature requests, or report issues via the Apify console support channel.

# Actor input Schema

## `searchUrls` (type: `array`):

Redfin URLs for a city, zip code, county, or neighborhood. Each URL is scraped page by page (up to maxPagesPerRegion).

## `searches` (type: `array`):

Additional regions to scrape. Each item can be a 5-digit U.S. zip code string (e.g. "10001") or a structured object {regionId, regionType, market} where regionType is 6=city, 5=county, 2=zip, 1=neighborhood. For free-text city names, paste the Redfin URL into searchUrls instead.

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

Which listing status to scrape.

## `sortBy` (type: `string`):

Sort order for search results, applied via Redfin's 'ord' parameter.

## `propertyTypes` (type: `array`):

Filter listings to the selected property types.

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

Filter listings priced at or above this USD value.

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

Filter listings priced at or below this USD value.

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

Minimum number of bedrooms.

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

Minimum number of bathrooms.

## `minSqft` (type: `integer`):

Minimum livable square footage.

## `maxSqft` (type: `integer`):

Maximum livable square footage.

## `minYearBuilt` (type: `integer`):

Minimum year built.

## `maxYearBuilt` (type: `integer`):

Maximum year built.

## `hasGarage` (type: `boolean`):

Only homes that report a garage.

## `soldWithinDays` (type: `integer`):

Sold within N days (only when listingType=sold).

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

Hard cap across all regions combined.

## `maxPagesPerRegion` (type: `integer`):

Each page returns up to 350 homes. Redfin caps the API at ~3150 homes per region.

## `flattenFields` (type: `boolean`):

When true, returns a clean flat record with derived fields (homeUrl, priceUsd, photoUrls, etc.). When false, returns the raw Redfin object.

## `includePhotoUrls` (type: `boolean`):

Decode the compressed photos field into a list of full CDN URLs.

## `includeRaw` (type: `boolean`):

When true, attaches the original Redfin home object under raw.

## `proxy` (type: `object`):

Proxy configuration.

## Actor input object example

```json
{
  "searchUrls": [
    {
      "url": "https://www.redfin.com/city/30749/NY/New-York"
    }
  ],
  "searches": [],
  "listingType": "forSale",
  "sortBy": "redfinRecommended",
  "propertyTypes": [
    "house",
    "condo",
    "townhouse",
    "multiFamily",
    "land",
    "mobile",
    "coop",
    "other"
  ],
  "hasGarage": false,
  "maxItems": 50,
  "maxPagesPerRegion": 9,
  "flattenFields": true,
  "includePhotoUrls": true,
  "includeRaw": false,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": []
  }
}
```

# 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 = {
    "searchUrls": [
        {
            "url": "https://www.redfin.com/city/30749/NY/New-York"
        }
    ],
    "maxItems": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("cirkit/redfin-property-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 = {
    "searchUrls": [{ "url": "https://www.redfin.com/city/30749/NY/New-York" }],
    "maxItems": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("cirkit/redfin-property-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 '{
  "searchUrls": [
    {
      "url": "https://www.redfin.com/city/30749/NY/New-York"
    }
  ],
  "maxItems": 50
}' |
apify call cirkit/redfin-property-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Redfin Property Scraper - Homes for Sale, Rent, and Sold Data",
        "description": "Fast, low-cost Redfin scraper for homes for sale, rentals, sold, coming-soon, and pending listings. Returns 50+ fields per home (price, beds, baths, sqft, lat/long, photos, MLS, key facts) with rich filters. 350 results per request.",
        "version": "0.6",
        "x-build-id": "mRpm7f7tR4KUXZhLh"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/cirkit~redfin-property-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-cirkit-redfin-property-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/cirkit~redfin-property-scraper/runs": {
            "post": {
                "operationId": "runs-sync-cirkit-redfin-property-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/cirkit~redfin-property-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-cirkit-redfin-property-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": {
                    "searchUrls": {
                        "title": "Redfin search URLs",
                        "type": "array",
                        "description": "Redfin URLs for a city, zip code, county, or neighborhood. Each URL is scraped page by page (up to maxPagesPerRegion).",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "searches": {
                        "title": "Additional searches (optional)",
                        "type": "array",
                        "description": "Additional regions to scrape. Each item can be a 5-digit U.S. zip code string (e.g. \"10001\") or a structured object {regionId, regionType, market} where regionType is 6=city, 5=county, 2=zip, 1=neighborhood. For free-text city names, paste the Redfin URL into searchUrls instead.",
                        "default": []
                    },
                    "listingType": {
                        "title": "Listing type",
                        "enum": [
                            "forSale",
                            "sold",
                            "comingSoon",
                            "pending"
                        ],
                        "type": "string",
                        "description": "Which listing status to scrape.",
                        "default": "forSale"
                    },
                    "sortBy": {
                        "title": "Sort by",
                        "enum": [
                            "redfinRecommended",
                            "newest",
                            "oldest",
                            "priceLow",
                            "priceHigh",
                            "sqftHigh",
                            "sqftLow",
                            "pricePerSqftLow",
                            "pricePerSqftHigh"
                        ],
                        "type": "string",
                        "description": "Sort order for search results, applied via Redfin's 'ord' parameter.",
                        "default": "redfinRecommended"
                    },
                    "propertyTypes": {
                        "title": "Property types",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Filter listings to the selected property types.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "house",
                                "condo",
                                "townhouse",
                                "multiFamily",
                                "land",
                                "mobile",
                                "coop",
                                "other"
                            ],
                            "enumTitles": [
                                "House",
                                "Condo",
                                "Townhouse",
                                "Multi-family",
                                "Land",
                                "Mobile / Manufactured",
                                "Co-op",
                                "Other"
                            ]
                        },
                        "default": [
                            "house",
                            "condo",
                            "townhouse",
                            "multiFamily",
                            "land",
                            "mobile",
                            "coop",
                            "other"
                        ]
                    },
                    "minPrice": {
                        "title": "Minimum price (USD)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Filter listings priced at or above this USD value."
                    },
                    "maxPrice": {
                        "title": "Maximum price (USD)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Filter listings priced at or below this USD value."
                    },
                    "minBeds": {
                        "title": "Minimum beds",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum number of bedrooms."
                    },
                    "minBaths": {
                        "title": "Minimum baths",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum number of bathrooms."
                    },
                    "minSqft": {
                        "title": "Minimum sqft",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum livable square footage."
                    },
                    "maxSqft": {
                        "title": "Maximum sqft",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum livable square footage."
                    },
                    "minYearBuilt": {
                        "title": "Minimum year built",
                        "minimum": 1700,
                        "type": "integer",
                        "description": "Minimum year built."
                    },
                    "maxYearBuilt": {
                        "title": "Maximum year built",
                        "minimum": 1700,
                        "type": "integer",
                        "description": "Maximum year built."
                    },
                    "hasGarage": {
                        "title": "Has garage",
                        "type": "boolean",
                        "description": "Only homes that report a garage.",
                        "default": false
                    },
                    "soldWithinDays": {
                        "title": "Sold within N days (only when listingType=sold)",
                        "minimum": 1,
                        "maximum": 1825,
                        "type": "integer",
                        "description": "Sold within N days (only when listingType=sold)."
                    },
                    "maxItems": {
                        "title": "Maximum total items",
                        "minimum": 1,
                        "maximum": 250000,
                        "type": "integer",
                        "description": "Hard cap across all regions combined.",
                        "default": 1000
                    },
                    "maxPagesPerRegion": {
                        "title": "Maximum pages per region",
                        "minimum": 1,
                        "maximum": 30,
                        "type": "integer",
                        "description": "Each page returns up to 350 homes. Redfin caps the API at ~3150 homes per region.",
                        "default": 9
                    },
                    "flattenFields": {
                        "title": "Flatten and enrich fields",
                        "type": "boolean",
                        "description": "When true, returns a clean flat record with derived fields (homeUrl, priceUsd, photoUrls, etc.). When false, returns the raw Redfin object.",
                        "default": true
                    },
                    "includePhotoUrls": {
                        "title": "Include photo URLs",
                        "type": "boolean",
                        "description": "Decode the compressed photos field into a list of full CDN URLs.",
                        "default": true
                    },
                    "includeRaw": {
                        "title": "Include raw Redfin object",
                        "type": "boolean",
                        "description": "When true, attaches the original Redfin home object under raw.",
                        "default": false
                    },
                    "proxy": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy configuration.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": []
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
