# HousingAnywhere Rental Listings Scraper (`automation-lab/housinganywhere-rental-listings-scraper`) Actor

🏠 Extract public HousingAnywhere rentals with rent, availability, furnishing, amenities, photos, deposits, coordinates, landlord fields, and search metadata.

- **URL**: https://apify.com/automation-lab/housinganywhere-rental-listings-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Real estate
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## HousingAnywhere Rental Listings Scraper

Collect structured rental inventory from public HousingAnywhere search and listing pages.

The **HousingAnywhere Rental Listings Scraper** exports monthly rent, availability, property type, room size, furnishing, amenities, photos, coordinates, deposits, landlord signals, and search metadata. Use it for rental market research, relocation operations, student housing analysis, and recurring inventory monitoring.

- 🏙️ Start from one or more city or property-type searches
- 🏠 Extract individual public listing URLs
- 🔎 Follow HousingAnywhere search pagination
- 🧩 Enrich every result from its public detail page
- 📊 Export JSON, CSV, Excel, XML, RSS, and HTML datasets
- 🔁 Schedule recurring runs to track price and availability changes

No HousingAnywhere login is required for the supported public pages.

### What does HousingAnywhere Rental Listings Scraper do?

The Actor turns HousingAnywhere pages into consistent dataset rows.

For each search URL, it:

1. Downloads the server-rendered search page.
2. Reads current rental cards and search metadata.
3. Follows pagination within the configured safety limit.
4. Deduplicates listings by their stable `ut` listing ID.
5. Optionally visits public detail pages.
6. Saves one structured row per unique rental.

You can also provide individual `/room/ut...` links when you already know which listings matter.

### Who is it for?

#### Rental market analysts

Build comparable-rent datasets by city, property type, size, furnishing, and utilities inclusion.

#### Relocation and student housing teams

Monitor furnished rooms and apartments for clients, employees, international students, or university cohorts.

#### Property managers

Compare active inventory, availability, advertised deposits, amenities, and rental terms across local markets.

#### Investors and researchers

Track supply and price movements with recurring snapshots that are easier to analyze than web pages.

#### Developers and data teams

Feed normalized rental records into dashboards, warehouses, alerts, internal APIs, or enrichment workflows.

### Why use this HousingAnywhere scraper?

- **Structured output:** numeric rent and size values are exported as numbers.
- **Search provenance:** each row can include its source search, page, and result total.
- **Rich enrichment:** detail mode adds photos, coordinates, facilities, deposits, policies, and descriptions.
- **Stable deduplication:** canonical listing IDs prevent duplicate rows across searches.
- **Low-overhead HTTP extraction:** the Actor does not launch a browser for ordinary runs.
- **Fail-closed inputs:** non-HousingAnywhere hosts and wrong page types are rejected.
- **Apify automation:** use schedules, webhooks, API clients, integrations, and MCP.

### What HousingAnywhere rental data can I extract?

| Field | Description |
|---|---|
| `listingId` | Stable HousingAnywhere unit-type ID such as `ut1194020` |
| `url` | Canonical public listing URL |
| `title` | Human-readable rental title |
| `street`, `city`, `country` | Public location fields |
| `postalCode`, `neighborhood` | Detail-page locality fields when available |
| `propertyType` | Room, studio, apartment, or other advertised type |
| `monthlyRent`, `currency` | Numeric monthly rent and ISO-style currency |
| `utilitiesIncluded` | Whether core utilities are included |
| `deposit` | Refundable deposit amount when advertised |
| `availability` | Current source availability text or date |
| `minimumStayMonths`, `maximumStayMonths` | Advertised rental period bounds |
| `bedroomCount` | Number of bedrooms when provided |
| `bedroomSizeM2`, `propertySizeM2` | Numeric floor-area signals |
| `bathroomType` | Shared or private bathroom value |
| `furnished` | Furnishing boolean derived from public facilities |
| `housemates`, `housematesGender` | Current shared-housing signals |
| `capacity` | Available tenant places |
| `latitude`, `longitude` | Public approximate map coordinates |
| `rating`, `reviewCount` | Search-card rating signals when present |
| `favoritesCount` | Public favorite count |
| `registrationPossible` | Address-registration availability |
| `cancellationPolicy`, `contractType` | Rental policy metadata |
| `facilities` | Normalized facility and amenity values |
| `photos` | Public listing photo URLs |
| `description` | Public property description |
| `landlordName`, `landlordType` | Public advertiser fields |
| `badges` | Tenant-verified or flexible-cancellation badges |
| `sourceSearchUrl`, `searchPage` | Discovery provenance |
| `searchResultTotal` | Total shown by the source search |
| `scrapedAt` | ISO timestamp of collection |

