# Flatfox Scraper - Swiss rentals, homes for sale, flatshares (`datagleaner/flatfox-swiss-property-scraper`) Actor

Flatfox.ch scraper: Swiss rentals and homes for sale by city or map area, with price, rooms, area, address, coordinates, features, agency and photos. Newest first. No login, no API key, no browser. $0.003 per listing.

- **URL**: https://apify.com/datagleaner/flatfox-swiss-property-scraper.md
- **Developed by:** [Data Gleaner](https://apify.com/datagleaner) (community)
- **Categories:** Real estate, Automation, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$3.00 / 1,000 listings

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

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Flatfox Scraper - Swiss Rentals, Homes for Sale and Flatshares (Flatfox.ch)

This Flatfox scraper turns Flatfox.ch, one of Switzerland's biggest rental and property portals, into clean JSON. Search by **city or map area**, filter by **rent or buy, category, price, rooms and living area**, and get each listing's **title, price in CHF, rent net, charges and gross, rooms, living area, floor, year built, street, ZIP, city, coordinates, availability date, furnished and temporary flags, features, agency, description and photo links**, newest first. No Flatfox account, no API key, no login, no browser: it reads the same public data the Flatfox website and apps load, with plain HTTP.

It is built to **finish the run**. An unknown location is reported in the log and skipped, a rate limit is waited out with exponential backoff, and one broken record never stops the rest.

### What does Flatfox Scraper do?

It lists every active Flatfox listing inside a city or map area, sorts them newest first, reads each one in full and returns one row per listing in the Apify dataset, exportable as JSON, CSV or Excel or readable through the API. Typical uses:

- **Swiss rent and sale price research.** Track asking rents per city, district (ZIP) and room count over time, build price indexes and compare Zurich, Geneva, Basel and Bern.
- **New-listing alerts.** Run hourly or daily on a schedule with a price cap and room count, and send new flats to Telegram, Slack, email or a spreadsheet.
- **Relocation and expat tools.** Feed a flat finder, a chatbot or a relocation service with fresh Swiss listings.
- **Investors and agencies.** Watch competing agencies' stock, find listings by agency, and size a market by canton or ZIP.
- **Datasets for AI and RAG.** Get clean multilingual listing text with structured fields for housing assistants and valuation models.
- **Student and flatshare search.** Filter `categories: ["SHARED"]` for rooms and flatshares under a monthly budget.

### Input

| Field | Type | What it does |
|---|---|---|
| `locations` | list of text | Swiss cities (`Zurich`, `Geneva`, `Basel`, `Bern`, `Lausanne`, `Winterthur`, `Lucerne`, `St. Gallen`, `Lugano`, `Zug`, `Biel`, `Thun`, `Fribourg`, `Neuchatel`, `Chur`, `Schaffhausen`, `Sion`, `Aarau`, `Baden`, `Locarno`, `Montreux`), `Switzerland` for the whole country, a circle `lat,lon,radiusKm` such as `47.05,8.31,10`, or a box `south,west,north,east`. One search per entry. A city covers its surroundings, about 5 to 9 km around the centre. |
| `offerType` | choice | `RENT` (default), `SALE` or `ANY`. |
| `categories` | list | Optional: `APARTMENT`, `HOUSE`, `SHARED` (rooms and flatshares), `INDUSTRY` (offices, shops, workshops), `PARK` (parking and garages), `GASTRO` (restaurants and bars), `PROPERTY` (land). Empty means all. |
| `minPrice`, `maxPrice` | number | CHF per month for rentals, purchase price for sales. |
| `minRooms`, `maxRooms` | number | Swiss room count, for example `2.5`. |
| `minAreaM2` | number | Minimum living area. Listings without an area are dropped when set. |
| `startUrls`, `listingIds` | list | Optional. Flatfox listing links or numbers to read directly. |
| `maxItems` | number | Cap on listings returned, newest first. Default 100. It is also your cost cap. |
| `includeDescription`, `includeImages` | true/false | Full description text and photo links. Default true. |
| `requestDelaySeconds` | number | Pause before each request, default 0.5 s (randomised up to 1.4x). |
| `proxyConfiguration` | object | Optional Apify Proxy. Default is no proxy. |

```json
{
  "locations": ["Zurich", "Winterthur"],
  "offerType": "RENT",
  "categories": ["APARTMENT"],
  "maxPrice": 2500,
  "minRooms": 2.5,
  "maxItems": 200
}
```

Listings are deduplicated across locations. Price, room and area filters are applied before you are billed: you pay only for listings you receive.

### Output

One row per listing.

| Field | Meaning |
|---|---|
| `id`, `url`, `status` | Flatfox listing number, link and status. |
| `offerType`, `category`, `type` | `RENT` or `SALE`; category such as `APARTMENT`, `HOUSE`, `SHARED`; and Flatfox's type such as `ATTIC_FLAT`, `SINGLE_ROOM`, `CHALET`. |
| `title`, `shortTitle`, `headline`, `description` | Flatfox's title with the price, a short title, the advertiser's headline and the full description in the language it was written in. |
| `price`, `priceUnit`, `priceIncludesUtilities`, `currency` | The displayed price as a number (monthly rent or sale price), its unit and whether utilities are included. Always CHF. |
| `rentNet`, `rentCharges`, `rentGross` | The rent split, when the advertiser gave it. |
| `rooms`, `livingAreaM2`, `usableAreaM2`, `propertyAreaM2`, `floor`, `yearBuilt`, `yearRenovated` | Size and building data. |
| `street`, `zipcode`, `city`, `canton`, `address`, `latitude`, `longitude` | Location. Many advertisers hide the street, so the address can be just ZIP and city. |
| `availableFrom`, `availability` | Move-in date, and whether it is a date, immediate or by agreement. |
| `isFurnished`, `isTemporary`, `isReserved` | Flags. |
| `features` | Amenities such as `lift`, `balconygarden`, `dishwasher`, `petsallowed`. |
| `agencyName`, `agencyCity`, `agencyStreet`, `agencyLogoUrl`, `reference`, `externalUrl` | The advertising agency and the agency's own listing reference and page, when there is one. |
| `videoUrl`, `tourUrl`, `imageCount`, `imageUrls` | Media. |
| `publishedAt`, `createdAt` | ISO 8601 with offset. |
| `scrapedAt`, `sourceType`, `sourceInput` | When it was scraped, whether it came from a `search` or a `url`, and the location or links you gave. |

```json
{
  "id": 86442398,
  "url": "https://flatfox.ch/en/flat/8048-zurich/86442398/",
  "status": "act",
  "offerType": "RENT",
  "category": "APARTMENT",
  "type": "APARTMENT",
  "title": "8048 Zürich - CHF 1’500 incl. utilities per month",
  "shortTitle": "2 ½ rooms apartment",
  "price": 1500,
  "priceUnit": "monthly",
  "priceIncludesUtilities": true,
  "currency": "CHF",
  "rentCharges": 300,
  "rentGross": 1500,
  "rooms": 2.5,
  "livingAreaM2": 55,
  "floor": 3,
  "zipcode": 8048,
  "city": "Zürich",
  "address": "8048 Zürich",
  "latitude": 47.3860807018571,
  "longitude": 8.479278556512062,
  "availableFrom": "2026-12-01",
  "isFurnished": true,
  "isTemporary": true,
  "features": ["lift", "washingmachine", "dishwasher", "parquetflooring"],
  "publishedAt": "2026-10-10T22:17:33+02:00",
  "imageCount": 3,
  "imageUrls": ["https://flatfox.ch/media/ff/2026/10/854df4ugrvqt5tnziyfmurk8qmkzv6b9oiaec7dy4h5yujpezo.jpg"],
  "scrapedAt": "2026-10-10T23:42:22+00:00",
  "sourceType": "search",
  "sourceInput": "Zurich"
}
```

### Pricing

Pay per event, with the price final:

- **$0.003 per listing** ($3 per 1,000 listings), with no start fee.

You pay only for listings you receive: nothing for unknown locations, failed requests, retries or listings your filters remove, and the run stops by itself when your **maximum total charge** is reached. Platform usage is included.

Example: all active Zurich rentals under CHF 3,000 is roughly 600 listings, so 600 x $0.003 = **$1.80**. A daily alert run with `maxItems: 50` for new Basel flats costs at most $0.15 per day. For comparison, the Swiss rental scraper that covers Flatfox together with other portals charges $0.00475 per listing plus $0.005 per run start.

### Use it from the API

```bash
curl -X POST "https://api.apify.com/v2/acts/datagleaner~flatfox-swiss-property-scraper/run-sync-get-dataset-items?token=<YOUR_APIFY_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"locations": ["Geneva"], "offerType": "RENT", "maxPrice": 2800, "maxItems": 50}'
```

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("datagleaner/flatfox-swiss-property-scraper").call(run_input={
    "locations": ["Zurich"],
    "offerType": "RENT",
    "minRooms": 3,
    "maxItems": 100,
})
for flat in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(flat["publishedAt"], flat["price"], flat["rooms"], flat["address"], flat["url"])
```

### Use it from n8n, Make, Zapier or an AI agent

Actor ID: `datagleaner/flatfox-swiss-property-scraper`

Minimal input:

```
{"locations": ["Zurich"], "maxItems": 10}
```

Each tool below runs this Actor with your own Apify API token.

- **n8n:** add the **Apify** node (`@apify/n8n-nodes-apify`). On n8n Cloud you install it from the community node registry. Choose **Run an Actor and get dataset**, set Actor to `datagleaner/flatfox-swiss-property-scraper` and paste the input above. Put it behind a Schedule trigger for new-listing alerts.
- **Make:** use the Apify app's **Run an Actor** module, then **Get Dataset Items** to read the results. **Watch Actor Runs** can trigger a scenario when a run finishes.
- **Zapier:** use the Apify action **Run Actor**, then the search **Fetch dataset items**. The trigger **Finished Actor run** starts a Zap when a run ends.
- **AI agents (MCP):** connect to `https://mcp.apify.com/?tools=datagleaner/flatfox-swiss-property-scraper`. Without a token, an agent can still find Actors with the `search-actors` tool, but running this one needs your Apify account. In Claude Code:

  ```
    claude mcp add --transport http apify "https://mcp.apify.com/?tools=datagleaner/flatfox-swiss-property-scraper"
  ```

  Then run `/mcp` to sign in to Apify in your browser. Then ask in plain language, for example: "Use the Flatfox scraper to find the 20 newest 3-room rentals in Basel under CHF 2,500 and rank them by price per square metre."
- **LangChain (Python):**

```python
## pip install langchain-apify, then set APIFY_TOKEN in your environment
import json
from langchain_apify import ApifyActorsTool
tool = ApifyActorsTool("datagleaner/flatfox-swiss-property-scraper")
result = tool.invoke({"run_input": json.loads('{"locations": ["Zurich"], "maxItems": 10}')})
```

### Limits

- **Flatfox only.** This Actor covers Flatfox.ch. It does not read Homegate, ImmoScout24, Newhome or other portals, which block automated access.
- **Active listings only.** Rented or sold listings disappear from Flatfox and from the results.
- **Addresses.** Many advertisers show only ZIP and city, so `street` is often empty, and coordinates can be approximate.
- **Cities are circles.** A city name covers roughly the city and its surroundings, not its legal border. Use a `south,west,north,east` box for exact areas, or filter by `zipcode` afterwards.
- **Price filters** use the displayed price. Listings priced "on request" have no price and are dropped when a price filter is set.
- **Contact details** of private landlords are not published by Flatfox and are not collected.
- **Speed.** About 40 listings per detail request, so hundreds of listings take under a minute.

### FAQ

**Do I need a Flatfox account or API key?** No. The Actor reads public data and needs no login of any kind.

**How do I get only new listings?** Results come newest first. Run it on a schedule with a small `maxItems` and keep the `id` values you have already seen.

**Can I get the whole country?** Yes: `locations: ["Switzerland"]`. Add price, category or room filters and a `maxItems` cap so you pay only for what you need.

**Can I search for houses for sale?** Yes: `offerType: "SALE"` with `categories: ["HOUSE"]`.

**What happens if I start it with no input?** It runs a small built-in example, 5 rentals in Zurich (5 x $0.003 = $0.015), and says so in the run's status message. Give `locations`, `startUrls` or `listingIds` for your own run.

**What language is the text in?** Titles are in English; descriptions are in whatever language the advertiser wrote, mostly German, French or Italian.

**Can I export to CSV or Excel?** Yes, from the run's dataset page or the API.

**Why is a field empty?** Advertisers fill only some fields. Empty means Flatfox did not publish it.

### Responsible use

This Actor reads only publicly visible Flatfox data and paces its requests politely. Listings can include agency names and other personal data: **you** are responsible for a lawful basis, for respecting Flatfox's terms and advertisers' rights, and for your obligations under the Swiss FADP, GDPR and any other law that applies. Do not use the output to spam advertisers, discriminate in housing, or evade platform rules. This is not legal advice.

# Actor input Schema

## `locations` (type: `array`):

Swiss cities such as Zurich, Geneva, Basel, Bern, Lausanne, Winterthur, Lucerne, St. Gallen, Lugano, or Switzerland for the whole country. For any other place use a circle as lat,lon,radiusKm (47.05,8.31,10) or a box as south,west,north,east. Each entry is one search; a city covers its surroundings (about 5 to 9 km).

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

RENT for rentals, SALE for properties for sale, ANY for both.

## `categories` (type: `array`):

Optional. Keep only these categories: APARTMENT, HOUSE, SHARED (flatshares and rooms), INDUSTRY (offices, shops, workshops), PARK (parking and garages), GASTRO (restaurants and bars), PROPERTY (land). Leave empty for all.

## `minPrice` (type: `integer`):

Optional. Monthly rent for rentals, purchase price for sales.

## `maxPrice` (type: `integer`):

Optional. Monthly rent for rentals, purchase price for sales.

## `minRooms` (type: `number`):

Optional. Swiss room count, for example 2.5 or 3.5. Listings without a room count are dropped when this is set.

## `maxRooms` (type: `number`):

Optional. Swiss room count.

## `minAreaM2` (type: `integer`):

Optional. Listings without an area are dropped when this is set.

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

Optional. Flatfox listing links (https://flatfox.ch/en/flat/8047-zurich/86442411/) to read those listings directly.

## `listingIds` (type: `array`):

Optional. Flatfox listing numbers, the last number in a listing link, for example 86442411.

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

Upper bound on listings returned in total, newest first. Each returned listing is billed, so this is also your cost cap.

## `includeDescription` (type: `boolean`):

Add the advertiser's full description text (German, French, Italian or English as written). Turn off for smaller rows.

## `includeImages` (type: `boolean`):

Add links to all photos of each listing.

## `requestDelaySeconds` (type: `number`):

Base pause before each request to Flatfox; the actual pause is randomised up to 1.4x. Raise it if Flatfox answers with rate limits (HTTP 429).

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

Optional. The default is no proxy, which works from Apify's servers. Enable Apify Proxy only if Flatfox rate-limits you.

## Actor input object example

```json
{
  "locations": [
    "Zurich"
  ],
  "offerType": "RENT",
  "categories": [],
  "startUrls": [],
  "listingIds": [],
  "maxItems": 100,
  "includeDescription": true,
  "includeImages": true,
  "requestDelaySeconds": 0.5,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "locations": [
        "Zurich"
    ],
    "categories": [],
    "startUrls": [],
    "listingIds": [],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("datagleaner/flatfox-swiss-property-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 = {
    "locations": ["Zurich"],
    "categories": [],
    "startUrls": [],
    "listingIds": [],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("datagleaner/flatfox-swiss-property-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "locations": [
    "Zurich"
  ],
  "categories": [],
  "startUrls": [],
  "listingIds": [],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call datagleaner/flatfox-swiss-property-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,datagleaner/flatfox-swiss-property-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

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