# Hotpads Scraper With Agents | Fast & Reliable (`fatihtahta/hotpads-scraper`) Actor

Extract HotPads rental listings at scale with unlimited coverage, deep listing detail, owner and contact data, flexible filters, and broad market coverage. Built for enterprise-grade rental intelligence, lead generation, and automated analytics pipelines.

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

## Pricing

from $0.70 / 1,000 property listings

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

## Hotpads Scraper

**Slug:** `fatihtahta/hotpads-scraper`

### Overview

Hotpads Scraper collects structured rental listing records, including listing identifiers, rental URLs, titles, property types, pricing, bedrooms, bathrooms, square footage, media, amenities, contact details, policies, timestamps, and location attributes. [HotPads](https://hotpads.com) is a public rental marketplace where apartment, condo, house, townhouse, room, sublet, and corporate housing availability can provide useful signals for rental-market analysis. The actor turns selected HotPads search criteria into repeatable Apify datasets that can be used in analytics, enrichment, monitoring, and reporting workflows. It is designed for recurring data acquisition where consistent JSON output, predictable input controls, and operational repeatability matter. Results reflect the public data available at run time and should be validated against your target market, filters, and downstream requirements.

### Why Use This Actor

- **Market research and analytics teams:** collect structured rental data for market intelligence, pricing analysis, inventory tracking, and neighborhood-level reporting.
- **Product and content teams:** populate rental experiences, internal directories, comparison tools, or content operations with normalized listing attributes and media metadata.
- **Developers and data engineering teams:** feed downstream systems with repeatable JSON records suitable for ETL jobs, data warehouses, APIs, and dataset normalization.
- **Lead generation and enrichment teams:** identify rental listings, owner-listed units, contact signals, amenities, and listing context for enrichment pipelines and operational review.
- **Monitoring and competitive tracking teams:** schedule recurring runs to track pricing, availability, listing recency, geographic coverage, and market movement over time.

### Common Use Cases

- **Market intelligence:** monitor rental supply, pricing bands, availability, bedroom mix, amenities, and location movement across supported HotPads markets.
- **Lead generation:** build targeted prospect lists from public rental listings that match owner-listed, amenity, price, or geographic criteria.
- **Competitive monitoring:** track changes across neighborhoods, property types, special offers, and recently published listings.
- **Catalog and directory building:** populate internal rental databases with structured public records, addresses, images, pricing, and feature metadata.
- **Data enrichment:** add current public rental attributes to existing CRM, BI, underwriting, or analytics datasets.
- **Recurring reporting:** schedule periodic runs for dashboards, alerts, market snapshots, and trend analysis.

### Quick Start

1. Enter a supported `location`, such as a city, neighborhood, borough, ZIP code, or address.
2. Add optional filters such as `property_type`, `min_price`, `max_price`, `bedroom`, `min_bedroom`, `min_bathroom`, amenities, pets, or publication recency.
3. Set a small `limit` for your first validation run.
4. Run the actor in Apify Console.
5. Inspect the first dataset records to confirm that the output shape, market, and filters match your use case.
6. Increase `limit`, adjust filters, enable broader coverage with `maximize_coverage`, or schedule the actor once the output is verified.

### Input Parameters

Hotpads Scraper requires a supported `location`; all other inputs refine scope, ordering, coverage, or output volume.

| Parameter | Type | Description | Default |
| --- | --- | --- | --- |
| `location` | string | Supported HotPads location to search. Use a city, neighborhood, borough, ZIP code, or address, such as `San Francisco, CA`, `SoHo, New York`, `10001`, or `90210`. Statewide searches are not supported in this flow. | – |
| `min_price` | integer | Minimum monthly rent to include, in USD. Leave empty for no lower price requirement. | – |
| `max_price` | integer | Maximum monthly rent to include, in USD. Leave empty for no upper price requirement. | – |
| `property_type` | array of strings | Property categories to include. Allowed values: `apartment`, `condo`, `duplex`, `house`, `townhouse`. | `["apartment"]` |
| `bedroom` | string | Exact bedroom count. Allowed values: `studio`, `1`, `2`, `3`, `4`. | – |
| `min_bedroom` | string | Minimum bedroom count. Allowed values: `1+`, `2+`, `3+`, `4+`. When both `bedroom` and `min_bedroom` are provided, the minimum bedroom filter takes priority. | – |
| `min_bathroom` | string | Minimum bathroom count. Allowed values: `1+`, `1.5+`, `2+`, `3+`, `4+`. | – |
| `min_area` | string | Minimum floor area in square feet. Allowed values: `200`, `400`, `600`, `800`, `1000`, `1200`, `1400`, `1600`, `1800`, `2000`, `2200`, `2400`, `2600`, `2800`, `3000`, `3200`, `3400`, `3600`, `3799`. | – |
| `max_area` | string | Maximum floor area in square feet. Allowed values: `3600`, `3400`, `3200`, `3000`, `2800`, `2600`, `2400`, `2200`, `2000`, `1800`, `1600`, `1400`, `1200`, `1000`, `800`, `600`, `400`, `200`, `1`. | – |
| `amenities` | array of strings | Required amenities. Allowed values: `in_unit_laundry`, `shared_laundry`, `ac`, `heating`, `parking`, `gated_entry`, `doorman`, `gym`, `pool`, `dishwasher`, `furnished`. | – |
| `pets` | array of strings | Required pet policies. Allowed values: `dogs_allowed`, `cats_allowed`. | – |
| `publication_date` | string | Listing recency window. Allowed values: `1_hour`, `24_hours`, `7_days`, `30_days`. | – |
| `keyword` | string | One keyword or phrase to narrow listing text, such as a feature, building name, neighborhood term, or leasing condition. | – |
| `exclude_rental_type` | array of strings | Rental categories to exclude. Allowed values: `regular`, `rooms_for_rent`, `sublet`, `corporate`. | – |
| `special_restriction` | string | Housing program filter. Allowed values: `income_restricted`, `senior_housing`, `student_housing`, `military_housing`, `no_restricted_housing`. | – |
| `with_photo` | boolean | Include only listings that provide at least one photo. | `false` |
| `with_price` | boolean | Include only listings that show clear pricing. | `false` |
| `for_rent_by_owner` | boolean | Include only rentals listed directly by the owner. | `false` |
| `properties_with_offers` | boolean | Include only listings that advertise special offers. | `false` |
| `accepting_online_applications` | boolean | Include only listings that accept online rental applications. | `false` |
| `sort_by` | string | Result ordering. Allowed values: `default`, `newest`, `most_popular`, `highest_price`, `lowest_price`. | `default` |
| `maximize_coverage` | boolean | Collect more matching listings for broad searches that may exceed the visible result set, without changing the selected criteria. Turn off for faster exploratory runs. | `true` |
| `limit` | integer | Maximum number of listings to save. Minimum value: `1`. Leave empty to collect all available results that match the selected criteria. | – |

### Choosing Inputs

Start with the smallest scope that answers your question. Use `location` to define the market, then decide whether your workflow needs broad discovery or a targeted dataset.

Narrower filters, such as price, bedroom count, property type, amenities, pets, publication recency, or listing requirements, produce more focused records. Broader inputs improve discovery and are useful for market scans, inventory analysis, and trend reporting. Use `sort_by` when ordering matters for validation or monitoring, and use `maximize_coverage` when broad searches may contain more matching rentals than the first visible result set. When testing a new market or filter set, start with a small `limit`, inspect the output, and then increase the limit after confirming record quality.

### Example Inputs

#### Targeted apartment search

```json
{
  "location": "SoHo, New York",
  "property_type": ["apartment", "condo"],
  "min_price": 3000,
  "max_price": 8000,
  "bedroom": "1",
  "with_photo": true,
  "limit": 50
}
````

#### Recently posted monitoring run

```json
{
  "location": "San Francisco, CA",
  "property_type": ["apartment"],
  "publication_date": "24_hours",
  "sort_by": "newest",
  "with_price": true,
  "limit": 100
}
```

#### Broad discovery with controlled volume

```json
{
  "location": "90210",
  "property_type": ["house", "townhouse"],
  "min_bedroom": "2+",
  "min_bathroom": "2+",
  "pets": ["dogs_allowed", "cats_allowed"],
  "maximize_coverage": true,
  "limit": 75
}
```

### Output

#### Output Destination

The actor writes results to an Apify dataset as JSON records. The dataset is designed for direct consumption by analytics tools, ETL pipelines, and downstream APIs with minimal post-processing.

When multiple entity types or record shapes exist, this README documents each shape separately based on the provided Example Output. The provided output contains one primary record shape: a HotPads rental listing record.

#### Record Envelope And Stable Identifiers

Each record represents one public HotPads rental listing and includes stable listing-level fields such as `id`, `url`, and `fingerprint` when available. The recommended idempotency key is `id`; if your destination requires a fallback, use `url` or `fingerprint`.

For deduplication and upserts, use the recommended idempotency key to merge repeated observations of the same listing instead of creating duplicate records. Stable identifiers make records easier to merge, deduplicate, and sync across repeated runs.

The `source_context` object records run context for the collected listing, and `fingerprint` provides an additional stable record signature for sync and deduplication workflows.

#### Examples

##### Example: listing record

```json
{
  "id": "sample-listing-001",
  "url": "https://hotpads.com/123-example-ave-example-city-ca-90001-sample/4b/pad",
  "title": "123 Example Ave #4B",
  "listing_type": "rental",
  "property_type": "condo",
  "building_url": "https://hotpads.com/123-example-ave-example-city-ca-90001-sample/building",
  "search_keyword": "Apartment Unit for Rent",
  "identifiers": {
    "building_id": "sample-building-001"
  },
  "pricing": {
    "min_price": 4250.0,
    "max_price": 4250.0
  },
  "features": {
    "min_bedrooms": 2,
    "max_bedrooms": 2,
    "min_bathrooms": 2.0,
    "max_bathrooms": 2.0,
    "bathrooms": 2.0,
    "min_square_feet": 1180.0,
    "max_square_feet": 1180.0
  },
  "units": {
    "models": [
      {
        "num_beds": 2,
        "low_price": 4250.0,
        "high_price": 4250.0
      }
    ],
    "new_unit_count": 0,
    "price_drop_count": 0
  },
  "media": {
    "primary_image_url": "https://example.com/images/hotpads-sample-01.webp",
    "image_urls": [
      "https://example.com/images/hotpads-sample-01.webp",
      "https://example.com/images/hotpads-sample-02.webp",
      "https://example.com/images/hotpads-sample-03.webp",
      "https://example.com/images/hotpads-sample-04.webp",
      "https://example.com/images/hotpads-sample-05.webp",
      "https://example.com/images/hotpads-sample-06.webp",
      "https://example.com/images/hotpads-sample-07.webp",
      "https://example.com/images/hotpads-sample-08.webp",
      "https://example.com/images/hotpads-sample-09.webp",
      "https://example.com/images/hotpads-sample-10.webp",
      "https://example.com/images/hotpads-sample-11.webp",
      "https://example.com/images/hotpads-sample-12.webp",
      "https://example.com/images/hotpads-sample-13.webp",
      "https://example.com/images/hotpads-sample-14.webp",
      "https://example.com/images/hotpads-sample-15.webp"
    ],
    "image_count": 15,
    "has_videos": false,
    "has_external_3d_tours": false,
    "has_zillow_3d_tours": false
  },
  "amenities": [
    "Pets: Cats and Dogs Allowed",
    "Laundry: In Unit",
    "Laundry: Shared",
    "HVAC: Central A/C",
    "Gym: On-site",
    "Security: Doorman",
    "Appliances: Dishwasher"
  ],
  "description": "Unit 4B at 123 Example Ave is a sample 2-bedroom, 2-bath residence with approximately 1,180 square feet of living space. The listing description includes anonymized details about an open living area, modern kitchen, in-unit laundry, shared amenities, and convenient neighborhood access. This sample text is provided only to demonstrate the shape and length of a typical listing description.",
  "contact": {
    "company_name": "Sample Property Group",
    "listed_by": {
      "company_name": "Sample Property Group",
      "contact_phone": "555-010-1234",
      "contact_name": "Leasing Team",
      "member_since": {
        "date": 1700000000000,
        "ago": "2 years, 1 month ago"
      }
    },
    "inquiry": {
      "restricted": false,
      "default_inquiry_message": "I'd like to schedule a viewing for Example Ave #4B, Example City, CA 90001, US. Please contact me with more information!",
      "requires_num_beds": false,
      "requires_move_date": false,
      "requires_first_and_last_name": false,
      "requires_phone": true,
      "requires_user_entered_message": false,
      "requires_zip_code": false,
      "requires_name": true,
      "requires_email": true,
      "requires_message": true,
      "display_contact_box": true
    }
  },
  "policies": {
    "rental_application_status": "undecided",
    "income_restricted": false,
    "senior_housing": false,
    "student_housing": false,
    "military_housing": false
  },
  "promotions": {
    "has_special_offers": false
  },
  "status": {
    "trusted": false,
    "broker_exclusive": false,
    "broker_listing": false,
    "bonus_listing_customer": false,
    "claimed_free_listing": false,
    "paid_multifamily": false,
    "paid_and_not_demoted": false,
    "demoted": false
  },
  "metrics": {
    "priority": 0.0,
    "score": 0.0,
    "experiment_score": 0.0
  },
  "timestamps": {
    "activated_at": "2026-01-15T12:00:00.000000Z",
    "updated_at": "2026-01-15T12:00:00.000000Z"
  },
  "attributes": {
    "activated": 1768478400000,
    "unit": "4B",
    "experiment_score": 0.0,
    "neighborhoods": [
      "Sample District"
    ],
    "company_name": "Sample Property Group",
    "has_total_monthly_price": false
  },
  "location": {
    "address": {
      "street": "123 Example Ave",
      "city": "Example City",
      "region": "CA",
      "postal_code": "90001",
      "hide_street": false
    },
    "city": "Example City",
    "region": "CA",
    "postal_code": "90001",
    "coordinates": {
      "latitude": 34.000000000000000,
      "longitude": -118.00000000000000,
      "quad": "sample-quad-001"
    },
    "neighborhoods": [
      "Sample District"
    ]
  },
  "source_context": {
    "seed_id": "sample-seed-001",
    "seed_type": "search",
    "seed_value": "Example District, Example City",
    "page_index": 1,
    "resolved_location": {
      "locationInput": "Example District, Example City",
      "name": "Example District",
      "type": "neighborhood",
      "areaId": "sample-area-001",
      "resourceId": "example-district-example-city-ca",
      "city": "Example City",
      "state": "CA",
      "lat": "34.0000000000",
      "lon": "-118.0000000000",
      "bounds": {
        "maxLat": "34.0100000000",
        "maxLon": "-117.9900000000",
        "minLat": "33.9900000000",
        "minLon": "-118.0100000000"
      }
    },
    "domain": "hotpads.com"
  },
  "fingerprint": "sample-fingerprint-001"
}
```

### Field Reference

#### Listing Record

**id** *(string, required)*: HotPads listing identifier.

**url** *(string, required)*: Public listing URL.

**title** *(string, optional)*: Listing title or unit label.

**listing\_type** *(string, optional)*: Listing category, such as `rental`.

**property\_type** *(string, optional)*: Property type, such as `condo`, `apartment`, `house`, or `townhouse`.

**building\_url** *(string, optional)*: Public building URL when available.

**search\_keyword** *(string, optional)*: Listing descriptor associated with the result.

**identifiers.building\_id** *(string, optional)*: Building identifier associated with the listing.

**pricing.min\_price / pricing.max\_price** *(number, optional)*: Monthly rent range in USD when pricing is available.

**features.min\_bedrooms / features.max\_bedrooms** *(number, optional)*: Bedroom range for the listing.

**features.min\_bathrooms / features.max\_bathrooms / features.bathrooms** *(number, optional)*: Bathroom values for the listing.

**features.min\_square\_feet / features.max\_square\_feet** *(number, optional)*: Floor-area range in square feet.

**units.models** *(array, optional)*: Unit or model-level pricing entries.

**units.models\[].num\_beds** *(number, optional)*: Bedroom count for a unit model.

**units.models\[].low\_price / units.models\[].high\_price** *(number, optional)*: Unit model monthly rent range in USD.

**units.new\_unit\_count** *(number, optional)*: Count of units marked as new.

**units.price\_drop\_count** *(number, optional)*: Count of units with price-drop signals.

**media.primary\_image\_url** *(string, optional)*: Primary image URL.

**media.image\_urls** *(array of strings, optional)*: Listing image URLs.

**media.image\_count** *(number, optional)*: Number of images reported for the listing.

**media.has\_videos** *(boolean, optional)*: Whether video media is advertised.

**media.has\_external\_3d\_tours** *(boolean, optional)*: Whether an external 3D tour is advertised.

**media.has\_zillow\_3d\_tours** *(boolean, optional)*: Whether a Zillow 3D tour is advertised.

**amenities** *(array of strings, optional)*: Public amenity labels associated with the listing.

**description** *(string, optional)*: Listing description text when available.

**contact.company\_name** *(string, optional)*: Company or listing source name.

**contact.listed\_by.company\_name** *(string, optional)*: Listing company name.

**contact.listed\_by.contact\_phone** *(string, optional)*: Public contact phone number when displayed.

**contact.listed\_by.contact\_name** *(string, optional)*: Public contact name when displayed.

**contact.listed\_by.member\_since.date** *(number, optional)*: Account membership timestamp when available.

**contact.listed\_by.member\_since.ago** *(string, optional)*: Human-readable membership age.

**contact.inquiry.restricted** *(boolean, optional)*: Whether inquiry access is restricted.

**contact.inquiry.default\_inquiry\_message** *(string, optional)*: Default inquiry message provided for the listing.

**contact.inquiry.requires\_num\_beds** *(boolean, optional)*: Whether inquiry requires bedroom count.

**contact.inquiry.requires\_move\_date** *(boolean, optional)*: Whether inquiry requires move date.

**contact.inquiry.requires\_first\_and\_last\_name** *(boolean, optional)*: Whether inquiry requires first and last name.

**contact.inquiry.requires\_phone** *(boolean, optional)*: Whether inquiry requires a phone number.

**contact.inquiry.requires\_user\_entered\_message** *(boolean, optional)*: Whether inquiry requires a user-entered message.

**contact.inquiry.requires\_zip\_code** *(boolean, optional)*: Whether inquiry requires ZIP code.

**contact.inquiry.requires\_name** *(boolean, optional)*: Whether inquiry requires name.

**contact.inquiry.requires\_email** *(boolean, optional)*: Whether inquiry requires email.

**contact.inquiry.requires\_message** *(boolean, optional)*: Whether inquiry requires a message.

**contact.inquiry.display\_contact\_box** *(boolean, optional)*: Whether a contact box is displayed.

**policies.rental\_application\_status** *(string, optional)*: Rental application status.

**policies.income\_restricted** *(boolean, optional)*: Whether income-restricted housing is indicated.

**policies.senior\_housing** *(boolean, optional)*: Whether senior housing is indicated.

**policies.student\_housing** *(boolean, optional)*: Whether student housing is indicated.

**policies.military\_housing** *(boolean, optional)*: Whether military housing is indicated.

**promotions.has\_special\_offers** *(boolean, optional)*: Whether special offers are advertised.

**status.trusted** *(boolean, optional)*: Listing trust signal.

**status.broker\_exclusive** *(boolean, optional)*: Whether broker exclusivity is indicated.

**status.broker\_listing** *(boolean, optional)*: Whether the listing is broker-associated.

**status.bonus\_listing\_customer** *(boolean, optional)*: Listing status signal.

**status.claimed\_free\_listing** *(boolean, optional)*: Whether a claimed free listing signal is present.

**status.paid\_multifamily** *(boolean, optional)*: Whether a paid multifamily signal is present.

**status.paid\_and\_not\_demoted** *(boolean, optional)*: Paid listing status signal.

**status.demoted** *(boolean, optional)*: Whether the listing is marked as demoted.

**metrics.priority** *(number, optional)*: Priority score when available.

**metrics.score** *(number, optional)*: Listing score when available.

**metrics.experiment\_score** *(number, optional)*: Experiment score when available.

**timestamps.activated\_at** *(string, optional)*: Activation timestamp in ISO 8601 format.

**timestamps.updated\_at** *(string, optional)*: Update timestamp in ISO 8601 format.

**attributes.activated** *(number, optional)*: Activation timestamp as a numeric value.

**attributes.unit** *(string, optional)*: Unit identifier or unit number.

**attributes.experiment\_score** *(number, optional)*: Experiment score mirrored from listing attributes.

**attributes.neighborhoods** *(array of strings, optional)*: Neighborhood labels.

**attributes.company\_name** *(string, optional)*: Company name captured with listing attributes.

**attributes.has\_total\_monthly\_price** *(boolean, optional)*: Whether total monthly price is indicated.

**location.address.street** *(string, optional)*: Street address when visible.

**location.address.city** *(string, optional)*: Address city.

**location.address.region** *(string, optional)*: State or region abbreviation.

**location.address.postal\_code** *(string, optional)*: Postal code.

**location.address.hide\_street** *(boolean, optional)*: Whether street display is hidden.

**location.city** *(string, optional)*: Listing city.

**location.region** *(string, optional)*: Listing state or region.

**location.postal\_code** *(string, optional)*: Listing postal code.

**location.coordinates.latitude / location.coordinates.longitude** *(number, optional)*: Geographic coordinates.

**location.coordinates.quad** *(string, optional)*: Geographic grid reference when available.

**location.neighborhoods** *(array of strings, optional)*: Neighborhoods associated with the listing.

**source\_context.seed\_id** *(string, optional)*: Identifier for the input seed that produced the record.

**source\_context.seed\_type** *(string, optional)*: Seed type, such as `search`.

**source\_context.seed\_value** *(string, optional)*: Original location or search value used for the run.

**source\_context.page\_index** *(number, optional)*: Page or batch index associated with the record.

**source\_context.resolved\_location.locationInput** *(string, optional)*: User-provided location value.

**source\_context.resolved\_location.name** *(string, optional)*: Resolved location name.

**source\_context.resolved\_location.type** *(string, optional)*: Resolved location type, such as neighborhood, city, ZIP code, or address.

**source\_context.resolved\_location.areaId** *(string, optional)*: Area identifier when available.

**source\_context.resolved\_location.resourceId** *(string, optional)*: Resource identifier when available.

**source\_context.resolved\_location.city** *(string, optional)*: Resolved city.

**source\_context.resolved\_location.state** *(string, optional)*: Resolved state.

**source\_context.resolved\_location.lat / source\_context.resolved\_location.lon** *(string, optional)*: Resolved location coordinates.

**source\_context.resolved\_location.bounds.maxLat / source\_context.resolved\_location.bounds.maxLon / source\_context.resolved\_location.bounds.minLat / source\_context.resolved\_location.bounds.minLon** *(string, optional)*: Resolved location boundary values.

**source\_context.domain** *(string, optional)*: Source domain, typically `hotpads.com`.

**fingerprint** *(string, required)*: Stable record fingerprint for deduplication and sync workflows.

### Data Quality, Guarantees, And Handling

- **Structured records:** results are normalized into predictable JSON objects for downstream use.
- **Best-effort extraction:** fields may vary by region, session, availability, and HotPads presentation changes.
- **Optional fields:** null-check fields in downstream code, especially contact, policy, media, address, and pricing details.
- **Deduplication:** use `id` as the strongest stable key; use `url` or `fingerprint` as fallbacks when needed.
- **Freshness:** results reflect the publicly available data at run time.
- **Repeated runs:** use the recommended idempotency key when syncing data into warehouses, CRMs, or search indexes.

### Tips For Best Results

- Start with a small `limit` to validate output shape before scaling up.
- Use one `location` or market segment per run when you need clean segmentation.
- Leave optional filters empty when the goal is broad discovery.
- Add filters gradually to understand how each field changes coverage.
- Use `publication_date` and `sort_by: "newest"` for recently posted listing monitoring.
- Keep `maximize_coverage` enabled for broad searches where you want more complete matching output.
- Use `id`, `url`, or `fingerprint` for deduplication when storing results over time.

### How to Run on Apify

1. Open the Actor in Apify Console.
2. Configure the available input fields for the target location and listing scope.
3. Set the maximum number of outputs to collect with `limit`.
4. Click **Start** and wait for the run to finish.
5. Open the dataset and inspect the first records.
6. Download results in JSON, CSV, Excel, or other supported formats.

### Scheduling & Automation

#### Scheduling

**Automated Data Collection**

Schedule runs to keep rental datasets fresh for monitoring, reporting, and enrichment workflows. Recurring runs are useful when you need consistent snapshots of pricing, availability, or recently posted listings.

- Navigate to **Schedules** in Apify Console
- Create a new schedule, such as daily, weekly, or a custom cron schedule
- Configure input parameters
- Enable notifications for run completion
- Add webhooks for automated processing

#### Integration Options

- **BI dashboards:** monitor pricing, availability, property types, amenities, and geographic coverage over time.
- **Data warehouses:** load normalized listing records into historical tables for reporting and analysis.
- **CRM enrichment:** sync public rental listing attributes, contact signals, and location context into account or lead records.
- **Google Sheets or Airtable:** review smaller market samples, qualification queues, or operational research lists.
- **Webhooks:** trigger validation, ingestion, notification, or enrichment workflows after each completed run.
- **Alerts and scheduled reporting:** notify teams when new listings, price bands, or market segments match your criteria.

### Export Formats And Downstream Use

Apify datasets can be exported or consumed by downstream systems for operational analysis, monitoring, and data delivery.

- **JSON:** for APIs, applications, and data pipelines
- **CSV or Excel:** for spreadsheet workflows and manual review
- **API access:** for automated ingestion into internal systems
- **BI and warehouses:** for reporting, dashboards, and historical analysis

### Performance

Estimated run times:

- **Small runs (< 1,000 outputs):** ~3-5 minutes
- **Medium runs (1,000-5,000 outputs):** ~5-15 minutes
- **Large runs (5,000+ outputs):** ~15-30 minutes

Execution time varies based on filters, result volume, and how much information is returned per record. Highly filtered runs can finish faster, while broad discovery or detail-rich records may take longer.

### Limitations

- Availability depends on what [HotPads](https://hotpads.com) publicly exposes at run time.
- Some optional fields may be missing on sparse listings or records with limited public detail.
- Very broad searches may take longer or require higher `limit` values to collect the desired volume.
- HotPads-side changes can affect field availability, naming, or visible results.
- Regional, account, or availability differences may change which listings are visible for the same criteria.
- Statewide searches are not supported by this actor input flow.

### Troubleshooting

**No results returned:** Check filter combinations, location spelling, property type selection, and whether HotPads has matching public rental records for the requested market.

**Fewer results than expected:** Broaden filters, raise `limit`, enable `maximize_coverage`, or verify that the target market contains enough matching records.

**Some fields are empty:** Optional fields depend on what each listing publicly provides.

**Run takes longer than expected:** Reduce scope, lower `limit` for validation, or split broad collection into smaller location or filter segments.

**Output changed:** Compare the current output with the field reference and include a small sample when reporting the issue.

### FAQ

**What data does this actor collect?**

It collects public HotPads rental listing records, including identifiers, URLs, titles, property types, pricing, bedrooms, bathrooms, square footage, images, amenities, contact details, policies, timestamps, and location context when available.

**Can I filter by location, category, date, price, or other criteria?**

Yes. The actor supports `location`, `property_type`, price range, bedroom and bathroom filters, area filters, amenities, pets, publication recency, keywords, rental-type exclusions, housing program filters, listing requirements, sorting, and output limits.

**Why did I receive fewer results than my limit?**

The `limit` is a maximum, not a guarantee. The run may return fewer records when HotPads has fewer matching public listings for the selected location and filters.

**Can I schedule recurring runs?**

Yes. Use Apify Schedules to run the actor daily, weekly, or on a custom cron schedule.

**How do I avoid duplicates across runs?**

Use `id` as the primary idempotency key. If needed, use `url` or `fingerprint` as fallback keys for deduplication and upserts.

**Can I export the data to CSV, Excel, or JSON?**

Yes. Apify datasets support JSON, CSV, Excel, and other export formats.

**Does this actor collect private data?**

The actor is intended to collect publicly available HotPads listing information. Users are responsible for ensuring their use of collected data complies with applicable laws, terms, and privacy requirements.

**What should I include when reporting an issue?**

Include the input used, the run ID, expected versus actual behavior, and a small output sample if it helps explain the issue.

### Compliance & Ethics

#### Responsible Data Collection

This actor collects publicly available rental listing information from [HotPads](https://hotpads.com) for legitimate business purposes, including:

- **Real estate** research and market analysis
- Rental inventory monitoring and operational reporting
- Data enrichment for internal analytics, CRM, and business intelligence workflows

Users are responsible for ensuring that their use of the data complies with applicable laws, regulations, contractual obligations, and the target site’s terms. This section is informational and not legal advice.

#### Best Practices

- Use collected data in accordance with applicable laws, regulations, and the target site’s terms
- Respect individual privacy and personal information
- Use data responsibly and avoid disruptive or excessive collection
- Do not use this actor for spamming, harassment, or other harmful purposes
- Follow relevant data protection requirements where applicable, including GDPR and CCPA

### Support

For help, use the actor page or Issues. Include the input used, with sensitive values redacted if needed, the run ID, expected versus actual behavior, and a small output sample when it helps illustrate the issue.

# Actor input Schema

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

Enter a supported HotPads location, such as San Francisco, CA; SoHo, New York; Manhattan, New York, NY; 10001; 90210. Do not enter only a state, because HotPads does not return statewide searches here.

## `min_price` (type: `integer`):

Enter the lowest monthly rent to include. Leave empty when there is no lower price requirement.

## `max_price` (type: `integer`):

Enter the highest monthly rent to include. Leave empty when there is no upper price requirement.

## `property_type` (type: `array`):

Select the property types you want to collect. The default focuses on apartments; selecting House by itself focuses the search on houses for rent.

## `bedroom` (type: `string`):

Choose a single bedroom count when you only want listings with that exact layout. Use Studio for studio apartments.

## `min_bedroom` (type: `string`):

Choose the fewest bedrooms a listing must have. When both bedroom fields are filled, this minimum bedroom filter takes priority over the exact bedroom count.

## `min_bathroom` (type: `string`):

Choose the fewest bathrooms a listing must have. Leave this empty to include listings across all available bathroom counts.

## `min_area` (type: `string`):

Choose the smallest floor area a listing must have. Leave empty when there is no minimum size requirement.

## `max_area` (type: `string`):

Choose the largest floor area a listing may have. Leave empty when there is no maximum size requirement.

## `amenities` (type: `array`):

Select the amenities a listing must match, such as parking, laundry, air conditioning, or furnished availability. Leave empty to avoid narrowing by amenities.

## `pets` (type: `array`):

Choose one or more pet policies to require. Leaving this empty includes listings whether or not they advertise pet support.

## `publication_date` (type: `string`):

Select how recently listings must have been published. Leave empty to include listings regardless of publication age.

## `keyword` (type: `string`):

Enter one keyword or phrase to narrow the results by listing text. Leave empty for broader discovery.

## `exclude_rental_type` (type: `array`):

Select rental types to leave out of the results, such as rooms for rent, sublets, or corporate housing. Leave empty to include all supported rental types.

## `special_restriction` (type: `string`):

Choose one housing program filter to apply, or choose not to include restricted housing when those listings are outside your target dataset.

## `with_photo` (type: `boolean`):

Turn this on to include only listings that provide at least one photo.

## `with_price` (type: `boolean`):

Turn this on to include only listings that show clear pricing.

## `for_rent_by_owner` (type: `boolean`):

Turn this on to include only rentals listed directly by the owner.

## `properties_with_offers` (type: `boolean`):

Turn this on to include only listings that advertise special offers.

## `accepting_online_applications` (type: `boolean`):

Turn this on to include only listings that accept online rental applications.

## `sort_by` (type: `string`):

Choose how to order matching listings. The default option uses the standard HotPads relevance sort.

## `maximize_coverage` (type: `boolean`):

Keep this enabled for large searches that may exceed the visible-result limit. Turn it off for faster exploratory runs where the first visible set of matching listings is enough.

## `limit` (type: `integer`):

Enter the maximum number of listings to save. Leave empty to collect all available results that match the selected criteria.

## Actor input object example

```json
{
  "location": "Soho, New York",
  "property_type": [
    "apartment",
    "condo",
    "duplex",
    "house",
    "townhouse"
  ],
  "with_photo": false,
  "with_price": false,
  "for_rent_by_owner": false,
  "properties_with_offers": false,
  "accepting_online_applications": false,
  "sort_by": "default",
  "maximize_coverage": true,
  "limit": 100
}
```

# Actor output Schema

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

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "location": "Soho, New York",
    "limit": 100
};

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

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = {
    "location": "Soho, New York",
    "limit": 100,
}

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

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

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

```

## CLI example

```bash
echo '{
  "location": "Soho, New York",
  "limit": 100
}' |
apify call fatihtahta/hotpads-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Hotpads Scraper With Agents | Fast & Reliable",
        "description": "Extract HotPads rental listings at scale with unlimited coverage, deep listing detail, owner and contact data, flexible filters, and broad market coverage. Built for enterprise-grade rental intelligence, lead generation, and automated analytics pipelines.",
        "version": "0.0",
        "x-build-id": "iqx43X2cGOWNGbLZf"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fatihtahta~hotpads-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fatihtahta-hotpads-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/fatihtahta~hotpads-scraper/runs": {
            "post": {
                "operationId": "runs-sync-fatihtahta-hotpads-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/fatihtahta~hotpads-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-fatihtahta-hotpads-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": [
                    "location"
                ],
                "properties": {
                    "location": {
                        "title": "Enter City, Neighborhood, Borough, ZIP, or Address",
                        "type": "string",
                        "description": "Enter a supported HotPads location, such as San Francisco, CA; SoHo, New York; Manhattan, New York, NY; 10001; 90210. Do not enter only a state, because HotPads does not return statewide searches here."
                    },
                    "min_price": {
                        "title": "Set Minimum Monthly Rent",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Enter the lowest monthly rent to include. Leave empty when there is no lower price requirement."
                    },
                    "max_price": {
                        "title": "Set Maximum Monthly Rent",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Enter the highest monthly rent to include. Leave empty when there is no upper price requirement."
                    },
                    "property_type": {
                        "title": "Choose Property Types",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Select the property types you want to collect. The default focuses on apartments; selecting House by itself focuses the search on houses for rent.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "apartment",
                                "condo",
                                "duplex",
                                "house",
                                "townhouse"
                            ],
                            "enumTitles": [
                                "Apartment",
                                "Condo",
                                "Duplex",
                                "House",
                                "Townhouse"
                            ]
                        },
                        "default": [
                            "apartment",
                            "condo",
                            "duplex",
                            "house",
                            "townhouse"
                        ]
                    },
                    "bedroom": {
                        "title": "Select an Exact Bedroom Count",
                        "enum": [
                            "studio",
                            "1",
                            "2",
                            "3",
                            "4"
                        ],
                        "type": "string",
                        "description": "Choose a single bedroom count when you only want listings with that exact layout. Use Studio for studio apartments."
                    },
                    "min_bedroom": {
                        "title": "Set Minimum Bedrooms",
                        "enum": [
                            "1+",
                            "2+",
                            "3+",
                            "4+"
                        ],
                        "type": "string",
                        "description": "Choose the fewest bedrooms a listing must have. When both bedroom fields are filled, this minimum bedroom filter takes priority over the exact bedroom count."
                    },
                    "min_bathroom": {
                        "title": "Set Minimum Bathrooms",
                        "enum": [
                            "1+",
                            "1.5+",
                            "2+",
                            "3+",
                            "4+"
                        ],
                        "type": "string",
                        "description": "Choose the fewest bathrooms a listing must have. Leave this empty to include listings across all available bathroom counts."
                    },
                    "min_area": {
                        "title": "Set Minimum Square Footage",
                        "enum": [
                            "200",
                            "400",
                            "600",
                            "800",
                            "1000",
                            "1200",
                            "1400",
                            "1600",
                            "1800",
                            "2000",
                            "2200",
                            "2400",
                            "2600",
                            "2800",
                            "3000",
                            "3200",
                            "3400",
                            "3600",
                            "3799"
                        ],
                        "type": "string",
                        "description": "Choose the smallest floor area a listing must have. Leave empty when there is no minimum size requirement."
                    },
                    "max_area": {
                        "title": "Set Maximum Square Footage",
                        "enum": [
                            "3600",
                            "3400",
                            "3200",
                            "3000",
                            "2800",
                            "2600",
                            "2400",
                            "2200",
                            "2000",
                            "1800",
                            "1600",
                            "1400",
                            "1200",
                            "1000",
                            "800",
                            "600",
                            "400",
                            "200",
                            "1"
                        ],
                        "type": "string",
                        "description": "Choose the largest floor area a listing may have. Leave empty when there is no maximum size requirement."
                    },
                    "amenities": {
                        "title": "Choose Required Amenities",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Select the amenities a listing must match, such as parking, laundry, air conditioning, or furnished availability. Leave empty to avoid narrowing by amenities.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "in_unit_laundry",
                                "shared_laundry",
                                "ac",
                                "heating",
                                "parking",
                                "gated_entry",
                                "doorman",
                                "gym",
                                "pool",
                                "dishwasher",
                                "furnished"
                            ],
                            "enumTitles": [
                                "In-unit laundry",
                                "Shared laundry",
                                "Air conditioning",
                                "Heating",
                                "Parking",
                                "Gated entry",
                                "Doorman",
                                "Gym",
                                "Pool",
                                "Dishwasher",
                                "Furnished"
                            ]
                        }
                    },
                    "pets": {
                        "title": "Select Allowed Pets",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Choose one or more pet policies to require. Leaving this empty includes listings whether or not they advertise pet support.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "dogs_allowed",
                                "cats_allowed"
                            ],
                            "enumTitles": [
                                "Dogs allowed",
                                "Cats allowed"
                            ]
                        }
                    },
                    "publication_date": {
                        "title": "Choose Listing Recency",
                        "enum": [
                            "1_hour",
                            "24_hours",
                            "7_days",
                            "30_days"
                        ],
                        "type": "string",
                        "description": "Select how recently listings must have been published. Leave empty to include listings regardless of publication age."
                    },
                    "keyword": {
                        "title": "Search Listing Text",
                        "type": "string",
                        "description": "Enter one keyword or phrase to narrow the results by listing text. Leave empty for broader discovery."
                    },
                    "exclude_rental_type": {
                        "title": "Exclude Rental Types",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Select rental types to leave out of the results, such as rooms for rent, sublets, or corporate housing. Leave empty to include all supported rental types.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "regular",
                                "rooms_for_rent",
                                "sublet",
                                "corporate"
                            ],
                            "enumTitles": [
                                "Standard rentals",
                                "Rooms for rent",
                                "Sublets",
                                "Corporate housing"
                            ]
                        }
                    },
                    "special_restriction": {
                        "title": "Choose Housing Program Filter",
                        "enum": [
                            "income_restricted",
                            "senior_housing",
                            "student_housing",
                            "military_housing",
                            "no_restricted_housing"
                        ],
                        "type": "string",
                        "description": "Choose one housing program filter to apply, or choose not to include restricted housing when those listings are outside your target dataset."
                    },
                    "with_photo": {
                        "title": "Require Photos",
                        "type": "boolean",
                        "description": "Turn this on to include only listings that provide at least one photo.",
                        "default": false
                    },
                    "with_price": {
                        "title": "Require Listed Prices",
                        "type": "boolean",
                        "description": "Turn this on to include only listings that show clear pricing.",
                        "default": false
                    },
                    "for_rent_by_owner": {
                        "title": "Require Owner-Listed Rentals",
                        "type": "boolean",
                        "description": "Turn this on to include only rentals listed directly by the owner.",
                        "default": false
                    },
                    "properties_with_offers": {
                        "title": "Require Special Offers",
                        "type": "boolean",
                        "description": "Turn this on to include only listings that advertise special offers.",
                        "default": false
                    },
                    "accepting_online_applications": {
                        "title": "Require Online Applications",
                        "type": "boolean",
                        "description": "Turn this on to include only listings that accept online rental applications.",
                        "default": false
                    },
                    "sort_by": {
                        "title": "Sort Results By",
                        "enum": [
                            "default",
                            "newest",
                            "most_popular",
                            "highest_price",
                            "lowest_price"
                        ],
                        "type": "string",
                        "description": "Choose how to order matching listings. The default option uses the standard HotPads relevance sort.",
                        "default": "default"
                    },
                    "maximize_coverage": {
                        "title": "Collect More Matching Listings",
                        "type": "boolean",
                        "description": "Keep this enabled for large searches that may exceed the visible-result limit. Turn it off for faster exploratory runs where the first visible set of matching listings is enough.",
                        "default": true
                    },
                    "limit": {
                        "title": "Set Maximum Results",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Enter the maximum number of listings to save. Leave empty to collect all available results that match the selected criteria."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