Fields remain optional when HousingAnywhere does not display them for a listing.

### How much does it cost to scrape HousingAnywhere listings?

This Actor uses pay-per-event pricing:

- a small one-time start charge covers run initialization;
- each unique rental row saved triggers one `listing` event;
- account tiers receive volume-adjusted per-listing prices.

The input cap gives you direct control over run size. A small first run with 8 listings is suitable for checking the output before scaling. Your Apify Console shows the exact price for your account tier before starting a run.

### How to scrape HousingAnywhere in 5 steps

1. Open the Actor input page.
2. Paste a HousingAnywhere search URL or individual listing URL.
3. Set **Maximum rental listings** to the required volume.
4. Keep **Enrich from listing pages** enabled for complete records.
5. Click **Start**, then export the dataset in your preferred format.

Search filters already encoded in a HousingAnywhere URL are preserved.

### Input parameters

#### `searchUrls`

HousingAnywhere search pages beginning with `/s/`, including localized paths and property-type filters.

Example:

```text
https://housinganywhere.com/s/Amsterdam--Netherlands/private-rooms
````

#### `listingUrls`

Optional public detail URLs beginning with `/room/ut...`.

#### `maxListings`

Global maximum number of unique rental records. Default: `20`. Allowed range: `1–5000`.

#### `includeDetails`

When `true`, fetch detail pages for amenities, photos, deposits, location, descriptions, and rental policies. Default: `true`.

#### `maxPagesPerSearch`

Maximum pagination depth for each search URL. Default: `10`. Allowed range: `1–100`.

### Example input: Amsterdam private rooms

```json
{
  "searchUrls": [
    { "url": "https://housinganywhere.com/s/Amsterdam--Netherlands/private-rooms" }
  ],
  "maxListings": 20,
  "includeDetails": true,
  "maxPagesPerSearch": 3
}
```

### Example input: one rental listing

```json
{
  "listingUrls": [
    { "url": "https://housinganywhere.com/room/ut1194020/nl/Amsterdam/weerdestein" }
  ],
  "maxListings": 1,
  "includeDetails": true,
  "maxPagesPerSearch": 1
}
```

### Example output

```json
{
  "listingId": "ut1194020",
  "url": "https://housinganywhere.com/room/ut1194020/nl/Amsterdam/weerdestein",
  "title": "private room in apartment in Weerdestein, Amsterdam",
  "street": "Weerdestein",
  "city": "Amsterdam",
  "country": "Netherlands",
  "propertyType": "private room in apartment",
  "monthlyRent": 1500,
  "currency": "EUR",
  "utilitiesIncluded": true,
  "bedroomCount": 1,
  "bedroomSizeM2": 10,
  "propertySizeM2": 12,
  "furnished": true,
  "housemates": 3,
  "registrationPossible": true,
  "scrapedAt": "2026-07-20T03:00:00.000Z"
}
```

Live values change over time; the example shows the output shape rather than a price guarantee.

### Search versus detail enrichment

With `includeDetails: false`, search runs are faster and return card-level fields such as rent, availability, room size, housemates, rating, badges, and a preview photo.

With `includeDetails: true`, the Actor adds richer listing-level fields. Choose detail mode for market analysis and no-detail mode for frequent lightweight discovery scans.

Direct `listingUrls` always require a detail request because there is no search card to use as a base record.

### Pagination and deduplication

HousingAnywhere currently serves paginated public searches. The Actor increments the `page` query parameter and stops when:

- the configured listing cap is reached;
- the source-reported result total is exhausted;
- no new listing IDs appear; or
- `maxPagesPerSearch` is reached.

If the same rental appears in multiple input searches, it is saved only once.

### Tips for reliable rental data

- 🎯 Use specific property-type searches when you need a homogeneous dataset.
- 🧪 Begin with 8–20 listings and inspect the dataset columns.
- ⚡ Disable enrichment for high-frequency inventory checks.
- 🧩 Enable enrichment when deposits, facilities, policies, or photos matter.
- 📅 Schedule equivalent inputs at consistent times for comparable snapshots.
- 🗃️ Store snapshots in named datasets or your own warehouse for change analysis.

### Export and data integrations

Apify datasets support JSON, JSONL, CSV, Excel, XML, RSS, and HTML exports.

Useful workflow patterns include:

- send completed datasets to Google Sheets for relocation coordinators;
- write rental snapshots to BigQuery, Snowflake, or PostgreSQL;
- trigger Slack alerts when new inventory appears below a rent threshold;
- connect Make or Zapier to route listings into review queues;
- use webhooks to start a comparison job after every run;
- download CSV files for analyst review in Excel.

### Scheduling a rental inventory monitor

Create an Apify schedule with a fixed input, such as one city search and a stable listing cap. Run daily or weekly depending on market speed.

To detect changes, compare rows by `listingId` and track:

- newly observed IDs;
- missing IDs;
- changes to `monthlyRent`;
- changes to `availability`;
- changes to furnishing or utilities inclusion.

The Actor produces current snapshots; it does not maintain historical state automatically.

### JavaScript API example

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/housinganywhere-rental-listings-scraper').call({
  searchUrls: [{ url: 'https://housinganywhere.com/s/Amsterdam--Netherlands/private-rooms' }],
  maxListings: 20,
  includeDetails: true,
  maxPagesPerSearch: 3,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Python API example

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/housinganywhere-rental-listings-scraper').call(run_input={
    'searchUrls': [{'url': 'https://housinganywhere.com/s/Amsterdam--Netherlands/private-rooms'}],
    'maxListings': 20,
    'includeDetails': True,
    'maxPagesPerSearch': 3,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### cURL API example

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~housinganywhere-rental-listings-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "searchUrls": [{"url":"https://housinganywhere.com/s/Amsterdam--Netherlands/private-rooms"}],
    "maxListings": 20,
    "includeDetails": true,
    "maxPagesPerSearch": 3
  }'
```

