# Flatfox Property Search Scraper (`solidcode/flatfox-scraper`) Actor

\[💰 $0.9 / 1K] Extract Swiss real estate listings from Flatfox (flatfox.ch). Search by location, offer type, category, price, and rooms, or paste search URLs. Get rent, surface, rooms, address, geo coordinates, photos, and agency details for rental and sale listings.

- **URL**: https://apify.com/solidcode/flatfox-scraper.md
- **Developed by:** [SolidCode](https://apify.com/solidcode) (community)
- **Categories:** Real estate, Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

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

## Flatfox Property Search Scraper

Pull rental and for-sale property listings from Flatfox (flatfox.ch) at scale — titles, descriptions, full price breakdowns, room counts, living space, exact map coordinates, ready-to-use image URLs, and listing-agency contact details for every property across Switzerland. Built for relocation services, property investors, and real-estate analysts who need clean, structured Swiss housing data without browsing the portal one listing at a time.

### Why This Scraper?

- **Six property categories in one run** — apartments, houses, secondary rooms (storage/hobby), shared flats, commercial/industrial space, and parking/garage slots, each filterable on its own.
- **Rent and sale in a single actor** — flip one dropdown between "For rent" and "For sale"; sale listings carry a derived selling price, rentals carry the full net / charges / gross breakdown.
- **Complete CHF price breakdown** — net rent, utility charges, and gross rent split into separate fields per rental, plus the selling price for every for-sale property.
- **Exact map coordinates, not blurred** — precise latitude and longitude on every listing for mapping, distance, and catchment analysis.
- **Ready-to-use image URLs** — full-resolution photo links and a cover image come back as direct, signed URLs you can load straight into a sheet or app — no asset-ID guesswork.
- **Listing-agency contacts** — agency name, full postal address, and logo URL captured for every property, ready for outreach lists.
- **40+ structured fields per listing** — reference code, object type, floor, year built, year renovated, furnished and temporary flags, moving date, feature tags (balcony, garage, pets…), canton, and publish timestamps.
- **Half-room and CHF-precise filters** — filter by minimum and maximum rooms down to the half-room (2.5), plus exact CHF price bands and square-meter living-space ranges that Swiss housing uses.
- **All of Switzerland, no URL-crafting** — type a city, region, or postal code and the actor builds the search for you, or paste a flatfox.ch search URL to mirror filters you already set up on the site.

### Use Cases

**Relocation & Housing Search**
- Build daily shortlists of apartments matching a relocating employee's budget, rooms, and neighborhood
- Compare rent levels across Zurich, Geneva, Basel, and Lausanne for relocation packages
- Track new rentals in a target postal code as they appear
- Filter furnished listings for short-term and corporate stays

**Real-Estate Investment**
- Pull for-sale listings with selling prices to model yields by city and canton
- Compare price per square meter across regions using exact living-space data
- Spot commercial and industrial space coming to market
- Monitor parking and garage inventory as a standalone asset class

**Market Research & Analytics**
- Map listing density and pricing by exact coordinates across Swiss cities
- Measure average net vs. gross rent spreads by region
- Track rooms, living space, and year-built distributions in a market
- Feed structured Swiss housing data into dashboards and reports

**Lead Generation**
- Build listing-agency contact lists with name, address, and logo
- Identify the most active agencies in a target city
- Target outreach by property category (e.g. only commercial listings)
- Enrich existing CRM records with fresh Flatfox listings

### Getting Started

#### Search by Location

The simplest start — one city and a result cap:

```json
{
    "location": "Zurich",
    "maxResults": 50
}
````

#### Filtered Rental Search

Two-to-three-room apartments under CHF 2,500 a month, newest first:

```json
{
    "offerType": "RENT",
    "location": "Geneva",
    "objectCategories": ["APARTMENT"],
    "priceMax": 2500,
    "roomsMin": 2,
    "roomsMax": 3,
    "sortBy": "newest",
    "maxResults": 200
}
```

#### For-Sale Search by URL

Paste one or more Flatfox search URLs to mirror filters set up on the site:

```json
{
    "startUrls": [
        "https://flatfox.ch/en/search/?offer_type=SALE&north=47.43&south=47.32&east=8.63&west=8.45"
    ],
    "maxResults": 500,
    "maxResultsPerUrl": 250
}
```

### Input Reference

#### What to Scrape

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `startUrls` | string\[] | — | Paste one or more Flatfox search result URLs. The scraper reads the filters straight from each URL. Leave empty to build a search with the filter fields below. |

#### Build a Search

These fields are used only when no Search URLs are provided.

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `offerType` | select | `For rent` | Search properties for rent or for sale. |
| `location` | string | — | City, region, or postal code to search (for example "Zurich", "Geneva", or "8005"). Leave empty to search all of Switzerland. |
| `objectCategories` | select\[] | `[]` | Limit results to these categories: Apartment, House, Secondary rooms (storage, hobby), Shared / room in flat, Commercial / industrial, Parking / garage. Leave empty for all. |
| `priceMin` | integer | — | Only include listings at or above this price in Swiss francs. For rentals this is the monthly rent. |
| `priceMax` | integer | — | Only include listings at or below this price in Swiss francs. |
| `roomsMin` | number | — | Minimum number of rooms (for example 2.5). |
| `roomsMax` | number | — | Maximum number of rooms. |
| `spaceMin` | integer | — | Minimum living space in square meters. |
| `spaceMax` | integer | — | Maximum living space in square meters. |
| `sortBy` | select | `Newest first` | Result order: Newest first, Price low to high, Price high to low, Rooms fewest first, Rooms most first, or Largest living space first. |

#### Limits

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `maxResults` | integer | `100` | Total number of listings to collect across all searches and URLs. Set to 0 to collect as many as available. |
| `maxResultsPerUrl` | integer | `0` | Maximum listings to collect from each individual search or URL. Set to 0 for no per-URL limit. |
| `ignoreUrlFailures` | boolean | `true` | When enabled, the scraper skips any search or URL that fails and continues with the rest. When disabled, the run stops on the first failure. |

### Output

Each record is one property listing, flat and ready for a spreadsheet:

```json
{
    "id": 421337,
    "reference": "ZH-4021",
    "title": "Bright 3.5-room apartment near the lake",
    "description": "Renovated apartment with balcony, modern kitchen, and lake views...",
    "objectCategory": "APARTMENT",
    "objectType": "APARTMENT",
    "offerType": "RENT",
    "price": 2450,
    "priceUnit": "monthly",
    "priceDisplayType": "TOTAL",
    "rentNet": 2200,
    "rentCharges": 250,
    "rentGross": 2450,
    "sellingPrice": null,
    "livingSpace": 86,
    "surfaceProperty": null,
    "surfaceUsable": null,
    "numberOfRooms": 3.5,
    "floor": 2,
    "yearBuilt": 1998,
    "yearRenovated": 2021,
    "isFurnished": false,
    "isTemporary": false,
    "attributes": ["balcony", "elevator", "pets_allowed"],
    "street": "Seestrasse 14",
    "zipcode": "8002",
    "city": "Zürich",
    "publicAddress": "Seestrasse 14, 8002 Zürich",
    "latitude": 47.3567,
    "longitude": 8.5361,
    "state": "ZH",
    "country": "CH",
    "movingDate": "2026-08-01",
    "movingDateType": "DATE",
    "publishedAt": "2026-06-10T09:22:00Z",
    "createdAt": "2026-06-10T09:20:00Z",
    "images": ["https://flatfox.ch/media/listing/421337/01.jpg?signature=..."],
    "coverImage": "https://flatfox.ch/media/listing/421337/cover.jpg?signature=...",
    "agencyName": "Lakeview Immobilien AG",
    "agencyAddress": "Bahnhofstrasse 5, 8001 Zürich, CH",
    "agencyLogo": "https://flatfox.ch/media/agency/logo.png",
    "url": "https://flatfox.ch/en/flat/bright-3-5-room-apartment/421337/"
}
```

#### Core Fields

| Field | Type | Description |
|-------|------|-------------|
| `id` | number | Unique Flatfox listing identifier |
| `reference` | string | Agency reference code |
| `title` | string | Listing title |
| `description` | string | Full listing description text |
| `objectCategory` | string | APARTMENT, HOUSE, SECONDARY, SHARED, INDUSTRY, or PARK |
| `objectType` | string | More specific object type (e.g. APARTMENT, OFFICE, GARAGE\_SLOT) |
| `offerType` | string | RENT or SALE |
| `url` | string | Direct Flatfox listing URL |

#### Pricing

| Field | Type | Description |
|-------|------|-------------|
| `price` | number | Display price in CHF (monthly for rentals) |
| `priceUnit` | string | Price unit (e.g. "monthly", "sell") |
| `priceDisplayType` | string | How the price is shown (e.g. "TOTAL") |
| `rentNet` | number | Net rent in CHF |
| `rentCharges` | number | Utility and service charges in CHF |
| `rentGross` | number | Gross rent in CHF (net + charges) |
| `sellingPrice` | number | Selling price in CHF for for-sale listings |

#### Property Details

| Field | Type | Description |
|-------|------|-------------|
| `livingSpace` | number | Living space in square meters |
| `surfaceProperty` | number | Total property surface in square meters |
| `surfaceUsable` | number | Usable surface in square meters |
| `numberOfRooms` | number | Number of rooms (e.g. 3.5) |
| `floor` | number | Floor number |
| `yearBuilt` | number | Year the property was built |
| `yearRenovated` | number | Year of the last renovation |
| `isFurnished` | boolean | Whether the property is furnished |
| `isTemporary` | boolean | Whether the lease is temporary |
| `attributes` | string\[] | Feature tags (balcony, garage, pets allowed, etc.) |

#### Address & Location

| Field | Type | Description |
|-------|------|-------------|
| `street` | string | Street and number |
| `zipcode` | string | Postal code |
| `city` | string | City |
| `publicAddress` | string | Full display address |
| `state` | string | Canton code (e.g. ZH, GE) |
| `country` | string | Country code (CH) |
| `latitude` | number | Exact latitude |
| `longitude` | number | Exact longitude |

#### Media, Agency & Dates

| Field | Type | Description |
|-------|------|-------------|
| `images` | string\[] | Full-resolution photo URLs |
| `coverImage` | string | Cover photo URL |
| `agencyName` | string | Listing agency name |
| `agencyAddress` | string | Listing agency postal address |
| `agencyLogo` | string | Listing agency logo URL |
| `movingDate` | string | Available-from date |
| `movingDateType` | string | How the moving date is expressed (e.g. fixed date or "by arrangement") |
| `publishedAt` | string | Publication timestamp |
| `createdAt` | string | Creation timestamp |

### Tips for Best Results

- **Paste a flatfox.ch search URL to copy your exact on-site filters** — set up a search on Flatfox, copy the address bar, and drop it into `startUrls`. Every filter, including the map area, is mirrored exactly with no rebuilding.
- **Each search area returns up to 1,000 listings** — Flatfox caps a single search at 1,000 results. To gather more from a large region, split it into several narrower searches (by city or postal code) or several URLs, and the totals add up across them.
- **Switching to "For sale" changes the price fields** — sale listings populate `sellingPrice`, while the rent breakdown (`rentNet`, `rentCharges`, `rentGross`) applies to rentals. Check the right field for the offer type you searched.
- **Use half-room filters the Swiss way** — `roomsMin` and `roomsMax` accept decimals like 2.5 or 3.5, matching how Swiss listings count rooms.
- **Start small to test** — run with `maxResults` at 20–50 first to confirm the filters return what you expect, then scale up.
- **Combine many areas in one run** — pass several URLs in `startUrls` and set `maxResultsPerUrl` to balance the volume taken from each area.
- **Leave the location empty for a national sweep** — clear `location` and the search covers all of Switzerland; narrow later with categories and price bands.

### Pricing

**From $0.90 per 1,000 results** — undercutting comparable Flatfox extractors, with cleaner defaults so you are never over-charged by a runaway result cap. Bronze, Silver, and Gold subscribers pay progressively less; the table below shows total cost at each discount tier.

| Results | No discount | Bronze | Silver | Gold |
|---------|-------------|--------|--------|------|
| 100 | $0.11 | $0.10 | $0.10 | $0.09 |
| 1,000 | $1.05 | $1.00 | $0.95 | $0.90 |
| 10,000 | $10.50 | $10.00 | $9.50 | $9.00 |
| 100,000 | $105.00 | $100.00 | $95.00 | $90.00 |

A "result" is one property listing in the output dataset. No compute or time-based charges — you pay per result, plus a small fixed per-run start fee.

### Integrations

Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via:

- **Zapier** / **Make** / **n8n** — Workflow automation
- **Google Sheets** — Direct spreadsheet export
- **Slack** / **Email** — Notifications on new results
- **Webhooks** — Trigger custom APIs on run completion
- **Apify API** — Full programmatic access

### Legal & Ethical Use

This actor is designed for legitimate real-estate research, market analysis, and lead generation. Users are responsible for complying with applicable laws and Flatfox's Terms of Service. Do not use extracted data for spam, harassment, or any illegal purpose, and handle any personal data, such as agency contacts, in line with applicable privacy regulations. </content> </invoke>

# Actor input Schema

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

Paste one or more Flatfox search result URLs (for example a results page for rentals in Zurich). The scraper reads the filters straight from each URL. Leave empty to build a search with the filter fields below.

## `offerType` (type: `string`):

Search properties for rent or for sale. Only applies when you build a search with the filters below (ignored when Search URLs are provided).

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

City, region, or postal code to search (for example 'Zurich', 'Geneva', or '8005'). Leave empty to search all of Switzerland. Each search area returns up to 1,000 listings — for a larger region, run several narrower searches.

## `objectCategories` (type: `array`):

Limit results to these property categories. Leave empty to include all categories.

## `priceMin` (type: `integer`):

Only include listings at or above this price in Swiss francs. For rentals this is the monthly rent. Leave empty for no minimum.

## `priceMax` (type: `integer`):

Only include listings at or below this price in Swiss francs. For rentals this is the monthly rent. Leave empty for no maximum.

## `roomsMin` (type: `number`):

Only include properties with at least this many rooms (for example 2.5). Leave empty for no minimum.

## `roomsMax` (type: `number`):

Only include properties with at most this many rooms. Leave empty for no maximum.

## `spaceMin` (type: `integer`):

Only include properties with at least this living space in square meters. Leave empty for no minimum.

## `spaceMax` (type: `integer`):

Only include properties with at most this living space in square meters. Leave empty for no maximum.

## `sortBy` (type: `string`):

Choose how Flatfox orders the results when building a search.

## `maxResults` (type: `integer`):

Total number of listings to collect across all searches and URLs. Set to 0 to collect as many as available. Note: a single search area returns at most 1,000 listings — to gather more, split a large region into several smaller searches or URLs.

## `maxResultsPerUrl` (type: `integer`):

Maximum listings to collect from each individual search or URL. Set to 0 for no per-URL limit (the overall Maximum Results still applies).

## `ignoreUrlFailures` (type: `boolean`):

When enabled, the scraper skips any search or URL that fails and continues with the rest. When disabled, the run stops on the first failure.

## Actor input object example

```json
{
  "startUrls": [
    "https://flatfox.ch/en/search/?offer_type=RENT&north=47.43&south=47.32&east=8.63&west=8.45"
  ],
  "offerType": "RENT",
  "location": "Zurich",
  "objectCategories": [],
  "sortBy": "newest",
  "maxResults": 100,
  "maxResultsPerUrl": 0,
  "ignoreUrlFailures": true
}
```

# Actor output Schema

## `overview` (type: `string`):

Table of scraped property listings with key fields.

## `detail` (type: `string`):

Full per-listing detail including pricing, surface, rooms, location, photos, and agency.

# 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": [
        "https://flatfox.ch/en/search/?offer_type=RENT&north=47.43&south=47.32&east=8.63&west=8.45"
    ],
    "offerType": "RENT",
    "location": "Zurich",
    "objectCategories": [],
    "sortBy": "newest",
    "maxResults": 100,
    "maxResultsPerUrl": 0,
    "ignoreUrlFailures": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/flatfox-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": ["https://flatfox.ch/en/search/?offer_type=RENT&north=47.43&south=47.32&east=8.63&west=8.45"],
    "offerType": "RENT",
    "location": "Zurich",
    "objectCategories": [],
    "sortBy": "newest",
    "maxResults": 100,
    "maxResultsPerUrl": 0,
    "ignoreUrlFailures": True,
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/flatfox-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": [
    "https://flatfox.ch/en/search/?offer_type=RENT&north=47.43&south=47.32&east=8.63&west=8.45"
  ],
  "offerType": "RENT",
  "location": "Zurich",
  "objectCategories": [],
  "sortBy": "newest",
  "maxResults": 100,
  "maxResultsPerUrl": 0,
  "ignoreUrlFailures": true
}' |
apify call solidcode/flatfox-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Flatfox Property Search Scraper",
        "description": "[💰 $0.9 / 1K] Extract Swiss real estate listings from Flatfox (flatfox.ch). Search by location, offer type, category, price, and rooms, or paste search URLs. Get rent, surface, rooms, address, geo coordinates, photos, and agency details for rental and sale listings.",
        "version": "1.0",
        "x-build-id": "ytDrUEdGhJLe1hcNI"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~flatfox-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-flatfox-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/solidcode~flatfox-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-flatfox-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/solidcode~flatfox-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-flatfox-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "startUrls": {
                        "title": "Search URLs",
                        "type": "array",
                        "description": "Paste one or more Flatfox search result URLs (for example a results page for rentals in Zurich). The scraper reads the filters straight from each URL. Leave empty to build a search with the filter fields below.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "offerType": {
                        "title": "Offer Type",
                        "enum": [
                            "RENT",
                            "SALE"
                        ],
                        "type": "string",
                        "description": "Search properties for rent or for sale. Only applies when you build a search with the filters below (ignored when Search URLs are provided).",
                        "default": "RENT"
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "City, region, or postal code to search (for example 'Zurich', 'Geneva', or '8005'). Leave empty to search all of Switzerland. Each search area returns up to 1,000 listings — for a larger region, run several narrower searches."
                    },
                    "objectCategories": {
                        "title": "Property Categories",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Limit results to these property categories. Leave empty to include all categories.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "APARTMENT",
                                "HOUSE",
                                "SECONDARY",
                                "SHARED",
                                "INDUSTRY",
                                "PARK"
                            ],
                            "enumTitles": [
                                "Apartment",
                                "House",
                                "Secondary rooms (storage, hobby)",
                                "Shared / room in flat",
                                "Commercial / industrial",
                                "Parking / garage"
                            ]
                        },
                        "default": []
                    },
                    "priceMin": {
                        "title": "Minimum Price (CHF)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include listings at or above this price in Swiss francs. For rentals this is the monthly rent. Leave empty for no minimum."
                    },
                    "priceMax": {
                        "title": "Maximum Price (CHF)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include listings at or below this price in Swiss francs. For rentals this is the monthly rent. Leave empty for no maximum."
                    },
                    "roomsMin": {
                        "title": "Minimum Rooms",
                        "minimum": 0,
                        "type": "number",
                        "description": "Only include properties with at least this many rooms (for example 2.5). Leave empty for no minimum."
                    },
                    "roomsMax": {
                        "title": "Maximum Rooms",
                        "minimum": 0,
                        "type": "number",
                        "description": "Only include properties with at most this many rooms. Leave empty for no maximum."
                    },
                    "spaceMin": {
                        "title": "Minimum Living Space (m²)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include properties with at least this living space in square meters. Leave empty for no minimum."
                    },
                    "spaceMax": {
                        "title": "Maximum Living Space (m²)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include properties with at most this living space in square meters. Leave empty for no maximum."
                    },
                    "sortBy": {
                        "title": "Sort By",
                        "enum": [
                            "newest",
                            "priceAsc",
                            "priceDesc",
                            "roomsAsc",
                            "roomsDesc",
                            "spaceDesc"
                        ],
                        "type": "string",
                        "description": "Choose how Flatfox orders the results when building a search.",
                        "default": "newest"
                    },
                    "maxResults": {
                        "title": "Maximum Results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Total number of listings to collect across all searches and URLs. Set to 0 to collect as many as available. Note: a single search area returns at most 1,000 listings — to gather more, split a large region into several smaller searches or URLs.",
                        "default": 100
                    },
                    "maxResultsPerUrl": {
                        "title": "Maximum Results Per URL",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum listings to collect from each individual search or URL. Set to 0 for no per-URL limit (the overall Maximum Results still applies).",
                        "default": 0
                    },
                    "ignoreUrlFailures": {
                        "title": "Continue If a URL Fails",
                        "type": "boolean",
                        "description": "When enabled, the scraper skips any search or URL that fails and continues with the rest. When disabled, the run stops on the first failure.",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
