# Flatfox Scraper — Swiss Rental & Property Listings (`studio-amba/flatfox-scraper`) Actor

Scrape rental and property listings from Flatfox.ch — Switzerland's rental and flatshare marketplace. Extract apartments and houses with CHF prices, rooms, living space, addresses, coordinates, and photos across every Swiss city and canton.

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

## Pricing

from $1.20 / 1,000 result scrapeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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 Scraper

Extract rental and property listings from [Flatfox.ch](https://flatfox.ch) — Switzerland's rental and flatshare marketplace. Get CHF prices, rooms, living space, addresses, coordinates, and photos for apartments and houses across every Swiss city and canton, in structured JSON.

No login or cookies required.

### What is Flatfox Scraper?

Flatfox is one of Switzerland's largest listing sites for renting and subletting flats, alongside Homegate and ImmoScout24.ch. This actor queries Flatfox's own listing API directly (the same one the site's search map uses), so every run returns clean, structured data — no HTML parsing, no broken selectors when the site redesigns its frontend.

### Why use this actor?

- **Whole-of-Switzerland coverage.** Search any major city across all four language regions (German, French, Italian) — Zürich, Geneva, Basel, Bern, Lausanne, Lugano, and 25+ more are built in, or pass exact coordinates/a bounding box for anywhere else.
- **Structured, not scraped-and-guessed.** Price, address, ZIP code, room count, living space, coordinates, and photos come straight from Flatfox's own data — no fragile CSS selectors.
- **Residential filter built in.** Flatfox also carries parking slots, storage compartments, and commercial units alongside apartments and houses. This actor filters to residential listings by default so you don't have to clean garage-slot rows out of your dataset yourself.
- **Rent or sale.** Flatfox is a rental-first marketplace, but also lists properties for sale — filter by either or fetch both.

### How to scrape Flatfox.ch data

1. Open this actor on Apify and click **Try for free** (or call it via the API/SDK).
2. Set **Location** to a Swiss city (e.g. `zurich`, `geneva`, `basel`, `lausanne`, `lugano`) — or use the advanced **latitude/longitude** or **boundingBox** inputs if you need an exact area not covered by the built-in city list.
3. Set **Listing Type** (rent / sale / any), **Property Category** (residential-only or all categories), and an optional price range.
4. Set **Max Results** and click **Start**.
5. Download the results as JSON, CSV, or Excel from the **Dataset** tab, or pull them via the Apify API.

Under the hood, the actor resolves your location to a lat/lon search box (the same job Flatfox's own map-based search does client-side), fetches every listing pin inside that box, then batch-fetches full listing detail — price, address, rooms, surface, photos — for each one. If an area is dense enough to hit the API's per-request cap, the actor automatically splits the box into smaller quadrants so no listings get dropped.

### Input

| Field | Type | Description | Default |
|---|---|---|---|
| `location` | string | Swiss city name (`zurich`, `geneva`, `basel`, `lausanne`, `lugano`, etc.) | `zurich` |
| `radiusKm` | integer | Half-width of the search box around the resolved center, in km | `6` |
| `latitude` / `longitude` | number | Advanced: explicit search center, used with `radiusKm` instead of `location` | — |
| `boundingBox` | object | Advanced: explicit `{ north, south, east, west }` lat/lon box, overrides location entirely | — |
| `listingType` | string | `rent`, `sale`, or `any` | `rent` |
| `objectCategory` | string | `residential` (apartments/houses/shared flats only) or `all` (incl. parking, storage, commercial) | `residential` |
| `priceMin` / `priceMax` | integer | Filter by price range in CHF | — |
| `maxResults` | integer | Maximum number of listings to return | `50` |
| `proxyConfiguration` | object | Apify proxy settings (Swiss residential recommended) | RESIDENTIAL / CH |

### Output

Each item in the dataset is one listing:

| Field | Description |
|---|---|
| `listingId` | Flatfox's internal listing ID |
| `listingTitle` | Listing headline |
| `price` | Monthly rent (or sale price) in CHF, `null` if "on request" |
| `currency` | Always `CHF` |
| `priceUnit` | Price unit as reported by Flatfox (`monthly`, `yearlym2`, ...) |
| `url` | Full listing URL |
| `scrapedAt` | ISO 8601 timestamp |
| `listingType` | `rent` or `sale` |
| `propertyType` | Property type (apartment, house, shared flat, etc.) |
| `address` | Full street address |
| `city` | City name |
| `postalCode` | Swiss ZIP code |
| `latitude` / `longitude` | Coordinates |
| `bedrooms` | Swiss room count ("Zimmer"/"pièces" — total rooms, often in halves e.g. 3.5, not strictly bedrooms) |
| `surface` | Living area in m² |
| `landSurface` | Property/land area in m², if listed |
| `buildYear` | Year built, if disclosed |
| `imageUrl` | Primary photo |
| `imageUrls` | All photos |
| `description` | Full listing description |
| `agencyName` | Managing agency or landlord name, if listed |

#### Example output

```json
{
  "listingId": "85994931",
  "listingTitle": "Badenerstrasse 552, 8048 Zürich - CHF 1'680 inkl. NK pro Monat",
  "price": 1680,
  "currency": "CHF",
  "priceUnit": "monthly",
  "url": "https://flatfox.ch/de/wohnung/badenerstrasse-552-8048-zurich/85994931/",
  "scrapedAt": "2026-08-04T19:51:58.097Z",
  "listingType": "rent",
  "propertyType": "apartment",
  "address": "Badenerstrasse 552, 8048 Zürich",
  "city": "Zürich",
  "postalCode": "8048",
  "latitude": 47.3839794,
  "longitude": 8.4984154,
  "bedrooms": 2,
  "surface": 45,
  "imageUrl": "https://flatfox.ch/media/ff/2026/04/d11vcetodyb6ejtgh2zdli2t0gebdltgjuueipxxt790d1zmgo.jpg",
  "imageUrls": [
    "https://flatfox.ch/media/ff/2026/04/d11vcetodyb6ejtgh2zdli2t0gebdltgjuueipxxt790d1zmgo.jpg",
    "https://flatfox.ch/media/ff/2026/04/elms63rl2tujw1v9vxm997yvg80g9cpcdubw1snkvbp3qotlel.jpg"
  ],
  "description": "Wir vermieten diese 2-Zimmer-Wohnung an zentraler Lage an der Badenerstrasse in Zürich Altstetten...",
  "agencyName": "NOVAC-SOLUTIONS GmbH (Wohnung)"
}
```

### Cost estimate

This actor uses pay-per-event pricing: a small charge when the run starts, plus a per-result charge for every listing pushed to the dataset. There are no per-page or per-request charges — a run pulling 50 listings from one city costs roughly the same whether that took one API batch or ten. As a rough guide, 50 listings costs a few cents; 1,000 listings costs a few dollars. Exact current pricing is shown on the actor's Store page before you run it.

Note: the final usage cost for a run only settles once it reports **SUCCEEDED** — reading the dataset mid-run (before the run finishes) will undercount how much a run actually costs.

### Notes and limitations

- Flatfox does not expose a server-side text/city search filter on its listing API — this actor resolves `location` to a geographic search box using a built-in lookup of Switzerland's major cities. If your target area isn't in that list, use the advanced `latitude`/`longitude` or `boundingBox` inputs instead.
- The API caps each bounding-box query at 1,000 candidate listings. For very dense areas (central Zürich, Geneva) with a large `maxResults`, the actor automatically splits the search box into smaller quadrants to avoid missing listings — this means dense-area runs with a high `maxResults` will issue more requests than a single-city default search.
- `bedrooms` reflects the Swiss convention of counting total rooms (Zimmer/pièces), not bedrooms specifically — a "3.5-room" flat typically means a living room plus 2-3 bedrooms.
- Some listings (mostly older or "price on request" ones) don't disclose a build year or exact price — those fields come back `null` rather than a guessed value.

### Related Scrapers

- [Homegate Scraper](https://apify.com/studio-amba/homegate-scraper) — Switzerland's #1 property portal
- [Comparis Scraper](https://apify.com/studio-amba/comparis-scraper) — Swiss comparison platform, including property listings
- [ImmoScout24 Austria Scraper](https://apify.com/studio-amba/immoscout24-at-scraper) — DACH-region real estate listings
- [Immoweb Scraper](https://apify.com/studio-amba/immoweb-scraper) — Belgium's #1 real estate portal
- [Zimmo Scraper](https://apify.com/studio-amba/zimmo-scraper) — Belgium's second-largest property portal

### Support

Found an issue or need a custom field added? Reach out via the Apify Console or open an issue on the actor's Store page.

# Actor input Schema

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

A major Swiss city name (e.g. 'zurich', 'geneva', 'basel', 'lausanne', 'lugano'). Flatfox has no server-side city filter, so this is resolved to a search area via a built-in city lookup table. Ignored when boundingBox or latitude/longitude are provided.

## `radiusKm` (type: `integer`):

Half-width of the search box around the resolved city center (or latitude/longitude), in kilometers. Larger values cover more of the surrounding area/canton.

## `latitude` (type: `number`):

Explicit search center latitude. Used with longitude + radiusKm instead of location. Overrides location.

## `longitude` (type: `number`):

Explicit search center longitude. Used with latitude + radiusKm instead of location.

## `boundingBox` (type: `object`):

Explicit { north, south, east, west } lat/lon bounding box. Overrides location and latitude/longitude entirely — copy these values from a flatfox.ch map search URL/network request if you need an exact area.

## `listingType` (type: `string`):

Filter by rent or sale. Flatfox is a rental-first marketplace — most listings are for rent, sale listings are a small minority.

## `objectCategory` (type: `string`):

'residential' keeps apartments, houses and shared flats only, filtering out parking slots, storage/cellar compartments, offices and industrial units that also appear on Flatfox. 'all' returns every category.

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

Only return listings at or above this price (CHF, applied client-side after fetching).

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

Only return listings at or below this price (CHF, applied client-side after fetching).

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

Maximum number of listings to return.

## `proxyConfiguration` (type: `object`):

Proxy settings. Flatfox.ch runs Cloudflare — plain requests currently pass without a challenge, but Swiss residential proxies are kept as the default for resilience if that changes.

## Actor input object example

```json
{
  "location": "zurich",
  "radiusKm": 6,
  "listingType": "rent",
  "objectCategory": "residential",
  "maxResults": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "CH"
  }
}
```

# 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 = {
    "location": "zurich",
    "radiusKm": 6,
    "listingType": "rent",
    "objectCategory": "residential",
    "maxResults": 20,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "CH"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("studio-amba/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 = {
    "location": "zurich",
    "radiusKm": 6,
    "listingType": "rent",
    "objectCategory": "residential",
    "maxResults": 20,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "CH",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("studio-amba/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 '{
  "location": "zurich",
  "radiusKm": 6,
  "listingType": "rent",
  "objectCategory": "residential",
  "maxResults": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "CH"
  }
}' |
apify call studio-amba/flatfox-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/kI4cCu11GAhzsaip8/builds/rrr6m30JmfICGLVr8/openapi.json