# Redfin Real Estate Listings (`truefetch/redfin-real-estate-listings`) Actor

Search Redfin real estate listings in the United States and Canada. Collect for-sale property data with prices, homes, condos, locations, photos, listing details, and source URLs.

- **URL**: https://apify.com/truefetch/redfin-real-estate-listings.md
- **Developed by:** [TrueFetch](https://apify.com/truefetch) (community)
- **Categories:** Real estate, Lead generation, Agents
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $13.00 / 1,000 results

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

> **Affiliate disclosure:** Apify links on this page may include referral parameters. If you sign up through one of these links, TrueFetch may earn a commission from Apify at no extra cost to you. Pricing, features, and Actor access are unaffected.

[![Redfin Real Estate Listings](https://img.shields.io/badge/Redfin%20Listings-1B4F9A?style=for-the-badge&logoColor=white)](https://apify.com/truefetch/redfin-real-estate-listings?fpr=aiagentapi)
[![Real Estate Data](https://img.shields.io/badge/Real%20Estate%20Listings-1F8A70?style=for-the-badge)](https://apify.com/truefetch/redfin-real-estate-listings?fpr=aiagentapi)
[![Pay per Result](https://img.shields.io/badge/%2413.00%20per%201%2C000%20listings-2E8B57?style=for-the-badge)](https://apify.com/truefetch/redfin-real-estate-listings?fpr=aiagentapi)
[![No Cookies](https://img.shields.io/badge/No%20Login%20%7C%20No%20Cookies-555555?style=for-the-badge)](https://apify.com/truefetch/redfin-real-estate-listings?fpr=aiagentapi)
[![Telegram Support](https://img.shields.io/badge/Telegram-Support-26A5E4?style=for-the-badge&logo=telegram&logoColor=white)](https://t.me/AiAgentApi)
[![Telegram Group](https://img.shields.io/badge/Telegram-Group-26A5E4?style=for-the-badge&logo=telegram&logoColor=white)](https://t.me/Apify_Actor)

## Redfin Real Estate Listings — US and Canada Homes API

**Search Redfin — a tech-first US real estate brokerage known for fast-updating listings, agent-reviewed accuracy, and competitive market insights across the United States and Canada — and return structured real estate data in one Apify Actor run.** Results include prices, listing status, property type, descriptions, images, agent or agency details, and source URLs as clean JSON / CSV / Excel. No platform login, cookies, or API keys required.

> **TL;DR (40-word answer):** Redfin Real Estate Listings is a no-login Apify Actor that returns 40+ structured fields per Redfin property listing from the United States and Canada at **$13.00 per 1,000 results**, with location-aware inputs, managed reliability, and JSON / CSV / Excel export.

> **What it is NOT:** Redfin Real Estate Listings is _not_ a Redfin brokerage account, buyer's agent service, tour booking tool, mortgage originator, or listing publication service — it reads public Redfin listing pages and returns structured listing data only.

> **Redfin Real Estate Listings is an Apify Actor for collecting public property listing data from Redfin across the United States and Canada.** Search by location, choose listing status such as `for_sale`, `for_rent`, or `sold`, and export a dataset with price, address, property type, media, agent metadata, and source URL. Built for US and Canada property market research, competitive market analysis, investment screening, CRM enrichment, and AI agents using the Apify API or MCP. Maintained by TrueFetch on the Apify Store.

---

### 💼 Why choose Redfin Real Estate Listings

**Redfin Real Estate Listings is best for** US and Canada property investors, home buyers targeting competitive markets, market analysts, lead generation teams, and AI agents that need structured Redfin listing data with reliable location-aware routing.

- **🌍 Redfin coverage for the United States and Canada** — collect listings from Redfin with location-aware inputs covering major US metros, tech hub cities, suburban markets, and Canadian cities where Redfin operates.
- **🏠 40+ fields per listing** — title, listing type, property type, price, currency, bedrooms, bathrooms, area, address, location, images, agent or agency fields, and source URLs when available.
- **🛡️ Managed reliability built in** — request retries, proxy-aware collection, deduplication, and consistent dataset output are handled by the Actor.
- **📊 Unified export format** — use JSON, JSONL, CSV, Excel, XML, RSS, or the Apify dataset API without building your own parser.
- **⚡ Pay-per-result, not per-CPU** — flat **$13.00 per 1,000 successful listings** (`$0.0130` per result). Free Apify plan includes $5 monthly credits ≈ **~384 free listings per month**.

---

### 🚀 Quick Start — run in 3 steps

#### Run in Apify Console

1. **Open the Actor** — go to [Redfin Real Estate Listings on Apify](https://apify.com/truefetch/redfin-real-estate-listings?fpr=aiagentapi) and click **Try for free**.
2. **Configure inputs** — choose a `country`, enter a `location`, set `listing_type`, and choose `max_results`.
3. **Click Start** — the Actor streams real estate listings to the dataset. Export as JSON, JSONL, CSV, Excel, XML, RSS, or pull via the dataset API.

#### Run via Apify API

```bash
curl -X POST "https://api.apify.com/v2/acts/TrueFetch~redfin-real-estate-listings/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "country": "United States",
    "location": "Seattle, WA",
    "listing_type": "for_sale",
    "max_results": 100
}'
````

#### Run via MCP (for AI agents)

Redfin Real Estate Listings is callable from Claude, ChatGPT, Cursor, and any MCP-compatible client through the [Apify MCP Server](https://docs.apify.com/platform/integrations/mcp?fpr=aiagentapi). Reference the Actor as `TrueFetch/redfin-real-estate-listings` and pass the same JSON input as above.

***

### ⚙️ Input parameters

| Parameter       | Type    | Required | Default    | Description                                                                               | Example         |
| --------------- | ------- | :------: | ---------- | ----------------------------------------------------------------------------------------- | --------------- |
| `country`       | string  |    ✅    | —          | Supported Redfin market. United States and Canada are supported.                          | `United States` |
| `location`      | string  |    ✅    | —          | City, region, neighborhood, postal code, or address to search.                            | `Seattle, WA`   |
| `max_results`   | integer |    ✅    | —          | Maximum number of real estate listings to return. Each successful listing is billed once. | `100`           |
| `listing_type`  | string  |    ❌    | `for_sale` | Listing status such as `for_sale`, `for_rent`, or `sold` where supported.                 | `for_sale`      |
| `property_type` | string  |    ❌    | empty      | Optional property type filter. Leave empty to include all supported property types.       | `house`         |

**Default behavior:** the Actor queries the supported source for the selected country and location, deduplicates by source URL or listing ID, and streams results to the default dataset.

```json
{
  "country": "United States",
  "location": "Seattle, WA",
  "listing_type": "for_sale",
  "max_results": 100
}
```

***

### 📦 Output dataset

Each run writes structured real estate objects to the **default Apify dataset**, exportable as JSON, JSONL, CSV, Excel, XML, RSS, or via the dataset API.

| Field           | Type   | Always present? | Description                                                   | Example                                               |
| --------------- | ------ | :-------------: | ------------------------------------------------------------- | ----------------------------------------------------- |
| `platform`      | string |       ✅        | Source platform name.                                         | `Redfin`                                              |
| `source_url`    | string |       ✅        | Original listing URL for verification.                        | `https://example.com/listing/123`                     |
| `title`         | string |       ✅        | Listing title.                                                | `Modern 2 bedroom apartment`                          |
| `description`   | string |    optional     | Clean listing description when available.                     | `Bright apartment near transit with updated kitchen.` |
| `listing_id`    | string |    optional     | Platform listing identifier.                                  | `123456789`                                           |
| `listing_type`  | string |    optional     | `for_sale`, `for_rent`, or `sold`.                            | `for_sale`                                            |
| `property_type` | string |    optional     | House, apartment, condo, land, commercial, or similar.        | `house`                                               |
| `price`         | object |    optional     | Price value, text, and currency when available.               | `{"value": 750000, "currency": "USD"}`                |
| `beds`          | number |    optional     | Bedroom count.                                                | `3`                                                   |
| `baths`         | number |    optional     | Bathroom count.                                               | `2`                                                   |
| `area`          | object |    optional     | Floor area or lot area with unit.                             | `{"value": 1450, "unit": "sqft"}`                     |
| `address`       | object |    optional     | Structured address fields when available.                     | `{"city": "Denver", "region": "CO"}`                  |
| `location`      | string |    optional     | Human-readable location.                                      | `Seattle, WA`                                         |
| `geo`           | object |    optional     | Latitude and longitude when available.                        | `{"lat": 39.7392, "lon": -104.9903}`                  |
| `image_urls`    | array  |    optional     | Deduplicated listing image URLs.                              | `["https://images.example.com/1.jpg"]`                |
| `agent`         | object |    optional     | Agent, agency, phone, email, or profile data when available.  | `{"name": "Jane Agent"}`                              |
| `official_url`  | string |    optional     | Official outbound URL when explicitly provided by the source. | `https://agency.example.com/listing/123`              |

#### Sample output

```json
{
  "platform": "Redfin",
  "source_url": "https://example.com/listing/123",
  "title": "Modern 2 bedroom apartment",
  "listing_type": "for_sale",
  "property_type": "apartment",
  "price": { "value": 750000, "currency": "USD", "text": "$750,000" },
  "beds": 2,
  "baths": 2,
  "location": "Seattle, WA",
  "image_urls": ["https://images.example.com/property.jpg"]
}
```

***

### 💡 Use cases

#### For real estate investors and analysts

Track for-sale, for-rent, or recently sold Redfin listings in target US or Canadian locations, compare asking prices across neighborhoods, monitor days-on-market trends, and export clean datasets for competitive market analysis and investment screening.

#### For agencies and lead generation teams

Collect Redfin listing metadata, agent or agency fields where available, source URLs, and location details to power prospecting, listing intelligence, and CRM enrichment workflows.

#### For property portals and data products

Use scheduled runs to refresh your US and Canada listing feed with Redfin data. Deduplicate on `source_url` or `listing_id`, then push structured fields to your database or downstream data product.

#### For AI agents and research assistants

Call this Actor through the Apify API or MCP server to answer US and Canada property market questions — competitive market tiers, price per sqft, inventory levels — with live Redfin data instead of stale training data.

***

### 💰 Pricing, limits, and performance

| Fact                        | Value                                             |
| --------------------------- | ------------------------------------------------- |
| Pricing model               | Pay-per-result (event: `result`)                  |
| Per-result price            | **$0.0130 per listing = $13.00 per 1,000**        |
| Free-tier monthly allowance | $5 Apify credits ≈ **~384 free listings / month** |
| Supported source            | Redfin                                            |
| Supported markets           | the United States and Canada                      |
| Output fields per listing   | **40+**                                           |
| Login / cookies required    | **No** — works without a platform account         |
| Export formats              | JSON, JSONL, CSV, Excel, XML, RSS, dataset API    |

You are billed only for **successfully delivered, deduplicated real estate listings**. Blocked requests, retries, and duplicates are not billed as result events.

***

### ⚖️ Compared with alternatives

| Capability                    | **Redfin Real Estate Listings** | Manual browsing |   In-house scraper   |
| ----------------------------- | :-----------------------------: | :-------------: | :------------------: |
| Structured listing dataset    |               ✅                |       ❌        |      you build       |
| No platform login required    |               ✅                |     varies      |        varies        |
| JSON / CSV / Excel export     |               ✅                |       ❌        |      you build       |
| Managed retries and stability |               ✅                |       ❌        |     you maintain     |
| Source URL for verification   |               ✅                |     manual      |      you build       |
| Pay-per-result pricing        |               ✅                |    time cost    | infrastructure + dev |
| Setup time to first result    |          < 60 seconds           |     manual      |    days to weeks     |

**Verdict.** Use Redfin Real Estate Listings when you need structured real estate listing data without building and maintaining platform-specific scraping infrastructure.

***

### ⚠️ Common mistakes to avoid

1. **Using a vague location.** Prefer city, postal code, neighborhood, or address formats supported by the selected platform.
2. **Expecting every field on every listing.** Some platforms or sellers do not publish agent, area, geo, or fee fields.
3. **Setting `max_results` too high for narrow searches.** A small neighborhood may not have enough matching listings.
4. **Confusing missing fields with parser failure.** If the raw source does not publish a field, the output should stay empty rather than invent a value.
5. **Ignoring source URLs.** Always keep `source_url` for verification and downstream deduplication.

***

### 🛠️ Troubleshooting

| Problem                               | Likely cause                                           | Fix                                                               |
| ------------------------------------- | ------------------------------------------------------ | ----------------------------------------------------------------- |
| Fewer results than `max_results`      | The source has fewer matching listings.                | Try a broader location, different listing type, or larger market. |
| Run returns 0 results                 | Location or listing type is too narrow or unsupported. | Try a major city, postal code, or a supported listing type.       |
| Some prices or agent fields are empty | The source listing did not publish those fields.       | Treat empty values as expected and filter downstream if needed.   |
| Results look unrelated                | Location format may not match the platform's routing.  | Use city/state, postal code, or a more precise address.           |
| Charge limit reached                  | Account-level run or monthly spend limit hit.          | Raise the run or monthly limit in your Apify settings.            |

***

### ❓ FAQ

#### What data does Redfin Real Estate Listings return?

It returns structured Redfin listing data including platform, source URL, title, description, listing type, property type, price, bedrooms, bathrooms, floor area, address, location, geo coordinates, images, and agent or agency details when published by Redfin.

#### How much does Redfin Real Estate Listings cost?

Redfin Real Estate Listings uses pay-per-result pricing at **$0.0130 per listing**, or **$13.00 per 1,000 listings**. The Apify Free plan includes $5 of monthly platform credits, covering approximately **384 free listings per month**.

#### Does Redfin Real Estate Listings require a login or cookies?

No. The Actor reads public Redfin listing pages without a Redfin account, cookies, or source-site API key. You only need an Apify token to invoke the Actor programmatically.

#### Can I export results to CSV or Excel?

Yes. Apify datasets can be exported as JSON, JSONL, CSV, Excel, XML, RSS, or consumed through the dataset API.

#### How does Redfin data compare to Zillow data?

Both Redfin and Zillow cover US and Canada residential listings. Redfin is a direct brokerage with agent-reviewed listings; Zillow aggregates from multiple MLS feeds and broker partners. Many investment and research teams use both sources to cross-reference listing data.

***

### 🔌 Integrations

Use Redfin Real Estate Listings with:

- **Apify API** for backend ingestion.
- **MCP clients** such as Claude, ChatGPT, Cursor, and other AI tools through Apify MCP Server.
- **Make, n8n, Zapier, and webhooks** for no-code workflows.
- **CSV / Excel exports** for analysts and operations teams.
- **Data warehouses** such as BigQuery, Snowflake, Postgres, and internal BI systems.

***

### 🧱 Sister Actors from TrueFetch

#### Jobs

- [Best Job Listing](https://apify.com/truefetch/best-job-listing?fpr=aiagentapi)
- [Indeed Job Listing](https://apify.com/truefetch/indeed-job-listing?fpr=aiagentapi)
- [LinkedIn Job Listing](https://apify.com/truefetch/linkedin-job-listing?fpr=aiagentapi)
- [Glassdoor Job Listing](https://apify.com/truefetch/glassdoor-job-listing?fpr=aiagentapi)

#### Shopping & Deals

- [Amazon Product Listing](https://apify.com/truefetch/amazon-product-listing?fpr=aiagentapi)
- [eBay Listing](https://apify.com/truefetch/ebay-listing?fpr=aiagentapi)
- [Walmart Product Listing](https://apify.com/truefetch/walmart-product-listing?fpr=aiagentapi)
- [Target Product Listing](https://apify.com/truefetch/target-product-listing?fpr=aiagentapi)

#### Vehicles

- [AutoTrader Car Listing](https://apify.com/truefetch/autotrader-car-listing?fpr=aiagentapi)
- [Cars.com Car Listing](https://apify.com/truefetch/carscom-car-listing?fpr=aiagentapi)
- [Webmotors Car Listing](https://apify.com/truefetch/webmotors-car-listing?fpr=aiagentapi)

#### Real Estate

- [Global Real Estate Listings](https://apify.com/truefetch/global-real-estate-listings?fpr=aiagentapi)
- [Zillow Real Estate Listings](https://apify.com/truefetch/zillow-real-estate-listings?fpr=aiagentapi)
- [Realtor Real Estate Listings](https://apify.com/truefetch/realtor-real-estate-listings?fpr=aiagentapi)
- [Rightmove Real Estate Listings](https://apify.com/truefetch/rightmove-real-estate-listings?fpr=aiagentapi)
- [Zoopla Real Estate Listings](https://apify.com/truefetch/zoopla-real-estate-listings?fpr=aiagentapi)
- [Domain Real Estate Listings](https://apify.com/truefetch/domain-real-estate-listings?fpr=aiagentapi)

***

### 📞 Support, changelog, last updated

#### Support

- 💬 **Telegram group:** [t.me/Apify\_Actor](https://t.me/Apify_Actor)
- 📧 **Support:** [t.me/AiAgentApi](https://t.me/AiAgentApi)
- 📖 **Actor page & docs:** <https://apify.com/truefetch/redfin-real-estate-listings?fpr=aiagentapi>

Maintained by **TrueFetch** on the [Apify Store](https://apify.com/TrueFetch?fpr=aiagentapi).

> **Cost of doing nothing:** building a Redfin data pipeline requires tracking frequent interface updates, monitoring listing format changes, and ongoing maintenance as the platform evolves. Redfin Real Estate Listings replaces all of that with a managed, metered, ready-to-run Actor.

#### Changelog

- **2026-06-02** — Updated TrueFetch real estate README, pricing copy, input descriptions, output schema summary, and platform-specific positioning.

***

### JSON-LD

```json
{
  "@context": "https://schema.org",
  "@graph": [
    {
      "@type": "WebSite",
      "@id": "https://apify.com/truefetch/redfin-real-estate-listings#website",
      "url": "https://apify.com/truefetch/redfin-real-estate-listings",
      "name": "Redfin Real Estate Listings",
      "publisher": { "@id": "https://apify.com/TrueFetch#publisher" }
    },
    {
      "@type": "SoftwareApplication",
      "@id": "https://apify.com/truefetch/redfin-real-estate-listings#software",
      "name": "Redfin Real Estate Listings",
      "applicationCategory": "BusinessApplication",
      "operatingSystem": "Cloud",
      "dateModified": "2026-06-03",
      "url": "https://apify.com/truefetch/redfin-real-estate-listings",
      "offers": {
        "@type": "Offer",
        "price": "0.0130",
        "priceCurrency": "USD",
        "description": "Pay per delivered real estate listing"
      },
      "author": { "@id": "https://apify.com/TrueFetch#author-TrueFetch" }
    },
    {
      "@type": "Organization",
      "@id": "https://apify.com/TrueFetch#publisher",
      "name": "TrueFetch",
      "url": "https://apify.com/TrueFetch"
    }
  ]
}
```

***

**Last Updated:** June 03, 2026

**Maintained by:** [TrueFetch](https://apify.com/TrueFetch?fpr=aiagentapi) · 💬 [Telegram Group](https://t.me/Apify_Actor) · 📧 [Support](https://t.me/AiAgentApi)

# Actor input Schema

## `country` (type: `string`):

Country where the target real estate listings are located

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

City, region, neighborhood, postal code, or address to search

## `max_results` (type: `integer`):

Maximum number of real estate listings to return per platform

## `listing_type` (type: `string`):

Listing status to search: for sale, for rent, or sold where supported

## `property_type` (type: `string`):

Optional property type filter. Leave empty to include all supported property types

## Actor input object example

```json
{
  "country": "United States",
  "location": "Seattle, WA",
  "max_results": 10,
  "listing_type": "for_sale"
}
```

# Actor output Schema

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

All property listings found across platforms with structured listing details and source URLs.

# 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 = {
    "country": "United States",
    "location": "Seattle, WA",
    "max_results": 10,
    "listing_type": "for_sale",
    "property_type": ""
};

// Run the Actor and wait for it to finish
const run = await client.actor("truefetch/redfin-real-estate-listings").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 = {
    "country": "United States",
    "location": "Seattle, WA",
    "max_results": 10,
    "listing_type": "for_sale",
    "property_type": "",
}

# Run the Actor and wait for it to finish
run = client.actor("truefetch/redfin-real-estate-listings").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 '{
  "country": "United States",
  "location": "Seattle, WA",
  "max_results": 10,
  "listing_type": "for_sale",
  "property_type": ""
}' |
apify call truefetch/redfin-real-estate-listings --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Redfin Real Estate Listings",
        "description": "Search Redfin real estate listings in the United States and Canada. Collect for-sale property data with prices, homes, condos, locations, photos, listing details, and source URLs.",
        "version": "1.0",
        "x-build-id": "QZ4ZlG0ik6gK4b68M"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/truefetch~redfin-real-estate-listings/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-truefetch-redfin-real-estate-listings",
                "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/truefetch~redfin-real-estate-listings/runs": {
            "post": {
                "operationId": "runs-sync-truefetch-redfin-real-estate-listings",
                "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/truefetch~redfin-real-estate-listings/run-sync": {
            "post": {
                "operationId": "run-sync-truefetch-redfin-real-estate-listings",
                "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": [
                    "country",
                    "location",
                    "max_results"
                ],
                "properties": {
                    "country": {
                        "title": "Country",
                        "enum": [
                            "Canada",
                            "United States"
                        ],
                        "type": "string",
                        "description": "Country where the target real estate listings are located"
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "City, region, neighborhood, postal code, or address to search"
                    },
                    "max_results": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of real estate listings to return per platform"
                    },
                    "listing_type": {
                        "title": "Listing Type",
                        "enum": [
                            "for_sale"
                        ],
                        "type": "string",
                        "description": "Listing status to search: for sale, for rent, or sold where supported"
                    },
                    "property_type": {
                        "title": "Property Type",
                        "enum": [
                            "residential",
                            "house",
                            "apartment",
                            "condo",
                            "townhouse",
                            "land",
                            "commercial",
                            "new_development",
                            "room",
                            "student_housing",
                            "senior_housing",
                            "auction",
                            "ready_to_build",
                            "other"
                        ],
                        "type": "string",
                        "description": "Optional property type filter. Leave empty to include all supported property types"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
