# Trulia Scraper (`automation-lab/trulia-scraper`) Actor

🏠 Export public Trulia sale, rental, and sold listings with prices, addresses, coordinates, features, broker attribution, photos, and page provenance.

- **URL**: https://apify.com/automation-lab/trulia-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 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/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

## Trulia Scraper

Export public Trulia property listings from sale, rental, and sold searches into clean JSON, CSV, Excel, XML, or RSS data.

Paste the filtered Trulia search URL you already use and receive structured prices, addresses, coordinates, beds, baths, square footage, listing status, broker attribution, freshness tags, photos, and page provenance.

No Trulia login is required.

### What does Trulia Scraper do?

Trulia Scraper turns Trulia search-result pages into analysis-ready property records.

It can:

- 🏠 collect homes for sale;
- 🔑 collect properties for rent;
- 📈 collect recently sold properties;
- 🎛️ preserve the location and filters encoded in your Trulia URL;
- 📄 follow multiple result pages;
- 🔁 remove duplicate listings across pages and searches;
- 🖼️ export available card photos;
- 🧾 preserve broker, agent, provider, and source attribution;
- 🕐 add scrape timestamps and page provenance for monitoring.

The Actor uses an HTTP-first extraction route and automatically manages the US residential proxy sessions needed by Trulia.

### Who is Trulia Scraper for?

#### Real-estate investors

Build candidate lists for a buy box, compare asking prices, and monitor fresh listings in target markets.

#### Agents and brokerages

Export filtered market inventory, review competing listings, and feed internal prospecting or market-report workflows.

#### Proptech and data teams

Collect normalized property records for dashboards, enrichment pipelines, quality checks, and source comparison.

#### Market researchers

Create repeatable snapshots of rental, sale, or sold inventory with numeric fields suitable for analysis.

#### Lead and data vendors

Produce source-attributed listing feeds for approved downstream workflows without manually copying search cards.

### Why use this Trulia listing extractor?

Manual copying is slow and loses context. This Actor keeps stable IDs, both formatted and numeric values, and the URL that produced each record.

Key benefits include:

- ✅ one input for sale, rental, and sold search URLs;
- ✅ useful typed fields rather than raw HTML;
- ✅ automatic pagination with explicit limits;
- ✅ deduplication by ZPID or listing identity;
- ✅ conservative retry behavior for blocked sessions;
- ✅ standard Apify exports and integrations;
- ✅ pay-per-result billing rather than a monthly subscription.

### What Trulia data can I extract?

| Field | Description |
|---|---|
| `recordId` | Stable normalized property/listing identity |
| `zpid` | Zillow property ID when Trulia provides it |
| `listingId` | Trulia listing ID |
| `providerListingId` | Provider or builder listing ID when available |
| `url` | Canonical Trulia property URL |
| `status` | For sale, for rent, sold, or another reported status |
| `listingType` | Resale, new home, rental, or another listing classification |
| `propertyType` | Single-family home, condo, townhouse, and similar types |
| `address` | Full formatted address |
| `city`, `state`, `zipCode` | Parsed location components |
| `latitude`, `longitude` | Map coordinates |
| `price`, `priceMax` | Exact price or numeric minimum/maximum for rental ranges |
| `formattedPrice` | Display price such as `$725,000` or `$2,583 - $4,757/mo` |
| `beds`, `bedsMax` | Exact beds or numeric minimum/maximum |
| `baths`, `bathsMax` | Exact baths or numeric minimum/maximum |
| `sqft`, `sqftMax` | Exact area or numeric minimum/maximum |
| `lotSize` | Formatted lot dimension when available |
| `tags` | Freshness and listing labels |
| `dateListed` | Listing date when present |
| `broker`, `agent`, `provider` | Source attribution |
| `photos` | Available listing-card photo URLs |
| `sourceUrl` | Input search URL that produced the record |
| `fetchedPage` | Result page number |
| `scrapedAt` | UTC extraction timestamp |

Some fields can be `null` because Trulia does not show every value on every search card.

### How to scrape Trulia listings

1. Open Trulia and create a sale, rental, or sold search.
2. Apply your desired location and filters.
3. Copy the resulting Trulia URL.
4. Open Trulia Scraper on Apify.
5. Paste the URL into **Trulia search URLs**.
6. Choose a small maximum listing count for your first run.
7. Click **Start**.
8. Preview the dataset and export it in your preferred format.

