# Bien'ici Property Search Scraper (`solidcode/bienici-com-scraper`) Actor

\[💰 $2.5 / 1K] Extract property listings from bien'ici (bienici.com), a leading French real estate portal. Search by location, price, type, rooms, and surface, or paste search URLs. Get prices, fees, surface, rooms, energy ratings, photos, and agency details for sale and rental listings in France.

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

## Pricing

from $2.50 / 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

## Bien'ici Property Search Scraper

Pull property listings from bien'ici — France's leading real estate portal — at scale: prices, price-per-m², surface, rooms, energy and greenhouse-gas ratings, GPS coordinates, photos, and agency details for every sale and rental listing across France. Search by city, district, or postal code with structured filters, or paste a bien'ici search link and mirror it exactly. Built for property investors, estate agents, relocation services, and market analysts who need fresh French property data without hand-building search URLs or maintaining their own extraction pipeline.

### Why This Scraper?

- **Build a search with no URL needed** — pick a city, district, or postal code and the scraper resolves it for you, across all of France. Most bien'ici scrapers force you to hand-craft URLs; here you just type "Paris", "Lyon", or "75011".
- **11 property types in one multi-select** — apartment, house, loft, townhouse, castle/mansion, land, parking/garage, building, shop, office, and commercial premises. Mix any combination in a single run.
- **Energy (DPE) and greenhouse-gas (GES) ratings on every listing** — the A–G energy class and CO₂ class come standard, so you can filter and rank by energy performance without opening a single listing.
- **Price-per-m² and agency fees broken out** — each row carries `pricePerSquareMeter`, the `agencyFeePercentage`, and `feesChargedTo` (buyer or seller), ready for instant comparables and true-cost analysis.
- **GPS coordinates per listing** — `latitude` and `longitude` on every property for mapping, heat-mapping, and radius analysis.
- **Sale and rental in one actor** — flip a single dropdown; rental prices are normalized to monthly rent and tagged via `transactionType` so you never mix up a sale price with a rent.
- **Optional agency contact enrichment** — turn on details to pull each listing's agency name, phone, contact, and address, plus elevator and cellar count — a ready-made lead list for target areas.
- **Inline photos, no extra cost** — every listing arrives with its full photo URL array already attached, plus `energyValue`, condominium fees, floor, and publication date.
- **Five sort orders and full filter bands** — sort by relevance, price (low-high / high-low), newest, or largest surface, with min/max price, min/max surface, minimum rooms, and minimum bedrooms.

### Use Cases

**Real Estate Investment & Analysis**
- Compare price-per-m² across arrondissements, cities, and regions
- Spot under-priced listings by ranking on `pricePerSquareMeter`
- Track new-build developments surfacing in any area search
- Factor agency fees into true acquisition cost before you bid

**Market Research**
- Map live inventory by city, district, or postal code
- Compare apartment vs. house vs. land supply across French markets
- Monitor asking-price trends by sorting newest-first over time
- Benchmark energy-class distribution (A–G) across neighbourhoods

**Lead Generation for Agencies**
- Build agency contact lists with name, phone, and address
- Identify which agencies dominate a given area or property type
- Source competitor listings to pitch sellers and landlords

**Relocation & Property Search Services**
- Pull rental shortlists with monthly rent, surface, and rooms for clients
- Filter by minimum bedrooms and surface for family relocations
- Deliver geo-tagged options clients can map instantly

**Price & Comparable Analysis**
- Generate comparables tables by city and property type
- Track energy-rating premiums (A/B vs. F/G) on sale prices
- Feed clean, structured rows into dashboards and valuation models

### Getting Started

#### Search a City (simplest)

Just name a location — the scraper resolves it and returns sale listings:

