# Cook County Assessor's Property Scraper (`parseforge/cookcountyassessor-scraper`) Actor

Get Cook County property information in minutes. Search by address, area, or property number and receive clear details on property value, sales history, and key home features. Perfect for buyers, investors, and analysts who need reliable data to compare properties and make smarter decisions quickly.

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

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

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

## 🏠 Cook County Assessor Property Scraper

Collect detailed Cook County property assessment data in minutes with no technical skills required. Search by PIN, address, township, or municipality to download assessed values, property details, sales history, and tax appeal records. Perfect for real estate investors, appraisers, property managers, and researchers who need comprehensive property information without browsing county websites manually.

> **The Cook County Assessor Scraper collects up to 1,000,000 property records with 20+ data fields including assessed values, physical characteristics, and sales history - all from official Cook County government records.**

### ✨ What Does It Do

- 📍 **Property Address and Location** - Find properties by street address to research listings, verify ownership, and compare neighborhood values with precise coordinates
- 🔑 **Property Index Number (PIN)** - Look up properties by their unique 14-digit PIN for official record identification and tax assessment tracking
- 💰 **Assessed Value and Market Estimate** - Access official tax assessments and estimated market values to benchmark property worth and evaluate tax liability
- 📏 **Building and Land Details** - Collect year built, square footage, bedrooms, bathrooms, construction quality, heating/cooling, and structural information for investment analysis
- 📊 **Year-by-Year Assessment History** - Track how assessments changed over time to identify trends, support appeals, and monitor property value shifts
- 🏘️ **Administrative and Geographic Data** - Get township, municipality, ward, school district, flood risk, and airport noise designations for comprehensive property profiles

### 🔧 Input

- **Search Mode** - Choose how to find properties: by PIN (direct lookup), by address (street search with optional city filter), by township (all properties in a Cook County township), or by municipality (city/village level)
- **PINs** - Enter one or more 14-digit Property Index Numbers for direct lookups. Example: 14321090140000
- **Street Address** - Search properties by street name or partial address. Use uppercase for best results. Example: MICHIGAN AVE, JANSSEN
- **City** - Optional city name to narrow address searches. Example: CHICAGO, OAK PARK, EVANSTON
- **Township** - Select a Cook County township to retrieve all properties from that area
- **Municipality** - Enter a city or village name to get all properties in that municipality
- **Assessment Year** - Filter to a specific tax year (1999-2026). Leave blank for most recent data
- **Include Assessed Values History** - Check to add year-by-year assessment data showing mailed, certified, and Board of Review values
- **Include Property Characteristics** - Check to add physical details like year built, square footage, bedrooms, bathrooms, construction quality
- **Include Sales History** - Check to add past sale dates, prices, deed types, buyer and seller names
- **Include Board of Review Appeals** - Check to add appeal history with assessor vs. Board of Review values and appeal outcomes
- **Max Properties** - Set the maximum number of results to return. Free users can collect up to 100. Paid users can collect up to 1,000,000.