For recurring monitoring, save the Actor input as an Apify task and schedule that task.

### Input

A minimal input looks like this:

```json
{
  "startUrls": [
    { "url": "https://www.trulia.com/for_sale/Austin,TX/" }
  ],
  "maxItems": 20,
  "maxPages": 2
}
````

#### Input fields

| Input | Type | Default | Purpose |
|---|---|---:|---|
| `startUrls` | array | required | Public Trulia sale, rental, or sold search URLs |
| `maxItems` | integer | `20` | Global maximum unique listings |
| `maxPages` | integer | `5` | Maximum result pages per URL |
| `maxRequestRetries` | integer | `5` | Fresh sessions tried after a block or network error |

The Actor rejects non-Trulia hosts and Trulia property-detail URLs. Configure your filters on a Trulia search and paste that search URL.

### Search URL examples

#### Homes for sale

```text
https://www.trulia.com/for_sale/Austin,TX/
```

#### Rentals

```text
https://www.trulia.com/for_rent/Austin,TX/
```

#### Sold properties

```text
https://www.trulia.com/sold/Austin,TX/
```

Trulia may redirect these friendly routes to a canonical location route. The Actor follows that redirect and uses the canonical route for pagination.

### Output example

```json
{
  "recordId": "29476130",
  "zpid": "29476130",
  "listingId": "7029476130",
  "url": "https://www.trulia.com/home/example-29476130",
  "status": "for sale",
  "listingType": "resale",
  "propertyType": "single-family home",
  "address": "7607 Williamson Creek Dr, Austin, TX 78736",
  "city": "Austin",
  "state": "TX",
  "zipCode": "78736",
  "latitude": 30.246248,
  "longitude": -97.915215,
  "price": 275000,
  "formattedPrice": "$275,000",
  "currency": "USD",
  "beds": 3,
  "baths": 1,
  "sqft": 1026,
  "formattedSqft": "1,026 sqft",
  "tags": ["NEW - 1 MIN AGO", "0.9 ACRES"],
  "broker": "Texas Income Property",
  "photoCount": 15,
  "sourceUrl": "https://www.trulia.com/for_sale/Austin,TX/",
  "fetchedPage": 1,
  "scrapedAt": "2026-07-17T17:34:20.696Z"
}
```

Values change as Trulia listings change. The example shows the shape, not a promise that the property remains active.

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

Trulia Scraper uses pay-per-event pricing:

- a small one-time fee when a run starts;
- a tiered fee for each unique listing saved to the dataset.

The formula-derived BRONZE rate is **$0.00037705 per listing**, or about **$0.38 per 1,000 listings**, plus the run-start fee. Higher Apify plans receive lower per-listing rates.

The final charge depends on the number of records produced. Set `maxItems` to control scope and cost.

### Pagination and result limits

Trulia usually exposes up to 40 search cards per result page.

`maxItems` is a global cap across every input URL. `maxPages` is applied separately to each URL.

For example:

```json
{
  "startUrls": [
    { "url": "https://www.trulia.com/for_sale/Austin,TX/" },
    { "url": "https://www.trulia.com/for_sale/Dallas,TX/" }
  ],
  "maxItems": 100,
  "maxPages": 3
}
```

The Actor stops as soon as it reaches 100 unique listings, even if more pages remain.

### Filtering Trulia searches

The Actor preserves filters encoded in the supplied URL. This keeps its input simple and aligned with Trulia's own search controls.

Useful filter workflows include:

- location or ZIP code;
- sale, rent, or sold status;
- minimum and maximum price;
- bedrooms and bathrooms;
- property type;
- square footage;
- open houses or listing freshness, when Trulia exposes those controls.

Always verify the filtered result page in your browser before copying its URL.

### Monitoring new listings and price changes

Run the same search on a schedule and compare records by `recordId` or `zpid`.

A practical monitoring pipeline is:

1. create an Apify task with a stable filtered URL;
2. schedule it hourly or daily;
3. send dataset items to a webhook, database, or automation platform;
4. compare `price`, `status`, and `tags` with the previous snapshot;
5. alert only when a tracked value changes.

The `sourceUrl`, `fetchedPage`, and `scrapedAt` fields make each observation auditable.

### Integrations

#### Google Sheets

Use the Apify Google Sheets integration to append new listing records to a market tracker.

#### Webhooks

Trigger a webhook when a run succeeds, then pull dataset items into your data pipeline.

#### Zapier and Make

Create workflows that route matching listings to Slack, email, a CRM, or a review queue.

#### Databases and warehouses

Export JSON or CSV to PostgreSQL, BigQuery, Snowflake, object storage, or your preferred ELT process.

#### Scheduled tasks

Turn a tested input into an Apify task and schedule it for repeatable inventory snapshots.

### API usage with JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/trulia-scraper').call({
  startUrls: [{ url: 'https://www.trulia.com/for_sale/Austin,TX/' }],
  maxItems: 20,
  maxPages: 2,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("automation-lab/trulia-scraper").call(run_input={
    "startUrls": [{"url": "https://www.trulia.com/for_rent/Austin,TX/"}],
    "maxItems": 20,
    "maxPages": 2,
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
```