```json
{
    "location": "Paris",
    "maxResults": 100
}
````

#### Filtered Rental Search

Apartments and lofts for rent in Lyon, under €1,500/month, at least 2 rooms:

```json
{
    "transactionType": "rent",
    "location": "Lyon",
    "propertyTypes": ["flat", "loft"],
    "priceMax": 1500,
    "roomsMin": 2,
    "sortBy": "priceAsc",
    "maxResults": 200
}
```

#### Advanced — Houses for Sale with Agency Contacts

Houses in Bordeaux, €300k–€800k, 80 m²+, with agency phone and contact pulled in:

```json
{
    "transactionType": "buy",
    "location": "Bordeaux",
    "propertyTypes": ["house"],
    "priceMin": 300000,
    "priceMax": 800000,
    "surfaceMin": 80,
    "bedroomsMin": 3,
    "sortBy": "newest",
    "includeDetails": true,
    "maxResults": 500
}
```

#### Paste a Bien'ici Search Link

Already set up a search on the site? Paste its URL and mirror it exactly:

```json
{
    "startUrls": [
        "https://www.bienici.com/recherche/achat/paris-75000",
        "https://www.bienici.com/recherche/location/lyon-69000"
    ],
    "maxResults": 300
}
```

### Input Reference

#### What to Scrape

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

#### Build a Search

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `transactionType` | select | `"buy"` | Search properties for sale or for rent. |
| `location` | string | `"Paris"` | City, district, or postal code (e.g. "Paris", "Lyon", "75011"). Required when not using a URL. |
| `propertyTypes` | string\[] | `[]` | Limit to specific types: Apartment, House, Loft, Townhouse, Castle/Mansion, Land, Parking/Garage, Building, Shop, Office, Commercial premises. Empty = all types. |
| `priceMin` | integer | `null` | Minimum price in euros (monthly rent for rentals). |
| `priceMax` | integer | `null` | Maximum price in euros (monthly rent for rentals). |
| `roomsMin` | integer | `null` | Minimum number of rooms (pièces). |
| `bedroomsMin` | integer | `null` | Minimum number of bedrooms (chambres). |
| `surfaceMin` | integer | `null` | Minimum living surface in m². |
| `surfaceMax` | integer | `null` | Maximum living surface in m². |
| `sortBy` | select | `"relevance"` | Order results: Most relevant, Price low→high, Price high→low, Newest first, or Largest surface first. |

#### Output Options

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `includeDetails` | boolean | `false` | Fetch each listing's agency contact details (name, phone, address) plus elevator and cellar count. Slower but richer. Off still returns price, surface, rooms, energy ratings, location, and photos. |

#### Limits

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `maxResults` | integer | `100` | Total listings to collect across all searches and URLs. Set to 0 for as many as available. |
| `maxResultsPerUrl` | integer | `0` | Maximum listings per individual search or URL. 0 = no per-URL limit (overall cap still applies). |
| `ignoreUrlFailures` | boolean | `true` | Skip any search or URL that fails and continue. When off, the run stops on the first failure. |

### Output

Each property is one flat row. Here's a representative result:

```json
{
    "id": "ad_64f8a1b2c3d4e5",
    "reference": "VA2034-BORDEAUX",
    "title": "Appartement 3 pièces 72 m²",
    "transactionType": "buy",
    "propertyType": "flat",
    "price": 465000,
    "priceWithoutFees": 450000,
    "pricePerSquareMeter": 6458,
    "agencyFeePercentage": 3.3,
    "feesChargedTo": "buyer",
    "surfaceArea": 72,
    "roomsQuantity": 3,
    "bedroomsQuantity": 2,
    "floor": 4,
    "floorQuantity": 6,
    "energyClassification": "C",
    "energyValue": 142,
    "greenhouseGazClassification": "B",
    "city": "Bordeaux",
    "postalCode": "33000",
    "district": "Chartrons",
    "departmentCode": "33",
    "latitude": 44.8578,
    "longitude": -0.5709,
    "newProperty": false,
    "isInCondominium": true,
    "annualCondominiumFees": 1800,
    "publicationDate": "2026-05-12T09:24:00Z",
    "photos": ["https://photos.bienici.com/12345-1.jpg", "https://photos.bienici.com/12345-2.jpg"],
    "agencyName": "Bordeaux Immobilier",
    "agencyPhone": "+33 5 56 00 00 00",
    "url": "https://www.bienici.com/annonce/vente/bordeaux/appartement/3-pieces/ad_64f8a1b2c3d4e5"
}
```

#### Core Fields

| Field | Type | Description |
|-------|------|-------------|
| `id` | string | Unique bien'ici listing identifier |
| `reference` | string | Agency reference for the listing |
| `title` | string | Listing title |
| `description` | string | Full listing description text |
| `transactionType` | string | "buy" or "rent" |
| `propertyType` | string | flat, house, loft, terrain, parking, etc. |
| `url` | string | Direct bien'ici listing link |
| `photos` | string\[] | Listing photo URLs (inline) |
| `isBienIciExclusive` | boolean | Listed exclusively on bien'ici |
| `with3dModel` | boolean | Has an interactive 3D model / virtual tour |
| `publicationDate` | string | First published date (ISO 8601) |
| `modificationDate` | string | Last modified date (ISO 8601) |

#### Pricing

| Field | Type | Description |
|-------|------|-------------|
| `price` | number | Price in euros (monthly rent for rentals) |
| `priceWithoutFees` | number | Price excluding agency fees |
| `pricePerSquareMeter` | number | Price per m² |
| `agencyFeePercentage` | number | Agency fee as a percentage |
| `feesChargedTo` | string | Who pays the agency fees (buyer / seller) |
| `priceHasDecreased` | boolean | Whether the price was recently cut |
| `annualCondominiumFees` | number | Annual condominium charges |

#### Property Details

| Field | Type | Description |
|-------|------|-------------|
| `surfaceArea` | number | Living surface in m² |
| `roomsQuantity` | number | Number of rooms (pièces) |
| `bedroomsQuantity` | number | Number of bedrooms (chambres) |
| `bathroomsQuantity` | number | Number of bathrooms (salles de bain) |
| `toiletQuantity` | number | Number of separate toilets |
| `floor` | number | Floor of the unit |
| `floorQuantity` | number | Floors in the building |
| `hasBalcony` | boolean | Has a balcony |
| `hasTerrace` | boolean | Has a terrace |
| `newProperty` | boolean | New-build flag |
| `isInCondominium` | boolean | Part of a condominium |
| `heating` | string | Heating type |
| `exposition` | string | Orientation / exposure |

#### Location

| Field | Type | Description |
|-------|------|-------------|
| `city` | string | City |
| `postalCode` | string | Postal code |
| `district` | string | District / neighbourhood name |
| `departmentCode` | string | Department code |
| `latitude` | number | Approximate latitude |
| `longitude` | number | Approximate longitude |

#### Energy Ratings

| Field | Type | Description |
|-------|------|-------------|
| `energyClassification` | string | DPE energy class (A–G) |
| `energyValue` | number | Energy consumption value |
| `greenhouseGazClassification` | string | Greenhouse-gas (GES) class (A–G) |
| `greenhouseGazValue` | number | Greenhouse-gas value |

#### Agency

Populated more fully when `includeDetails` is on.

| Field | Type | Description |
|-------|------|-------------|
| `agencyName` | string | Listing agency name |
| `agencyPhone` | string | Agency phone number |
| `agencyContactName` | string | Agency contact person |
| `agencyAddress` | string | Agency address |
| `hasElevator` | boolean | Elevator present |
| `cellarsOrUndergroundsQuantity` | number | Number of cellars / underground spaces |

### Tips for Best Results

- **Type a location, skip the URL** — entering "Paris", "Lyon", or a postal code like "75011" is faster and more reliable than hand-building a bien'ici link.
- **Split big cities to go deep** — bien'ici caps any single search at about 2,500 results. To pull a whole city, split by arrondissement, by price band, or by property type; each narrower search gets its own 2,500-result window.
- **Remember rentals are monthly** — for `rent` searches, `price`, `priceMin`, and `priceMax` are all monthly rent in euros, not annual.
- **Leave details off for speed** — keep `includeDetails` off when you only need price, surface, rooms, energy ratings, location, and photos. Turn it on only when you need agency phone, contact, and address.
- **Rank by `pricePerSquareMeter` for comps** — it's the cleanest single metric for spotting good value and building comparables tables across districts.
- **Filter by energy class for green portfolios** — every row carries the A–G DPE class, so you can isolate efficient stock (A/B) or renovation targets (F/G) without opening listings.
- **Start small, then scale** — run 50–100 results first to confirm the filters match your needs, then raise `maxResults`.

### Pricing

**From $2.50 per 1,000 results** — undercutting the typical French-property scraper while returning richer per-listing data. No compute or time-based charges — you pay per result, plus a small fixed per-run start fee. 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.30 | $0.28 | $0.265 | $0.25 |
| 1,000 | $3.00 | $2.80 | $2.65 | $2.50 |
| 10,000 | $30.00 | $28.00 | $26.50 | $25.00 |
| 100,000 | $300.00 | $280.00 | $265.00 | $250.00 |

A "result" is any property row in the output dataset. The fixed per-run start fee and Apify platform fees (which depend on your plan) are additional.

### 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. You are responsible for complying with applicable laws and bien'ici's Terms of Service. Do not use extracted data for spam, harassment, or any unlawful purpose, and handle any personal data (such as agency contact details) in line with GDPR and other applicable privacy regulations.

# Actor input Schema

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

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

## `transactionType` (type: `string`):

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

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

City, district, or postal code to search (for example 'Paris', 'Lyon', or '75011'). Required when building a search without a URL.

## `propertyTypes` (type: `array`):

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

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

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

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

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

## `roomsMin` (type: `integer`):

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

## `bedroomsMin` (type: `integer`):

Only include properties with at least this many bedrooms (chambres). Leave empty for no minimum.

## `surfaceMin` (type: `integer`):

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

## `surfaceMax` (type: `integer`):

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

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

Choose how bien'ici orders the results when building a search.

## `includeDetails` (type: `boolean`):

Fetch each listing's agency contact details (agency name, phone, address) plus a few extra specs like elevator and cellar count. This makes one extra request per listing, so runs take longer and cost more. Leave off for faster, cheaper runs that still include price, surface, rooms, energy ratings, location, and photos.

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

Total number of listings to collect across all searches and URLs. Set to 0 to collect as many as available. Note: bien'ici limits any single search to about 2,500 results — to go beyond that, narrow your filters (price, surface, type) or split the search by area or arrondissement.

## `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": [],
  "transactionType": "buy",
  "location": "Paris",
  "propertyTypes": [],
  "sortBy": "relevance",
  "includeDetails": false,
  "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, energy ratings, 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": [],
    "transactionType": "buy",
    "location": "Paris",
    "propertyTypes": [],
    "sortBy": "relevance",
    "includeDetails": false,
    "maxResults": 100,
    "maxResultsPerUrl": 0,
    "ignoreUrlFailures": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/bienici-com-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": [],
    "transactionType": "buy",
    "location": "Paris",
    "propertyTypes": [],
    "sortBy": "relevance",
    "includeDetails": False,
    "maxResults": 100,
    "maxResultsPerUrl": 0,
    "ignoreUrlFailures": True,
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/bienici-com-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": [],
  "transactionType": "buy",
  "location": "Paris",
  "propertyTypes": [],
  "sortBy": "relevance",
  "includeDetails": false,
  "maxResults": 100,
  "maxResultsPerUrl": 0,
  "ignoreUrlFailures": true
}' |
apify call solidcode/bienici-com-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Bien'ici Property Search Scraper",
        "description": "[💰 $2.5 / 1K] Extract property listings from bien'ici (bienici.com), a leading French real estate portal. Search by location, price, type, rooms, and surface, or paste search URLs. Get prices, fees, surface, rooms, energy ratings, photos, and agency details for sale and rental listings in France.",
        "version": "1.0",
        "x-build-id": "Fmkod3fEwzFHDh0oU"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~bienici-com-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-bienici-com-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~bienici-com-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-bienici-com-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~bienici-com-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-bienici-com-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 bien'ici search result URLs (for example a results page for 'achat' in Paris). The scraper reads the filters straight from each URL. Leave empty to build a search with the filter fields below.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "transactionType": {
                        "title": "Transaction Type",
                        "enum": [
                            "buy",
                            "rent"
                        ],
                        "type": "string",
                        "description": "Search properties for sale or for rent. Only applies when you build a search with the filters below (ignored when Search URLs are provided).",
                        "default": "buy"
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "City, district, or postal code to search (for example 'Paris', 'Lyon', or '75011'). Required when building a search without a URL."
                    },
                    "propertyTypes": {
                        "title": "Property Types",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Limit results to these property types. Leave empty to include all types.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "flat",
                                "house",
                                "loft",
                                "townhouse",
                                "castle",
                                "terrain",
                                "parking",
                                "building",
                                "shop",
                                "office",
                                "premises"
                            ],
                            "enumTitles": [
                                "Apartment",
                                "House",
                                "Loft",
                                "Townhouse",
                                "Castle / Mansion",
                                "Land",
                                "Parking / Garage",
                                "Building",
                                "Shop",
                                "Office",
                                "Commercial premises"
                            ]
                        },
                        "default": []
                    },
                    "priceMin": {
                        "title": "Minimum Price (€)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include listings at or above this price in euros. For rentals this is the monthly rent. Leave empty for no minimum."
                    },
                    "priceMax": {
                        "title": "Maximum Price (€)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include listings at or below this price in euros. For rentals this is the monthly rent. Leave empty for no maximum."
                    },
                    "roomsMin": {
                        "title": "Minimum Rooms",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include properties with at least this many rooms (pieces). Leave empty for no minimum."
                    },
                    "bedroomsMin": {
                        "title": "Minimum Bedrooms",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include properties with at least this many bedrooms (chambres). Leave empty for no minimum."
                    },
                    "surfaceMin": {
                        "title": "Minimum Surface Area (m²)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include properties with at least this living surface in square meters. Leave empty for no minimum."
                    },
                    "surfaceMax": {
                        "title": "Maximum Surface Area (m²)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include properties with at most this living surface in square meters. Leave empty for no maximum."
                    },
                    "sortBy": {
                        "title": "Sort By",
                        "enum": [
                            "relevance",
                            "priceAsc",
                            "priceDesc",
                            "newest",
                            "surfaceDesc"
                        ],
                        "type": "string",
                        "description": "Choose how bien'ici orders the results when building a search.",
                        "default": "relevance"
                    },
                    "includeDetails": {
                        "title": "Include Agency Contact Details",
                        "type": "boolean",
                        "description": "Fetch each listing's agency contact details (agency name, phone, address) plus a few extra specs like elevator and cellar count. This makes one extra request per listing, so runs take longer and cost more. Leave off for faster, cheaper runs that still include price, surface, rooms, energy ratings, location, and photos.",
                        "default": false
                    },
                    "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: bien'ici limits any single search to about 2,500 results — to go beyond that, narrow your filters (price, surface, type) or split the search by area or arrondissement.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