Example input:
```json
{
  "searchMode": "municipality",
  "municipality": "CHICAGO",
  "maxItems": 500,
  "includeAssessedValues": true,
  "includeCharacteristics": true,
  "includeSales": false,
  "includeAppeals": false
}
````

### 📊 Output

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

| 🔑 PIN | 📍 Property Address | 🏙️ City |
|---|---|---|
| 📘 Township | 🏘️ Municipality | 🏷️ Property Class |
| 💰 Assessed Value | 📈 Market Value (est.) | 📅 Year Built |
| 📏 Building Sq Ft | 📏 Land Sq Ft | 🌍 Latitude/Longitude |
| 🔗 Assessor URL | 📋 ZIP Code | 🏠 Mailing Address |
| 🏘️ School District | 🚨 Flood Risk | 📞 Ward |
| 📅 Scraped At | ⚠️ Error Messages | 🗓️ Assessment Year History |
| 💵 Sales Price & Date | 📊 Board of Review Values | 🏛️ Appeal Outcomes |

### 💎 Why Choose the Cook County Assessor Scraper?

| Feature | Our Scraper | Similar Tools |
|---|---|---|
| Official Cook County government data | ✔️ | ❌ |
| Search by PIN, address, township, or city | ✔️ | ❌ |
| Year-by-year assessment history | ✔️ | ❌ |
| Property characteristics (bedrooms, sq ft, year built) | ✔️ | ❌ |
| Sales history with prices and dates | ✔️ | ❌ |
| Board of Review appeal records | ✔️ | ❌ |
| Up to 1,000,000 results per run | ✔️ | Partial |
| No authentication required | ✔️ | ❌ |
| Export to CSV, Excel, or JSON | ✔️ | ✔️ |
| Free tier with no rate limits | ✔️ | ❌ |
| Suitable for bulk data collection | ✔️ | ❌ |
| Built for non-technical users | ✔️ | ❌ |

### 📋 How to Use

No technical skills required. Follow these simple steps:

1. **Sign Up**: [Create a free account with $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp) - includes 100 free results per run
2. **Find the Tool**: Search for "Cook County Assessor" in the Apify Store and configure your search parameters
3. **Run It**: Click "Start" and watch your results populate in real time

That's it. No coding, no setup, no complicated configuration. Now you can export your data in CSV, Excel, or JSON format.

### 🎯 Business Use Cases

- 📊 **Real Estate Investors** - Research assessed values and sales history across Cook County to identify undervalued properties before making acquisition offers
- 💼 **Property Managers** - Collect assessment data for entire portfolios to track tax liability trends and prepare for appeals
- 🔍 **Appraisers and Assessors** - Gather comparable property data by township and property class to validate market valuations and support professional reports

***

### 🌟 Beyond business use cases

Data like this powers more than commercial workflows. The same structured records support research, education, civic projects, and personal initiatives.

<table>
<tr>
<td width="50%">

#### 🎓 Research and academia

- Empirical datasets for papers, thesis work, and coursework
- Longitudinal studies tracking changes across snapshots
- Reproducible research with cited, versioned data pulls
- Classroom exercises on data analysis and ethical scraping

</td>
<td width="50%">

#### 🎨 Personal and creative

- Side projects, portfolio demos, and indie app launches
- Data visualizations, dashboards, and infographics
- Content research for bloggers, YouTubers, and podcasters
- Hobbyist collections and personal trackers

</td>
</tr>
<tr>
<td width="50%">

#### 🤝 Non-profit and civic

- Transparency reporting and accountability projects
- Advocacy campaigns backed by public-interest data
- Community-run databases for local issues
- Investigative journalism on public records

</td>
<td width="50%">

#### 🧪 Experimentation

- Prototype AI and machine-learning pipelines with real data
- Validate product-market hypotheses before engineering spend
- Train small domain-specific models on niche corpora
- Test dashboard concepts with live input

</td>
</tr>
</table>

### ❓ FAQ

**🔍 How does this work?**
The scraper pulls data directly from Cook County's official Open Data Portal. No login required, it's all public record.

**📊 How accurate is the data?**
Data comes straight from Cook County government records and is the same information used by appraisers, tax collectors, and county officials.

**📅 Can I schedule automatic runs?**
Yes. Set up a schedule in Apify to collect updated property data weekly, monthly, or any frequency you need.

**⚖️ Is it legal to collect this data?**
Yes. Cook County publishes this data publicly through their official Open Data Portal. All data is public record. Users are responsible for complying with local laws and Cook County terms of service.

**🛡️ Will Cook County block my requests?**
No. You are accessing public data from Cook County's official portal. There is no blocking risk.

**⚡ How long does a run take?**
A single PIN lookup takes seconds. Searching 100 properties takes 2-5 minutes. Township or municipality searches depend on property count (typically 5-15 minutes for 1000 properties).

**⚠️ Are there any limits?**
Free users can collect up to 100 results per run. Paid users can collect up to 1,000,000 results per run.

### 🔗 Integrate Cook County Assessor Scraper with any app

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

### 💡 More ParseForge Actors

- [Houzz Scraper](https://apify.com/parseforge/houzz-scraper) - Collect real estate listings and market data
- [Google News Scraper](https://apify.com/parseforge/google-news-scraper) - Extract news articles and headlines
- [Justia Case Law Scraper](https://apify.com/parseforge/justia-case-law-scraper) - Research legal precedents and court decisions
- [Revzilla Scraper](https://apify.com/parseforge/revzilla-scraper) - Collect motorcycle gear and product data
- [LiveAuctioneers Scraper](https://apify.com/parseforge/liveauctioneers-scraper) - Track auction listings and bids

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

### 🚀 Ready to Start?

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

### 🆘 Need Help?

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

### ⚠️ Disclaimer

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

# Actor input Schema

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

Maximum number of properties to return. Free users are capped at 100. Leave blank for no limit.

## `searchMode` (type: `string`):

How to search for properties. Use 'pin' for direct PIN lookup, 'address' for street address search, 'township' to get all properties in a Cook County township, or 'municipality' for city/village level.

## `pins` (type: `array`):

List of 14-digit Property Index Numbers to look up. Used when searchMode is 'pin'. Example: \["14321090140000", "20144090260000"].

## `address` (type: `string`):

Property street address to search for. Partial matches supported. Use uppercase (e.g., JANSSEN, MICHIGAN AVE). Used when searchMode is 'address'.

## `city` (type: `string`):

City name to narrow address search (e.g., CHICAGO, OAK PARK, EVANSTON). Leave blank to search all cities.

## `township` (type: `string`):

Cook County township to retrieve all properties from. Used when searchMode is 'township'.

## `municipality` (type: `string`):

Municipality (city/village) name. Used when searchMode is 'municipality'. Example: Chicago, Evanston, Oak Park.

## `year` (type: `integer`):

Filter assessed values and characteristics to a specific year (1999–2026). Leave blank to get the most recent data.

## `includeAssessedValues` (type: `boolean`):

Include historic assessed values (mailed, certified, and Board of Review values for land, building, and total).

## `includeCharacteristics` (type: `boolean`):

Include physical property characteristics: year built, square footage, bedrooms, bathrooms, construction quality, etc.

## `includeSales` (type: `boolean`):

Include property sales history with sale dates, prices, buyer/seller names, and deed types.

## `includeAppeals` (type: `boolean`):

Include Board of Review appeal history with assessor/BOR values, appeal type, result, and attorney information.

## Actor input object example

```json
{
  "maxItems": 10,
  "searchMode": "pin",
  "pins": [
    "14321090140000"
  ],
  "includeAssessedValues": true,
  "includeCharacteristics": true,
  "includeSales": false,
  "includeAppeals": false
}
```

# Actor output Schema

## `defaultDatasetId` (type: `string`):

ID of the dataset containing scraped property records

## `itemsUrl` (type: `string`):

URL to access all scraped property records

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "maxItems": 10,
    "searchMode": "pin",
    "pins": [
        "14321090140000"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/cookcountyassessor-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "maxItems": 10,
    "searchMode": "pin",
    "pins": ["14321090140000"],
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/cookcountyassessor-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "maxItems": 10,
  "searchMode": "pin",
  "pins": [
    "14321090140000"
  ]
}' |
apify call parseforge/cookcountyassessor-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Cook County Assessor's Property Scraper",
        "description": "Get Cook County property information in minutes. Search by address, area, or property number and receive clear details on property value, sales history, and key home features. Perfect for buyers, investors, and analysts who need reliable data to compare properties and make smarter decisions quickly.",
        "version": "1.5",
        "x-build-id": "eDj41nVv6wZWGBbVx"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~cookcountyassessor-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-cookcountyassessor-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/parseforge~cookcountyassessor-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-cookcountyassessor-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/parseforge~cookcountyassessor-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-cookcountyassessor-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",
                "required": [
                    "searchMode"
                ],
                "properties": {
                    "maxItems": {
                        "title": "Max Properties",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Maximum number of properties to return. Free users are capped at 100. Leave blank for no limit."
                    },
                    "searchMode": {
                        "title": "Search Mode",
                        "enum": [
                            "pin",
                            "address",
                            "township",
                            "municipality"
                        ],
                        "type": "string",
                        "description": "How to search for properties. Use 'pin' for direct PIN lookup, 'address' for street address search, 'township' to get all properties in a Cook County township, or 'municipality' for city/village level."
                    },
                    "pins": {
                        "title": "PINs (Property Index Numbers)",
                        "type": "array",
                        "description": "List of 14-digit Property Index Numbers to look up. Used when searchMode is 'pin'. Example: [\"14321090140000\", \"20144090260000\"].",
                        "items": {
                            "type": "string"
                        }
                    },
                    "address": {
                        "title": "Street Address",
                        "type": "string",
                        "description": "Property street address to search for. Partial matches supported. Use uppercase (e.g., JANSSEN, MICHIGAN AVE). Used when searchMode is 'address'."
                    },
                    "city": {
                        "title": "City",
                        "type": "string",
                        "description": "City name to narrow address search (e.g., CHICAGO, OAK PARK, EVANSTON). Leave blank to search all cities."
                    },
                    "township": {
                        "title": "Township",
                        "enum": [
                            "Barrington",
                            "Berwyn",
                            "Bloom",
                            "Bremen",
                            "Calumet",
                            "Cicero",
                            "Elk Grove",
                            "Evanston",
                            "Hanover",
                            "Hyde Park",
                            "Jefferson",
                            "Lake",
                            "Lake View",
                            "Lemont",
                            "Leyden",
                            "Lyons",
                            "Maine",
                            "New Trier",
                            "Niles",
                            "North Chicago",
                            "Northfield",
                            "Norwood Park",
                            "Oak Park",
                            "Orland",
                            "Palatine",
                            "Palos",
                            "Proviso",
                            "Rich",
                            "River Forest",
                            "Riverside",
                            "Rogers Park",
                            "Schaumburg",
                            "South Chicago",
                            "Stickney",
                            "Thornton",
                            "West Chicago",
                            "Wheeling",
                            "Worth"
                        ],
                        "type": "string",
                        "description": "Cook County township to retrieve all properties from. Used when searchMode is 'township'."
                    },
                    "municipality": {
                        "title": "Municipality",
                        "type": "string",
                        "description": "Municipality (city/village) name. Used when searchMode is 'municipality'. Example: Chicago, Evanston, Oak Park."
                    },
                    "year": {
                        "title": "Assessment Year",
                        "type": "integer",
                        "description": "Filter assessed values and characteristics to a specific year (1999–2026). Leave blank to get the most recent data."
                    },
                    "includeAssessedValues": {
                        "title": "Include Assessed Values History",
                        "type": "boolean",
                        "description": "Include historic assessed values (mailed, certified, and Board of Review values for land, building, and total).",
                        "default": true
                    },
                    "includeCharacteristics": {
                        "title": "Include Property Characteristics",
                        "type": "boolean",
                        "description": "Include physical property characteristics: year built, square footage, bedrooms, bathrooms, construction quality, etc.",
                        "default": true
                    },
                    "includeSales": {
                        "title": "Include Sales History",
                        "type": "boolean",
                        "description": "Include property sales history with sale dates, prices, buyer/seller names, and deed types.",
                        "default": false
                    },
                    "includeAppeals": {
                        "title": "Include Board of Review Appeals",
                        "type": "boolean",
                        "description": "Include Board of Review appeal history with assessor/BOR values, appeal type, result, and attorney information.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```