### API usage with cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~trulia-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "startUrls": [{"url": "https://www.trulia.com/sold/Austin,TX/"}],
    "maxItems": 20,
    "maxPages": 2
  }'
```

Use the returned run ID to inspect status and retrieve the default dataset.

### Use Trulia Scraper with MCP

Connect Apify's MCP server to Claude Code or another compatible client:

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

#### Claude Desktop setup

Use this Claude Desktop configuration:

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

#### Cursor setup

Add the same MCP URL in **Cursor → Settings → MCP** and name the server `apify`.

#### VS Code setup

Add the Apify MCP URL to your VS Code MCP server configuration, then enable the `automation-lab/trulia-scraper` tool.

Example prompts:

- “Run the Trulia scraper for this Austin rental search and return 20 listings.”
- “Export the sale listings, then group them by property type.”
- “Compare prices from today's dataset with yesterday's IDs.”

### Data quality tips

- Start with one verified URL and a low `maxItems` value.
- Keep `maxPages` proportionate to the expected market size.
- Use `recordId` or `zpid` for deduplication across runs.
- Prefer numeric fields for calculations and formatted fields for reports.
- Treat `null` as “not shown on the search card,” not as zero.
- For rental-community ranges, use the base numeric field as the minimum and the corresponding `Max` field as the upper bound.
- Preserve `broker` and `provider` attribution in downstream products.
- Review records after changing Trulia filters.

### Reliability and anti-bot handling

Trulia protects result pages with PerimeterX.

The Actor automatically uses US residential sessions, browser-like HTTP fingerprints, challenge detection, and bounded session rotation. It does not ask users to provide cookies or solve CAPTCHAs.

A temporary shortage of usable sessions can still cause a run to fail. Retry the run later rather than setting unlimited retries. Bounded failure is safer and makes missing output visible.

### Limitations

- The initial release extracts search-result cards, not full property-detail pages.
- Neighborhood amenities, schools, demographics, tax history, and contact details are not enriched.
- Field availability depends on listing type and what Trulia displays.
- Trulia can change payloads, URL routes, filters, or anti-bot behavior.
- Search totals can change while pagination is in progress.
- The Actor supports public US Trulia search pages only.
- Results are not an MLS feed and should not be represented as one.

### Legal and responsible use

Trulia Scraper extracts publicly visible listing information.

You are responsible for using the data lawfully and for complying with applicable website terms, database rights, privacy rules, fair-housing requirements, MLS attribution rules, and downstream licensing obligations.

Do not use the Actor to access private accounts, contact people unlawfully, discriminate, or make regulated decisions without appropriate review. Avoid collecting more data than your legitimate workflow needs.

### Troubleshooting

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

The Actor accepts only public `trulia.com` search-result URLs. A property detail URL under `/home/`, a shortened URL, or another domain fails closed. Open a search page and copy its URL instead.

#### Why did the run fail after several retries?

Trulia may have challenged every residential session sampled during that run. Wait briefly and retry. If the problem persists, check the Actor run log for HTTP status and payload errors.

#### Why are some fields null?

Trulia search cards do not show every field for every listing. For example, sold cards, land, new construction, and rentals can have different field availability.

#### Why are fewer records returned than `maxItems`?

The filtered search may contain fewer listings, `maxPages` may be too low, or the source may have returned duplicates. Increase page depth only when Trulia shows more pages.

### FAQ

#### Does Trulia Scraper require a Trulia account?

No. It covers public search pages and does not use saved homes, messaging, or private account data.

#### Can it scrape rentals and sold homes?

Yes. Supply the corresponding public Trulia rental or sold search URL.

#### Can I paste multiple searches?

Yes. Add multiple entries to `startUrls`. The global `maxItems` limit applies across all of them.

#### Does it download image files?

No. It exports the photo URLs exposed in each search card, keeping runs faster and datasets lightweight.

#### Can it scrape property details?

Not in the initial release. The Actor focuses on reliable search exports. Use the listing URL as a key for a separately authorized enrichment workflow.

#### How often should I run a monitor?

Choose a schedule that matches your use case and source freshness. Daily runs suit many market snapshots; high-priority new-listing workflows may run more frequently.

### Related real-estate scrapers

Expand source coverage with other Automation Lab Actors:

- [Zillow Scraper](https://apify.com/automation-lab/zillow-scraper) for Zillow search and property data;
- [Realtor.com Scraper](https://apify.com/automation-lab/realtor-com-scraper) for Realtor.com listings;
- [Redfin Scraper](https://apify.com/automation-lab/redfin-scraper) for Redfin market data.

Use separate source IDs and attribution when combining datasets.

### Start exporting Trulia listings

Open a filtered Trulia search, copy its URL, keep the first run small, and start the Actor.

Your result appears in the default dataset and can be previewed, downloaded, scheduled, or sent to another service through the Apify platform.

# Actor input Schema

## `startUrls` (type: `array`):

Public Trulia search-result URLs. Configure location and filters on Trulia, then paste the resulting URL here.

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

Stop after saving this many unique property listings across all URLs.

## `maxPages` (type: `integer`):

Maximum Trulia result pages to request for each input URL (up to 40 listings per page).

## `maxRequestRetries` (type: `integer`):

Number of fresh US residential sessions to retry after a CAPTCHA, block, or transient network error.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.trulia.com/for_sale/Austin,TX/"
    }
  ],
  "maxItems": 20,
  "maxPages": 2,
  "maxRequestRetries": 5
}
```