### Use the scraper through MCP

Connect Apify MCP to Claude Code:

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/housinganywhere-rental-listings-scraper"
```

For Claude Desktop, Cursor, or VS Code, add an HTTP MCP server:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/housinganywhere-rental-listings-scraper"
    }
  }
}
```

Example prompts:

- “Scrape 20 furnished HousingAnywhere rentals from this Amsterdam search and rank them by monthly rent.”
- “Extract this HousingAnywhere listing and summarize the deposit, utilities, room size, and registration rules.”
- “Run my saved rental inventory input and return only listings available now.”

### Data quality and limitations

HousingAnywhere controls the source layout, inventory, and visible fields. A listing may omit ratings, exact availability dates, postal codes, facilities, or landlord fields.

Search cards represent the source's current ranked inventory and may include nearby localities. Use the emitted `city` value rather than assuming every result is inside the searched city boundary.

Coordinates are the public coordinates supplied by the listing page and may be approximate for tenant safety.

The Actor does not reveal private contact details, bypass login requirements, make bookings, or message landlords.

### Is it legal to scrape HousingAnywhere?

The Actor extracts publicly visible rental information. Web scraping legality depends on jurisdiction, purpose, contract terms, and how data is stored or redistributed.

You are responsible for:

- having a lawful purpose;
- following applicable privacy and database laws;
- respecting HousingAnywhere terms and platform rights;
- minimizing collection of personal data;
- honoring deletion or correction obligations;
- avoiding harmful, discriminatory, or unsolicited-contact uses.

This documentation is not legal advice.

### Troubleshooting

#### Why did the Actor reject my URL?

Only public `housinganywhere.com` search paths (`/s/...`) and detail paths (`/room/ut...`) are accepted. Put each URL in the matching input field.

#### Why is a field missing?

HousingAnywhere does not expose every field on every rental. Enable detail enrichment and verify the value is public on the source page.

#### Why did a run fail with no listings?

Check that the search still displays rental cards in a normal browser. A complete extraction failure is reported as an error instead of producing an empty successful dataset.

#### Why did I receive fewer rows than `maxListings`?

The source may contain fewer unique matching rentals, your pagination cap may be reached, or multiple searches may overlap. `maxListings` is a ceiling, not a guaranteed count.

### Frequently asked questions

#### Can I scrape several cities in one run?

Yes. Add multiple HousingAnywhere search URLs. The global cap applies across them.

#### Can I scrape apartments, studios, and rooms?

Yes. Use the appropriate HousingAnywhere search URL and preserve its category path or filters.

#### Does the Actor require a proxy?

The current public search and detail routes work over ordinary HTTP. The Actor does not require users to configure a proxy for the supported workflow.

