# Bienici Scraper (`gauzy_penguin/bienici-scraper`) Actor

Scrapes realestate listings from Bienici.com website. Supports keyword search, categories, price filters, item conditions, pagination, and rate-limit handling. Designed for stable, production-scale scraping.

- **URL**: https://apify.com/gauzy\_penguin/bienici-scraper.md
- **Developed by:** [locas mora](https://apify.com/gauzy_penguin) (community)
- **Categories:** Real estate, Lead generation, AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.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

## Bienici Scraper — French Real Estate Listings API

Extract structured property data from [Bienici.com](https://www.bienici.com), France's leading real estate aggregator. Scrape apartments, houses, and villas listed for **sale or rent** across all French cities — no API key, no login, no limits.

---

## Performance Overview:

This run demonstrates the actor’s production-grade efficiency, processing 3000 listings in 23 seconds with low memory usage (~90 MB avg) and stable CPU utilization, confirming strong scalability and I/O-optimized architecture.

![production-grade efficiency](https://api.apify.com/v2/key-value-stores/bfCbIXneBpZEREunx/records/bienici_run.png)


### What This Actor Does

The **Bienici Scraper** sends requests directly to Bienici's internal search API and returns clean, structured JSON for every listing it finds. You control what you scrape: transaction type (buy or rent), property type (apartment, house, land…), sort order, and how many results you need.

Each output record contains everything a real estate data pipeline needs: price, surface area, number of rooms, GPS coordinates, energy rating (DPE), condominium fees, photos, and publication date — ready to load into a database, spreadsheet, or BI tool.

---

### Key Features

- **Buys and rentals** — scrape `buy` and `rent` listings independently or together
- **All property types** — apartments, houses, lofts, land, parking, buildings, castles ...
- **Flexible sorting** — by publication date, price, surface area, or price per m²
- **Up to 15,000 listings per run** — configurable batch size for safe, respectful scraping
- **Automatic retries** — exponential back-off on rate limits and server errors
- **Clean output** — nested JSON flattened into analysis-ready fields

---

### Output Fields

Each scraped listing returns a flat JSON object with the following fields:

| Field | Type | Description |
|---|---|---|
| `id` | string | Bienici listing ID |
| `reference` | string | Agency reference number |
| `title` | string | Listing title |
| `description` | string | Full listing description |
| `adType` | string | `buy` or `rent` |
| `propertyType` | string | `flat`, `house`, `loft`, etc. |
| `city` | string | City name |
| `postalCode` | string | French postal code |
| `district` | string | Neighborhood name |
| `departmentCode` | string | French department number |
| `lat` / `lon` | float | Approximate GPS coordinates |
| `price` | integer | Listing price in EUR |
| `pricePerSquareMeter` | float | EUR/m² |
| `priceWithoutFees` | integer | Price net of agency fees |
| `feesChargedTo` | string | `seller` or `buyer` |
| `annualCondominiumFees` | integer | Annual copro charges in EUR |
| `surfaceArea` | float | Total area in m² |
| `roomsQuantity` | integer | Total rooms |
| `bedroomsQuantity` | integer | Bedrooms |
| `floor` | integer | Floor number |
| `floorQuantity` | integer | Building floors |
| `yearOfConstruction` | integer | Year built |
| `hasElevator` | boolean | Elevator in building |
| `hasCellar` | boolean | Private cellar |
| `parkingPlacesQuantity` | integer | Parking spots |
| `heating` | string | Heating type description |
| `energyClassification` | string | DPE energy class (A–G) |
| `greenhouseGazClassification` | string | GES class (A–G) |
| `energyValue` | integer | Primary energy consumption (kWh/m²/year) |
| `newProperty` | boolean | New-build flag |
| `isInCondominium` | boolean | Part of a condominium |
| `accountType` | string | `agency` or `private` |
| `publicationDate` | ISO 8601 | Date listed |
| `modificationDate` | ISO 8601 | Date last updated |
| `photos` | array | List of photo URLs |
| `photoCount` | integer | Number of photos |
| `opticalFiberStatus` | string | Fiber availability status |

---

### Sample Output

```json
{
  "id": "immo-facile-60851947",
  "reference": "P20590",
  "title": "Appartement Troyes 4 pièce(s)",
  "adType": "buy",
  "propertyType": "flat",
  "city": "Troyes",
  "postalCode": "10000",
  "district": "Troyes - Charmilles",
  "departmentCode": "10",
  "lat": 48.29785,
  "lon": 4.09137,
  "price": 160000,
  "pricePerSquareMeter": 2170.67,
  "priceWithoutFees": 160000,
  "feesChargedTo": "seller",
  "annualCondominiumFees": 936,
  "surfaceArea": 73.71,
  "roomsQuantity": 4,
  "bedroomsQuantity": 2,
  "floor": 1,
  "floorQuantity": 4,
  "yearOfConstruction": 1955,
  "hasElevator": false,
  "hasCellar": true,
  "parkingPlacesQuantity": 1,
  "heating": "radiateur gaz individuel",
  "energyClassification": "C",
  "greenhouseGazClassification": "C",
  "energyValue": 122,
  "newProperty": false,
  "isInCondominium": true,
  "accountType": "agency",
  "publicationDate": "2026-06-24T09:23:26.519Z",
  "photos": [
    "https://file.bienici.com/photo/immo-facile-60851947_..._a.jpg",
    "https://file.bienici.com/photo/immo-facile-60851947_..._b.jpg"
  ],
  "photoCount": 10,
  "opticalFiberStatus": "en cours de deploiement"
}
````

***

### Input Parameters

| Parameter | Type | Required | Default | Description |
|---|---|---|---|---|
| `adType` | array | ✅ | `["buy"]` | Transaction type: `buy`, `rent`, or both |
| `propertyTypes` | array | ✅ | `["flat"]` | Property types to scrape (see options below) |
| `sortBy` | string | | `publicationDate` | Sort field |
| `sortOrder` | string | | `desc` | `asc` or `desc` |
| `maxItems` | integer | | `500` | Max listings per transaction type (500 – 15,000) |

#### Supported Property Types

| Value | Label |
|---|---|
| `flat` | Apartment |
| `house` | House / Villa |
| `parking` | Parking space |
| `terrain` | Land / Plot |
| `loft` | Loft |
| `building` | Entire building |
| `castle` | Castle |
| `prestige` | Prestige property |
| `townhouse` | Townhouse |
| `shop` | Shop |
| `premise` | Local Commercial |
| `office` | Offices |
| `others` | Others |

***

### How to Use

#### Via Apify Console

1. Click **Try for free**
2. Select your transaction type and property types
3. Set `maxItems` (start with 500 to test)
4. Click **Start** and wait for results
5. Export as JSON, CSV, or connect directly via the [Apify API](https://docs.apify.com/api/v2)

***

### Common Use Cases

**Market analysis** — pull all listings in a département, calculate median price/m², track how prices change week over week.

**Lead generation for real estate agencies** — identify newly listed properties in a target area sorted by `publicationDate desc` to catch fresh inventory before competitors.

**Investment research** — filter apartments in a city, cross-reference DPE ratings with price to find undervalued energy-efficient properties.

**Automated price alerts** — schedule daily runs, compare new listings against a stored baseline, trigger a webhook when a property matches your criteria.

**Training data for property valuation models** — collect thousands of labeled examples (price, surface, location, features) to train regression or neural network models.

**Rental yield mapping** — combine buy and rent prices for the same zones to estimate gross rental yields by city or neighborhood.

***

### Scheduler & Automation Tips

- **Freshness monitoring**: schedule a daily run with `sortBy: publicationDate`, `sortOrder: desc`, `maxItems: 500` to capture new listings
- **Full market snapshot**: run weekly with `maxItems: 15000` across all property types for a complete dataset
- **Incremental deduplication**: use the `id` field as a unique key to upsert into your database and avoid duplicate records
- **Webhook integration**: connect to Zapier, Make, or a custom endpoint via Apify's built-in webhook system to trigger actions on new data

***

### Performance & Reliability

- Each API request fetches up to 500 listings
- Automatic exponential back-off on `429`, `403`, and `5xx` responses (up to 5 retries)
- A run of 3000 listings completes in under 23 seconds
- A full run of 15,000 listings typically completes in under 3 minutes
- Results are pushed to Apify's dataset in batches of 50, so partial results are always saved even if a run is interrupted

***

### Legal & Ethical Use

This actor accesses publicly available listing data that Bienici displays to all visitors. It respects the site's rate limits through automatic throttling and does not access any authenticated or private content.

Users are responsible for ensuring their use of scraped data complies with applicable laws (including GDPR for personal data) and Bienici's terms of service. This actor is intended for research, analytics, and business intelligence use cases.

***

### Support

Found a bug or need a custom field? Open an issue or reach out via the Apify contact form on this actor's page. Feature requests (additional filters, webhook support, Google Sheets integration) are welcome.

# Actor input Schema

## `adType` (type: `array`):

Choose whether to scrape listings for sale, for rent, or both.

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

Select one or more property types to scrape.

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

Choose how listings are ordered.

## `sortOrder` (type: `string`):

Ascending or descending sort direction.

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

Maximum number of listings to retrieve per transaction type.

## Actor input object example

```json
{
  "adType": [
    "buy"
  ],
  "propertyTypes": [
    "flat"
  ],
  "sortBy": "publicationDate",
  "sortOrder": "desc",
  "maxItems": 500
}
```

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("gauzy_penguin/bienici-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("gauzy_penguin/bienici-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 '{}' |
apify call gauzy_penguin/bienici-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Bienici Scraper",
        "description": "Scrapes realestate listings from Bienici.com website. Supports keyword search, categories, price filters, item conditions, pagination, and rate-limit handling. Designed for stable, production-scale scraping.",
        "version": "1.0",
        "x-build-id": "ftKwjAgib14S6dYct"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/gauzy_penguin~bienici-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-gauzy_penguin-bienici-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/gauzy_penguin~bienici-scraper/runs": {
            "post": {
                "operationId": "runs-sync-gauzy_penguin-bienici-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/gauzy_penguin~bienici-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-gauzy_penguin-bienici-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",
                "required": [
                    "adType",
                    "propertyTypes"
                ],
                "properties": {
                    "adType": {
                        "title": "Transaction Type",
                        "type": "array",
                        "description": "Choose whether to scrape listings for sale, for rent, or both.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "buy",
                                "rent"
                            ],
                            "enumTitles": [
                                "Buy",
                                "Rent"
                            ]
                        },
                        "default": [
                            "buy"
                        ]
                    },
                    "propertyTypes": {
                        "title": "Property Types",
                        "type": "array",
                        "description": "Select one or more property types to scrape.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "flat",
                                "house",
                                "parking",
                                "terrain",
                                "loft",
                                "building",
                                "castle",
                                "prestige",
                                "townhouse",
                                "shop",
                                "premises",
                                "office",
                                "others"
                            ],
                            "enumTitles": [
                                "Apartment",
                                "House / Villa",
                                "Parking",
                                "Land",
                                "Loft",
                                "Building",
                                "Castle",
                                "Prestige",
                                "Townhouse",
                                "Shop",
                                "Local Commercial",
                                "Office",
                                "Others"
                            ]
                        },
                        "default": [
                            "flat"
                        ]
                    },
                    "sortBy": {
                        "title": "Sort Results By",
                        "enum": [
                            "publicationDate",
                            "price",
                            "surfaceArea",
                            "pricePerSquareMeter"
                        ],
                        "type": "string",
                        "description": "Choose how listings are ordered.",
                        "default": "publicationDate"
                    },
                    "sortOrder": {
                        "title": "Sort Order",
                        "enum": [
                            "desc",
                            "asc"
                        ],
                        "type": "string",
                        "description": "Ascending or descending sort direction.",
                        "default": "desc"
                    },
                    "maxItems": {
                        "title": "Maximum Items",
                        "minimum": 500,
                        "maximum": 15000,
                        "type": "integer",
                        "description": "Maximum number of listings to retrieve per transaction type.",
                        "default": 500
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