# 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 = {
    "startUrls": [
        {
            "url": "https://www.trulia.com/for_sale/Austin,TX/"
        }
    ],
    "maxItems": 20,
    "maxPages": 2,
    "maxRequestRetries": 5
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/trulia-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 = {
    "startUrls": [{ "url": "https://www.trulia.com/for_sale/Austin,TX/" }],
    "maxItems": 20,
    "maxPages": 2,
    "maxRequestRetries": 5,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/trulia-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 '{
  "startUrls": [
    {
      "url": "https://www.trulia.com/for_sale/Austin,TX/"
    }
  ],
  "maxItems": 20,
  "maxPages": 2,
  "maxRequestRetries": 5
}' |
apify call automation-lab/trulia-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Trulia Scraper",
        "description": "🏠 Export public Trulia sale, rental, and sold listings with prices, addresses, coordinates, features, broker attribution, photos, and page provenance.",
        "version": "0.1",
        "x-build-id": "bTAO6ebTec6zR3OJc"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~trulia-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-trulia-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~trulia-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-trulia-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~trulia-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-trulia-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": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "🏘️ Trulia search URLs",
                        "type": "array",
                        "description": "Public Trulia search-result URLs. Configure location and filters on Trulia, then paste the resulting URL here.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum listings",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Stop after saving this many unique property listings across all URLs.",
                        "default": 20
                    },
                    "maxPages": {
                        "title": "Maximum pages per URL",
                        "minimum": 1,
                        "maximum": 25,
                        "type": "integer",
                        "description": "Maximum Trulia result pages to request for each input URL (up to 40 listings per page).",
                        "default": 5
                    },
                    "maxRequestRetries": {
                        "title": "Retries after a blocked request",
                        "minimum": 0,
                        "maximum": 8,
                        "type": "integer",
                        "description": "Number of fresh US residential sessions to retry after a CAPTCHA, block, or transient network error.",
                        "default": 5
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```