#### Does it download images?

No. It exports public photo URLs, which keeps runs efficient and datasets compact.

#### Can it track changes automatically?

Use Apify schedules for recurring snapshots, then compare rows by `listingId` in your database, spreadsheet, or automation.

### Related real estate scrapers

Combine this Actor with other Automation Lab tools when your workflow covers additional markets:

- [Zillow Scraper](https://apify.com/automation-lab/zillow-scraper) for US property listings
- [Airbnb Listing Scraper](https://apify.com/automation-lab/airbnb-listing-scraper) for short-term rental inventory
- [Google Maps Scraper](https://apify.com/automation-lab/google-maps-scraper) for local businesses and neighborhood research

Use source-specific Actors rather than treating different rental marketplaces as identical datasets.

### Support

If a valid public HousingAnywhere search or listing stops producing expected fields, open an issue on the Actor page and include:

- the input URL;
- the approximate run time;
- the run ID;
- the missing field or unexpected behavior;
- whether detail enrichment was enabled.

Do not include private account credentials or personal contact information.

# Actor input Schema

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

Add city, country, or property-type search URLs from housinganywhere.com. Filters already present in each URL are preserved.

## `listingUrls` (type: `array`):

Optional HousingAnywhere /room/ut... URLs to extract directly.

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

Stop after saving this many unique listings across all inputs.

## `includeDetails` (type: `boolean`):

Fetch each public detail page for amenities, photos, coordinates, deposits, descriptions, and landlord fields.

## `maxPagesPerSearch` (type: `integer`):

Safety limit for pagination of each HousingAnywhere search URL.

## Actor input object example

```json
{
  "searchUrls": [
    {
      "url": "https://housinganywhere.com/s/Amsterdam--Netherlands/private-rooms"
    }
  ],
  "listingUrls": [],
  "maxListings": 8,
  "includeDetails": true,
  "maxPagesPerSearch": 2
}
```

# Actor output Schema

## `overview` (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 = {
    "searchUrls": [
        {
            "url": "https://housinganywhere.com/s/Amsterdam--Netherlands/private-rooms"
        }
    ],
    "maxListings": 8,
    "includeDetails": true,
    "maxPagesPerSearch": 2
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/housinganywhere-rental-listings-scraper").call(input);

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = {
    "searchUrls": [{ "url": "https://housinganywhere.com/s/Amsterdam--Netherlands/private-rooms" }],
    "maxListings": 8,
    "includeDetails": True,
    "maxPagesPerSearch": 2,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/housinganywhere-rental-listings-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "searchUrls": [
    {
      "url": "https://housinganywhere.com/s/Amsterdam--Netherlands/private-rooms"
    }
  ],
  "maxListings": 8,
  "includeDetails": true,
  "maxPagesPerSearch": 2
}' |
apify call automation-lab/housinganywhere-rental-listings-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "HousingAnywhere Rental Listings Scraper",
        "description": "🏠 Extract public HousingAnywhere rentals with rent, availability, furnishing, amenities, photos, deposits, coordinates, landlord fields, and search metadata.",
        "version": "0.1",
        "x-build-id": "ODuvPuhdX0zRuvx8g"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~housinganywhere-rental-listings-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-housinganywhere-rental-listings-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/automation-lab~housinganywhere-rental-listings-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-housinganywhere-rental-listings-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/automation-lab~housinganywhere-rental-listings-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-housinganywhere-rental-listings-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "searchUrls": {
                        "title": "🏙️ HousingAnywhere search URLs",
                        "type": "array",
                        "description": "Add city, country, or property-type search URLs from housinganywhere.com. Filters already present in each URL are preserved.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "listingUrls": {
                        "title": "🏠 Individual listing URLs",
                        "type": "array",
                        "description": "Optional HousingAnywhere /room/ut... URLs to extract directly.",
                        "default": [],
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxListings": {
                        "title": "Maximum rental listings",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Stop after saving this many unique listings across all inputs.",
                        "default": 20
                    },
                    "includeDetails": {
                        "title": "Enrich from listing pages",
                        "type": "boolean",
                        "description": "Fetch each public detail page for amenities, photos, coordinates, deposits, descriptions, and landlord fields.",
                        "default": true
                    },
                    "maxPagesPerSearch": {
                        "title": "Maximum pages per search",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Safety limit for pagination of each HousingAnywhere search URL.",
                        "default": 10
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
