# Global Real Estate Listings (`truefetch/global-real-estate-listings`) Actor

Search real estate listings across supported property marketplaces with one normalized dataset. Collect sale, rental, and sold listings with prices, locations, property details, images, agents, platform names, and source URLs.

- **URL**: https://apify.com/truefetch/global-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, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $11.25 / 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.
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

> **Affiliate disclosure:** Apify links on this page may include referral parameters. If you sign up through them, TrueFetch may receive a commission at no extra cost to you.

**Global Real Estate Listings is a multi-market real estate listings API for collecting normalized sale, rental, and sold property records from 40 supported marketplaces across 24 countries.**

- **40 marketplaces** are mapped to the countries they currently support.
- **40 normalized Dataset fields** cover identity, price, rooms, area, location, media, contacts, source links, and processing metadata.
- **Seven public inputs** provide country, location, platform, result-limit, transaction, property-type, and posted-date controls.
- **Pay-per-event billing** charges one Actor Start event and one Result event for each listing stored in the default Dataset.

[**Run a one-result test**](https://console.apify.com/actors/UYofaeEgDIbwgKawh/input) · [**View API**](https://apify.com/truefetch/global-real-estate-listings/api?fpr=aiagentapi)

With the current local pricing metadata, a FREE-tier test that stores one result costs at most **$0.02250**: $0.01000 for Actor Start plus $0.01250 for one Result. A source can return no matching listing, and current Store pricing should always be checked before a run.

### What does Global Real Estate Listings do?

Global Real Estate Listings searches supported property marketplaces for a country and location, then returns records in one consistent Dataset shape. The Actor is designed for developers and data teams that need comparable listing data without maintaining a separate output model for every source. A record can include the source listing identity, transaction and property types, price components, rooms, area, address, coordinates, images, dates, amenities, agent or agency details, and a URL back to the original listing.

This Actor is a marketplace search and normalization tool. It is **not** a multiple-listing-service feed, valuation service, legal due-diligence product, or guarantee that every source exposes every field. Marketplace coverage, filters, freshness, and field availability remain source-dependent. Global Real Estate Listings is not affiliated with the marketplaces it can search; use the returned source URL to verify material facts before making a property, lending, compliance, or investment decision.

### How do I run Global Real Estate Listings?

1. Open the [Global Real Estate Listings input page](https://console.apify.com/actors/UYofaeEgDIbwgKawh/input).
2. Choose a supported `country` and enter a `location` such as a city, neighborhood, postal code, or address.
3. Set `max_results`. The limit applies **per selected platform**, so selecting several platforms can return more than that number in total.
4. Optionally choose platforms and filters. An omitted platform list uses the compatible sources for the selected country; unsupported filter combinations can leave a platform out of the run.
5. Start the Actor and export the default Dataset when the run finishes.

Use this smallest shared test scenario throughout the examples:

```json
{
  "country": "United States",
  "location": "Austin, TX",
  "platforms": ["Zillow"],
  "max_results": 1,
  "listing_type": "for_sale",
  "property_type": "house",
  "posted_since": "7 days"
}
````

The test requests at most one Zillow result for a recently posted house for sale in Austin. It does not imply that a matching listing will exist when the run executes.

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

Each default Dataset item uses the following 40-field public schema. Empty source values remain `null`; nested objects and arrays contain only information exposed for that listing.

| Field group | Fields | Meaning |
| --- | --- | --- |
| Visuals and text | `cover_image`, `image_urls`, `title`, `description` | Primary image, image collection, listing title, and cleaned description. |
| Listing identity | `listing_id`, `mls_id`, `listing_type`, `availability`, `market_type` | Source identifiers and listing status or market context. |
| Property classification | `property_type`, `subtype`, `category`, `business_type` | Normalized and source-specific property categories. |
| Price and space | `price`, `rooms`, `area`, `land` | Nested price, bedroom/bathroom, floor-area, and lot information. |
| Place | `location`, `address`, `geo`, `country` | Display location, detailed address, coordinates, region, city, district, and postal code when available. |
| Building and dates | `building`, `dates`, `posted_time`, `fees` | Building attributes, listing dates, posted time, taxes, deposits, and recurring costs. |
| Media and features | `media`, `open_houses`, `features`, `amenities`, `details` | Tours, floor plans, open-house entries, features, amenities, and additional structured details. |
| Community and units | `reviews`, `policies`, `units`, `nearby` | Ratings, rental policies, unit plans, schools, transit, and nearby amenities. |
| Contact and provenance | `contact`, `platform`, `source_url`, `official_url` | Agent or agency details, source name, original listing URL, and an explicitly supplied official outbound URL. |
| Processing metadata | `processor`, `processed_at` | Actor reference and UTC processing timestamp. |

An abbreviated, illustrative result for the Austin scenario can look like this:

```json
{
  "cover_image": "https://images.example.com/austin-home.jpg",
  "title": "Three-bedroom home in Austin",
  "listing_id": "123456789",
  "listing_type": "for_sale",
  "property_type": "House",
  "price": {"value": 625000, "text": "$625,000", "currency": "USD"},
  "rooms": {"beds": 3, "baths": 2},
  "location": "Austin, TX",
  "address": "Example address, Austin, TX",
  "geo": {"lat": 30.2672, "lng": -97.7431, "city": "Austin"},
  "contact": {"agent": "Example Agent", "agency": "Example Realty"},
  "platform": "zillow",
  "source_url": "https://www.zillow.com/homedetails/123456789",
  "processor": "https://apify.com/truefetch/global-real-estate-listings",
  "processed_at": "2026-07-21T12:00:00+00:00"
}
```

The example demonstrates the schema; it is not a live property or a promise that Zillow will expose every shown value.

### What inputs can I configure?

| Input | Type | Required | Behavior |
| --- | --- | --- | --- |
| `country` | string | Yes | Selects one of 24 supported countries and determines which marketplaces are compatible. |
| `location` | string | Yes | Accepts a city, region, neighborhood, postal code, or address that the selected source can interpret. |
| `platforms` | array | No | Restricts the search to chosen compatible marketplaces. Empty means all compatible platforms for the country. |
| `max_results` | integer, 1–10,000 | Yes | Sets the maximum listings returned per selected platform. |
| `listing_type` | string | No | Accepts `for_sale`, `for_rent`, or `sold`; omitted input is treated as `for_sale`. |
| `property_type` | string | No | Requests a supported type such as `house`, `apartment`, `condo`, `land`, or `commercial`. |
| `posted_since` | date or relative text | No | Requests listings within a period such as `7 days` only on sources that support posted-date filtering. |

Optional inputs remain optional. The Actor does not invent a property type, posted date, or platform selection when the user leaves those fields empty. A platform can be skipped when it does not support the requested country, transaction type, property type, or posted-date filter.

### What platforms and markets does Global Real Estate Listings cover?

The current local route map contains 40 marketplaces across 24 countries:

| Market | Supported sources |
| --- | --- |
| Australia | Domain |
| Botswana, Kenya, Mauritius, Mozambique, Namibia, Nigeria, South Africa, Zambia, Zimbabwe | Property24 |
| Brazil | ZAP Imóveis, Chaves na Mão, QuintoAndar, VivaReal |
| Canada | Zillow, Craigslist Housing, Redfin, RentCafe, Apartments.com, Realtor.ca, Centris |
| France | Leboncoin Immobilier |
| Germany | Immowelt, ImmobilienScout24 |
| India | MagicBricks, NoBroker, 99acres |
| Italy | Immobiliare.it, Casa.it |
| Japan | AtHome Japan, Homes/LIFULL, SUUMO |
| Netherlands | Funda |
| New Zealand | Trade Me Property |
| Poland | Otodom |
| Spain | Fotocasa |
| Sweden | Hemnet |
| United Kingdom | Rightmove, Zoopla, OnTheMarket |
| United States | Zillow, Craigslist Housing, Realtor.com, Redfin, Trulia, LoopNet, Movoto, RentCafe, Apartments.com, Homes.com, Apartment List, Rent.com, Vrbo |

Not every source supports sale, rent, sold, property-type, and posted-date filters in the same way. Coverage maps configured sources; availability and completeness vary over time.

### Why use Global Real Estate Listings?

| Verified capability | Practical benefit |
| --- | --- |
| Country-aware source selection | Avoid sending a country request to marketplaces that are not mapped to that market. |
| Optional platform selection | Run a narrow one-source comparison or broaden a country search without changing the Dataset model. |
| Forty normalized public fields | Build a stable downstream table while retaining source URLs for verification. |
| Per-platform result limits | Control the size of a narrow test and understand how multi-platform totals can grow. |
| Source-dependent filtering | Request transaction, property, and posted-date criteria without pretending every marketplace supports them. |

The main trade-off is normalization versus source uniformity. A consistent field name makes cross-market analysis easier, but a marketplace may omit a value or represent it differently. Keep nullable fields in downstream models and retain `platform` plus `source_url` for provenance.

### Who is Global Real Estate Listings for?

Global Real Estate Listings is primarily for developers, analysts, and data teams building market-monitoring, inventory-discovery, research, or lead-enrichment workflows. Typical uses include comparing asking prices across sources, creating a review queue for newly listed properties, assembling location-level inventory samples, enriching property research with images and contact details, and feeding normalized records into a warehouse or internal dashboard.

It can also help professionals who need a repeatable export. It does not replace a licensed MLS feed, appraisal, transaction authority, private records, or legal review.

### How can I use Global Real Estate Listings through the API or MCP?

The public Actor slug is `truefetch/global-real-estate-listings`; the Store console currently resolves it to Actor ID `UYofaeEgDIbwgKawh`. The [live API page](https://apify.com/truefetch/global-real-estate-listings/api?fpr=aiagentapi) provides generated SDK, HTTP, CLI, and OpenAPI examples.

Run the shared Austin test synchronously with HTTP:

```bash
curl -X POST "https://api.apify.com/v2/acts/truefetch~global-real-estate-listings/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"country":"United States","location":"Austin, TX","platforms":["Zillow"],"max_results":1,"listing_type":"for_sale","property_type":"house","posted_since":"7 days"}'
```

For MCP, Apify's current official configuration uses the hosted server and selects the Actor by slug:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com/?tools=truefetch/global-real-estate-listings",
      "headers": {"Authorization": "Bearer <APIFY_TOKEN>"}
    }
  }
}
```

After connecting, ask the selected Actor tool to run with the same Austin JSON input. Treat the API token as a secret and never commit it to a repository.

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

Current local pricing metadata uses pay per event. Store prices can change, so verify the [live pricing tab](https://apify.com/truefetch/global-real-estate-listings/pricing?fpr=aiagentapi) before running.

| Billed event | FREE | BRONZE | SILVER | GOLD | PLATINUM | DIAMOND | Billing unit |
| --- | ---: | ---: | ---: | ---: | ---: | ---: | --- |
| Actor Start | $0.01000 | $0.01000 | $0.01000 | $0.01000 | $0.01000 | $0.01000 | One start event when the Actor begins. |
| Result | $0.01250 | $0.01208 | $0.01167 | $0.01125 | $0.01125 | $0.01125 | One normalized listing stored in the default Dataset. |

At the FREE tier, the one-platform, one-result test costs $0.01000 + (1 × $0.01250) = **$0.02250** if one result is stored. A zero-result run still incurs the start event but no Result event. Selecting multiple platforms can store up to `max_results` for each compatible platform and therefore can create more billed Result events.

### How does Global Real Estate Listings compare with alternatives?

| Approach | Best fit | Trade-off |
| --- | --- | --- |
| Global Real Estate Listings | One normalized model across several countries or marketplaces | Broader coverage means more source-dependent nulls and filter differences. |
| A single-market TrueFetch Actor | Focused work on Zillow, Realtor.com, Zoopla, or another supported source | Simpler scope, but no multi-market search in the same run. |
| Manual marketplace research | A small number of one-off checks requiring human judgment | Difficult to repeat or export consistently. |
| Licensed listing feed | Workflows requiring contractual completeness, defined service levels, or regulated use | Requires a separate commercial agreement and its own data model. |

Choose the Global Actor for normalized discovery across marketplaces, a narrower Actor for one source, and a licensed feed when contractual rights are mandatory.

### What are the limits and troubleshooting steps?

| Symptom or limit | Explanation and next step |
| --- | --- |
| No results | The location or filters may have no current match. Retry the smallest input with one compatible platform and fewer optional filters. |
| A selected platform is skipped | The platform may not support the country, transaction type, property type, or posted-date request. Remove the incompatible filter or choose another source. |
| Some fields are `null` | Marketplaces expose different attributes. Use nullable downstream fields and verify important facts at `source_url`. |
| More results than `max_results` | The limit applies per selected platform, not necessarily to the entire run. Select one platform for a strict one-source test. |
| Similar listings appear twice | Different marketplaces can advertise the same property with different identifiers or URLs. Deduplicate downstream using source-aware business rules. |
| One platform fails while others continue | Multi-source runs can produce partial results. Review the run status, then reproduce the issue with one platform and `max_results: 1`. |

When reporting an issue, include the run URL, sanitized input, selected platform, expected behavior, and one example source URL. Never post an API token or private data. The [public Issues page](https://apify.com/truefetch/global-real-estate-listings/issues/open?fpr=aiagentapi) showed no open issue details during the 2026-07-21 documentation review; that old public snapshot is not evidence that every current run is defect-free.

### Frequently asked questions

#### Does an empty `platforms` input mean no platforms?

No. Empty or omitted `platforms` means the Actor can use the compatible marketplaces for the selected country. Provide an explicit list to narrow the run.

#### Is `max_results` a total-run limit?

No. It is the maximum per selected platform. A run across five compatible sources can store more than `max_results` in total.

#### Does every marketplace support `sold` listings?

No. Transaction coverage differs by source. An incompatible platform can be skipped rather than silently changing the requested transaction type.

#### Why is `posted_since` optional?

Only some sources support posted-date filtering. Leave it empty for broad coverage, or use it when the selected source supports the requested timeframe.

#### Are missing fields replaced with guessed values?

No. Unavailable values remain `null`. The normalized schema does not make a source attribute exist when the marketplace did not expose it.

#### Can the same property appear from multiple platforms?

Yes. Cross-marketplace listings can refer to the same real-world property. Preserve provenance, then apply your own deduplication rule.

#### Can I schedule recurring searches?

Yes. Use Apify scheduling around a stable, tested input. Review Dataset growth and Result-event costs before increasing frequency or platform count.

#### Is the returned data suitable for an appraisal or legal decision?

Not by itself. The Actor provides marketplace listing data, not professional valuation, title, legal, lending, or compliance advice.

### Related TrueFetch Actors

- [Zillow Real Estate Listings](https://apify.com/truefetch/zillow-real-estate-listings?fpr=aiagentapi) — choose this for a Zillow-only workflow in the United States or Canada.
- [Realtor Real Estate Listings](https://apify.com/truefetch/realtor-real-estate-listings?fpr=aiagentapi) — choose this for focused Realtor.com sale, rental, or sold listing research in the United States.
- [Zoopla Real Estate Listings](https://apify.com/truefetch/zoopla-real-estate-listings?fpr=aiagentapi) — choose this for a United Kingdom workflow centered on Zoopla sale and rental listings.

### Support and last updated

Documentation and public surfaces were reviewed on **2026-07-21**. The [Store page](https://apify.com/truefetch/global-real-estate-listings?fpr=aiagentapi), [API reference](https://apify.com/truefetch/global-real-estate-listings/api?fpr=aiagentapi), [pricing](https://apify.com/truefetch/global-real-estate-listings/pricing?fpr=aiagentapi), and [Issues page](https://apify.com/truefetch/global-real-estate-listings/issues/open?fpr=aiagentapi) are the formal Actor links. The public Store currently reflects an older deployed snapshot; local verified schemas and runtime evidence were used for capability claims in this README.

For help, use the [TrueFetch community](https://t.me/TrueFetch) or [direct support](https://t.me/AiAgentApi). Include a sanitized one-result reproduction and run URL so the issue can be checked without exposing credentials.

[**Run a one-result test**](https://console.apify.com/actors/UYofaeEgDIbwgKawh/input) · [**Open the current API guide**](https://apify.com/truefetch/global-real-estate-listings/api?fpr=aiagentapi)

# Actor input Schema

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

Country where supported real estate marketplaces will be searched

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

City, region, neighborhood, postal code, or address supported by each selected source

## `platforms` (type: `array`):

Optional platforms to search. Leave empty to use every supported platform for the selected country

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

Maximum number of property listings to return per selected platform

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

Choose the transaction status to search

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

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

## `posted_since` (type: `string`):

Only include listings posted within this timeframe when the source supports posted-date filtering

## Actor input object example

```json
{
  "country": "United States",
  "location": "New York, NY",
  "max_results": 10
}
```

# Actor output Schema

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

Overview table for the default dataset of normalized property listings.

# 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": "New York, NY",
    "max_results": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("truefetch/global-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": "New York, NY",
    "max_results": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("truefetch/global-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": "New York, NY",
  "max_results": 10
}' |
apify call truefetch/global-real-estate-listings --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Global Real Estate Listings",
        "description": "Search real estate listings across supported property marketplaces with one normalized dataset. Collect sale, rental, and sold listings with prices, locations, property details, images, agents, platform names, and source URLs.",
        "version": "1.0",
        "x-build-id": "8tzhDxRaRdSY3pAwY"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/truefetch~global-real-estate-listings/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-truefetch-global-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~global-real-estate-listings/runs": {
            "post": {
                "operationId": "runs-sync-truefetch-global-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~global-real-estate-listings/run-sync": {
            "post": {
                "operationId": "run-sync-truefetch-global-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": [
                            "Australia",
                            "Botswana",
                            "Brazil",
                            "Canada",
                            "France",
                            "Germany",
                            "India",
                            "Italy",
                            "Japan",
                            "Kenya",
                            "Mauritius",
                            "Mozambique",
                            "Namibia",
                            "Netherlands",
                            "New Zealand",
                            "Nigeria",
                            "Poland",
                            "South Africa",
                            "Spain",
                            "Sweden",
                            "United Kingdom",
                            "United States",
                            "Zambia",
                            "Zimbabwe"
                        ],
                        "type": "string",
                        "description": "Country where supported real estate marketplaces will be searched"
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "City, region, neighborhood, postal code, or address supported by each selected source"
                    },
                    "platforms": {
                        "title": "Platforms",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Optional platforms to search. Leave empty to use every supported platform for the selected country",
                        "items": {
                            "type": "string",
                            "enum": [
                                "Zillow",
                                "Craigslist Housing",
                                "Leboncoin Immobilier",
                                "Realtor.com",
                                "Redfin",
                                "Trulia",
                                "LoopNet",
                                "Movoto",
                                "RentCafe",
                                "Rightmove",
                                "Apartments.com",
                                "Homes.com",
                                "Domain",
                                "Realtor.ca",
                                "Immowelt",
                                "Trade Me Property",
                                "ImmobilienScout24",
                                "Immobiliare.it",
                                "Zoopla",
                                "ZAP Imóveis",
                                "Fotocasa",
                                "Hemnet",
                                "Apartment List",
                                "AtHome Japan",
                                "Casa.it",
                                "Centris",
                                "Chaves na Mão",
                                "Funda",
                                "Homes/LIFULL",
                                "MagicBricks",
                                "NoBroker",
                                "99acres",
                                "OnTheMarket",
                                "Otodom",
                                "Property24",
                                "QuintoAndar",
                                "Rent.com",
                                "SUUMO",
                                "VivaReal",
                                "Vrbo"
                            ]
                        }
                    },
                    "max_results": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of property listings to return per selected platform"
                    },
                    "listing_type": {
                        "title": "Listing Type",
                        "enum": [
                            "for_sale",
                            "for_rent",
                            "sold"
                        ],
                        "type": "string",
                        "description": "Choose the transaction status to search"
                    },
                    "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 or asset type filter. Leave empty to include all supported property types"
                    },
                    "posted_since": {
                        "title": "Posted Since",
                        "type": "string",
                        "description": "Only include listings posted within this timeframe when the source supports posted-date filtering"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
