# Bien Ici French Real Estate Scraper (`parseforge/bienici-real-estate-scraper`) Actor

Scrape French real estate listings from BienIci. Get rent or sale price, surface, rooms, postal code, address, agent contact, photos, and 40+ fields. No API key required.

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

## Pricing

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

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 🏡 Bien Ici French Real Estate Scraper

> 🚀 **Export French real estate listings in seconds.** Pull **rent or sale prices, surface, rooms, postal codes, agent type, energy class, photos, and 40+ fields** from BienIci. No API key, no registration, no manual CSV wrangling.

> 🕒 **Last updated:** 2026-05-13 · **📊 42 fields** per record · **🏡 900,000+ live listings** · **🇫🇷 All of France** · **🏢 13 property types**

The **BienIci Scraper** exports the live French property catalog from BienIci, one of the country's largest real-estate marketplaces. Every record returns **42 normalized fields**, including transaction type (rent vs buy), price, price per square meter, surface area, rooms, bedrooms, bathrooms, floor info, energy and GHG classifications, parking, heating, exact or blurred coordinates, district, postal code, department code, account type (agency vs notary vs network), publication and modification dates, photo gallery, and full description in French.

The marketplace covers **every French region and over 900,000 active listings** at any moment, spanning flats, houses, lofts, townhouses, castles, mansions, buildings, parking spaces, land, offices, shops, and commercial premises. This Actor surfaces that catalog through a single input form and returns the data as CSV, Excel, JSON, or XML in under five minutes.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Real-estate agencies, prop-tech startups, rental aggregators, market analysts, investors, relocation services, journalists | Rental and sale market analysis, comparable-property research, lead enrichment, portal feed sync, price-per-m² benchmarking, district-level investment scoring |

---

### 📋 What the BienIci Scraper does

Eight filtering workflows in a single run:

- 🛒 **Transaction type.** Rent listings or properties for sale.
- 🏢 **Property type filter.** One or more of 13 types (flat, house, loft, townhouse, castle, mansion, building, parking, land, premises, office, shop, other).
- 💶 **Price range.** Min and max in EUR (monthly rent for rentals, total price for sales).
- 📐 **Surface range.** Min and max living surface in square meters.
- 🚪 **Rooms and bedrooms.** Minimum rooms (pièces) and minimum bedrooms.
- 📮 **Postal code prefix.** Two-digit department prefix (e.g. `75` Paris, `69` Lyon, `13` Marseille).

Each record includes price, surface, rooms, bedrooms, bathrooms, floor, floor count, balcony/garden/cellar/intercom/separate-toilet flags, parking spots, heating type, energy classification (DPE), GHG classification, full French description, city, postal code, district, department code, latitude, longitude, address-known flag, agent account type, BienIci exclusivity flag, new-build flag, 3D virtual-tour flag, photo count and gallery URLs, reference, publication and modification dates, availability date, agency rental fee, safety deposit, and the original French ad type label.

> 💡 **Why it matters:** BienIci is a public catalog with a JSON search API, but the filters are non-trivial, the response is heavily nested, and pricing semantics differ between rent and sale. This Actor normalizes that into one consistent 42-field schema across every transaction type and property class, so analytics and dashboards just work.

---

### 🎬 Full Demo

_🚧 Coming soon: a 3-minute walkthrough showing how to go from sign-up to a downloaded French real estate dataset._

---

### ⚙️ Input

<table>
<thead>
<tr><th>Input</th><th>Type</th><th>Default</th><th>Behavior</th></tr>
</thead>
<tbody>
<tr><td><code>transactionType</code></td><td>enum</td><td><code>"buy"</code></td><td><code>"rent"</code> or <code>"buy"</code>. Required.</td></tr>
<tr><td><code>maxItems</code></td><td>integer</td><td><code>10</code></td><td>Records to return. Free plan caps at 10, paid plan at 1,000,000.</td></tr>
<tr><td><code>propertyType</code></td><td>string[]</td><td><code>[]</code></td><td>One or more of 13 BienIci property-type slugs. Empty = all types.</td></tr>
<tr><td><code>priceMin</code>, <code>priceMax</code></td><td>integer (EUR)</td><td><code>null</code></td><td>Price range. Monthly rent for <code>rent</code>, total for <code>buy</code>.</td></tr>
<tr><td><code>surfaceMin</code>, <code>surfaceMax</code></td><td>integer (m²)</td><td><code>null</code></td><td>Living surface range.</td></tr>
<tr><td><code>roomsMin</code>, <code>bedroomsMin</code></td><td>integer</td><td><code>null</code></td><td>Minimum rooms (pièces) and bedrooms.</td></tr>
<tr><td><code>postalCode</code></td><td>string</td><td><code>""</code></td><td>French postal code prefix (e.g. <code>75</code>, <code>69</code>, <code>13</code>).</td></tr>
</tbody>
</table>

**Example: 50 Paris flats for sale under EUR 800K with 2+ bedrooms.**

```json
{
    "transactionType": "buy",
    "maxItems": 50,
    "propertyType": ["flat"],
    "priceMax": 800000,
    "bedroomsMin": 2,
    "postalCode": "75"
}
````

**Example: rentals in Lyon between EUR 800 and EUR 1,500 / month.**

```json
{
    "transactionType": "rent",
    "maxItems": 100,
    "priceMin": 800,
    "priceMax": 1500,
    "postalCode": "69"
}
```

> ⚠️ **Good to Know:** for privacy reasons, BienIci often returns a blurred centroid (within a small radius) rather than the exact street-level coordinates. The `addressKnown` flag tells you which records have a precise location. Pricing on listings is what the seller or agent has published and may differ from the eventual transaction price.

***

### 📊 Output

Each listing record contains **42 fields**. Download the dataset as CSV, Excel, JSON, or XML.

#### 🧾 Schema

| Field | Type | Example |
|---|---|---|
| 🖼️ `imageUrl` | string | null | `"https://photos.bienici.com/..."` |
| 🆔 `id` | string | `"ag750647-48389199"` |
| 🔗 `url` | string | `"https://www.bienici.com/annonce/..."` |
| 🏷️ `title` | string | null | `"Appartement 3 pièces Paris 15e"` |
| 🛒 `transactionType` | string | `"buy"` |
| 🏢 `propertyType` | string | null | `"flat"` |
| 💶 `price` | number | null | `545000` |
| 📐 `pricePerSquareMeter` | number | null | `8530` |
| 💸 `monthlyCharges` | number (optional) | `185` |
| 📏 `surfaceArea` | number | null | `64` |
| 🚪 `rooms` | number | null | `3` |
| 🛏️ `bedrooms` | number | null | `2` |
| 🛁 `bathrooms` | number | null | `1` |
| 🏢 `floor` / `floorQuantity` | number | null | `4` / `7` |
| 🌿 `hasBalcony`, `hasGarden`, `hasCellar`, `hasIntercom`, `hasSeparateToilet` | boolean | null | `true` |
| 🚗 `parkingPlaces` | number | null | `1` |
| 🔥 `heating` | string | null | `"individual gas"` |
| 🌱 `energyClassification` | string | null | `"C"` |
| 💨 `ghgClassification` | string (optional) | `"D"` |
| 📝 `description` | string | null | `"Au coeur du 15e..."` |
| 🏙️ `city` | string | null | `"Paris 15e"` |
| 📮 `postalCode` | string | null | `"75015"` |
| 🗺️ `district` | string | null | `"Saint-Lambert"` |
| 🔢 `departmentCode` | string | null | `"75"` |
| 📍 `latitude` / `longitude` | number | null | `48.838 / 2.305` |
| 📌 `addressKnown` | boolean | null | `false` |
| 🏷️ `accountType` | string | null | `"agency"` |
| ⭐ `isBienIciExclusive` | boolean | null | `true` |
| 🆕 `isNewProperty` | boolean | null | `false` |
| 🎥 `is3DEnabled` | boolean | null | `false` |
| 🖼️ `photoCount` | number | `12` |
| 🖼️ `photos` | string\[] | `["...","..."]` |
| 📎 `reference` | string | null | `"4823-VP"` |
| 📅 `publicationDate` / `modificationDate` | ISO 8601 (optional) | `"2026-04-12T..."` |
| 📆 `availableDate` | ISO 8601 | null | `"2026-06-01T..."` |
| 💼 `agencyRentalFee` | number (optional) | `850` |
| 🛡️ `safetyDeposit` | number (optional) | `1700` |
| 🇫🇷 `adTypeFR` | string | null | `"vente"` |
| 🕒 `scrapedAt` | ISO 8601 | `"2026-05-13T10:00:00.000Z"` |

#### 📦 Sample record

<details>
<summary><strong>🏢 Paris flat for sale, 64 m², 3 rooms</strong></summary>

```json
{
    "imageUrl": "https://photos.bienici.com/sample-1.jpg",
    "id": "ag750647-48389199",
    "url": "https://www.bienici.com/annonce/achat/paris-15e/appartement/ag750647-48389199",
    "title": "Appartement 3 pièces Paris 15e",
    "transactionType": "buy",
    "propertyType": "flat",
    "price": 545000,
    "pricePerSquareMeter": 8530,
    "monthlyCharges": 185,
    "surfaceArea": 64,
    "rooms": 3,
    "bedrooms": 2,
    "bathrooms": 1,
    "floor": 4,
    "floorQuantity": 7,
    "hasBalcony": true,
    "hasGarden": false,
    "hasCellar": true,
    "hasIntercom": true,
    "hasSeparateToilet": true,
    "parkingPlaces": 0,
    "heating": "individual gas",
    "energyClassification": "C",
    "ghgClassification": "D",
    "description": "Au coeur du 15e arrondissement, appartement lumineux...",
    "city": "Paris 15e",
    "postalCode": "75015",
    "district": "Saint-Lambert",
    "departmentCode": "75",
    "latitude": 48.838,
    "longitude": 2.305,
    "addressKnown": false,
    "accountType": "agency",
    "isBienIciExclusive": true,
    "isNewProperty": false,
    "is3DEnabled": false,
    "photoCount": 12,
    "photos": ["https://photos.bienici.com/sample-1.jpg"],
    "reference": "4823-VP",
    "publicationDate": "2026-04-12T08:20:00.000Z",
    "availableDate": "2026-06-01T00:00:00.000Z",
    "adTypeFR": "vente",
    "scrapedAt": "2026-05-13T10:00:00.000Z"
}
```

</details>

***

### ✨ Why choose this Actor

| | Capability |
|---|---|
| 🇫🇷 | **All of France.** 900,000+ live listings, every region, every department, every property class. |
| 🛒 | **Rent and buy in one Actor.** Switch `transactionType` and the same schema and filters apply. |
| 📊 | **42 normalized fields.** Price, price-per-m², surface, rooms, energy class, GHG, photos, agent type, all consistent across record types. |
| 🌱 | **DPE and GHG ready.** Energy and greenhouse-gas classifications for every record where the seller has published the diagnostic. |
| 🎯 | **Eight filters that combine.** Type, price, surface, rooms, bedrooms, postal code prefix all chainable in one input form. |
| ⚡ | **Fast.** 100 listings in under 30 seconds, 1,000 in under 5 minutes. |
| 🚫 | **No login.** The BienIci search API is public; no credentials needed. |

> 📊 Clean French property data underpins every comparable analysis, agency CRM, relocation tool, and investment dashboard in the FR market.

***

### 📈 How it compares to alternatives

| Approach | Cost | Coverage | Refresh | Filters | Setup |
|---|---|---|---|---|---|
| **⭐ BienIci Scraper** *(this Actor)* | $5 free credit, then pay-per-use | **900,000+** live listings | **Live per run** | type, price, surface, rooms, postal | ⚡ 2 min |
| Manual BienIci browsing | Free | One result page at a time | Manual | Built-in UI filters | 🐢 Tedious |
| Generic FR portal aggregators | EUR 99+/month | Mixed quality | Daily | Vendor-defined | ⏳ Hours |
| Custom scraper build | Engineering time | Full | Live | Custom | 🕒 Days |

Pick this Actor when you want a clean, normalized French listing feed without maintaining a scraper yourself.

***

### 🚀 How to use

1. 📝 **Sign up.** [Create a free account with $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp) (takes 2 minutes).
2. 🌐 **Open the Actor.** Go to the BienIci French Real Estate Scraper page on the Apify Store.
3. 🎯 **Set input.** Pick `rent` or `buy`, optionally add property type, price, surface, postal code, and set `maxItems`.
4. 🚀 **Run it.** Click **Start** and let the Actor collect your data.
5. 📥 **Download.** Grab your results in the **Dataset** tab as CSV, Excel, JSON, or XML.

> ⏱️ Total time from signup to downloaded dataset: **3-5 minutes.** No coding required.

***

### 💼 Business use cases

<table>
<tr>
<td width="50%" valign="top">

#### 🏢 Real-estate Agencies and Brokers

- Build comparable-property reports with live local pricing
- Track rival agencies' new listings within hours of publication
- Feed CRM and pipeline tools with daily fresh leads
- Enrich expired-listing follow-ups with current market context

</td>
<td width="50%" valign="top">

#### 📊 Market Analysts and Investors

- Compute price-per-m² benchmarks by district and postal code
- Track sale-to-rent yield gaps across French cities
- Spot inventory shifts after policy or rate changes
- Build investment-grade scoring on rental yield and DPE class

</td>
</tr>
<tr>
<td width="50%" valign="top">

#### 🚚 Relocation and Property-Tech

- Power expat housing search with fresh, filterable listings
- Match employee-mobility budgets to live rental inventory
- Sync rental feeds into Slack or HR tools
- Build a candidate-shortlist email digest from a daily run

</td>
<td width="50%" valign="top">

#### 🗞️ Journalism and Civic Research

- Track price evolution across French regions month over month
- Investigate short-let conversions in tourist neighborhoods
- Quantify new-build supply vs existing stock
- Build interactive maps for local-news real estate coverage

</td>
</tr>
</table>

***

### 🔌 Automating BienIci Scraper

Control the scraper programmatically for scheduled runs and pipeline integrations:

- 🟢 **Node.js.** Install the `apify-client` NPM package.
- 🐍 **Python.** Use the `apify-client` PyPI package.
- 📚 See the [Apify API documentation](https://docs.apify.com/api/v2) for full details.

The [Apify Schedules feature](https://docs.apify.com/platform/schedules) lets you trigger this Actor on any cron interval. Hourly, daily, or weekly refreshes keep downstream databases in sync automatically.

***

### 🌟 Beyond business use cases

Data like this powers more than commercial workflows. The same structured records support research, education, civic projects, and personal initiatives.

<table>
<tr>
<td width="50%">

#### 🎓 Research and academia

- Urban-economics papers on rent gradients in French metros
- Real-estate finance coursework with live transaction data
- Reproducible studies on energy-efficiency premiums (DPE)
- Theses on supply elasticity and policy effects

</td>
<td width="50%">

#### 🎨 Personal and creative

- Personal house-hunting dashboards across regions
- Side projects mapping price-per-m² heatmaps
- Travel and relocation blogs with live inventory snapshots
- Hobby visualizations of French architecture types

</td>
</tr>
<tr>
<td width="50%">

#### 🤝 Non-profit and civic

- Housing-affordability research for civic groups
- Local-government dashboards on rental market tension
- Investigative journalism on housing inequality
- Tenant-rights orgs comparing advertised vs market rents

</td>
<td width="50%">

#### 🧪 Experimentation

- Train price-prediction ML models on real listings
- Prototype agent pipelines that recommend properties
- Test recommendation engines on a real listing feed
- Validate prop-tech product hypotheses with live data

</td>
</tr>
</table>

***

### 🤖 Ask an AI assistant about this scraper

Open a ready-to-send prompt about this ParseForge actor in the AI of your choice:

- 💬 [**ChatGPT**](https://chat.openai.com/?q=How%20do%20I%20use%20the%20BienIci%20French%20Real%20Estate%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🧠 [**Claude**](https://claude.ai/new?q=How%20do%20I%20use%20the%20BienIci%20French%20Real%20Estate%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🔍 [**Perplexity**](https://perplexity.ai/search?q=How%20do%20I%20use%20the%20BienIci%20French%20Real%20Estate%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🅒 [**Copilot**](https://copilot.microsoft.com/?q=How%20do%20I%20use%20the%20BienIci%20French%20Real%20Estate%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)

***

### ❓ Frequently Asked Questions

#### 🧩 How does it work?

Set `transactionType`, optionally add filters and `maxItems`, click Start, and the Actor hits the public BienIci search API and emits one normalized record per listing. No browser automation, no captchas, no setup.

#### 🏡 What property types are covered?

13 BienIci slugs: flat, house, loft, townhouse, castle, mansion, building, parking, land, premises, office, shop, and other. Leave the `propertyType` filter empty to return every type at once.

#### 📍 Are the coordinates exact?

BienIci often returns a blurred centroid (within a small radius) rather than the exact street-level coordinates, for privacy reasons. The `addressKnown` boolean indicates which records have precise positioning.

#### 💶 How are rent vs sale prices reported?

For `transactionType: "rent"`, the `price` field is monthly rent in EUR. For `transactionType: "buy"`, it is the total sale price in EUR. `pricePerSquareMeter` is computed from price and surface for both types.

#### 🌱 What is the DPE and GHG field?

`energyClassification` is the French DPE (Diagnostic de Performance Energétique) class, A through G. `ghgClassification` is the greenhouse-gas emissions class on the same A-G scale. Both reflect the diagnostic published by the seller or agent.

#### ⏰ Can I schedule regular runs?

Yes. Use Apify Schedules to run this Actor on any cron interval (hourly, daily, weekly) and keep a downstream database in sync with new listings.

#### 🔁 What happens to delisted properties?

The Actor returns only listings currently active on BienIci. Once a property is sold, rented, or pulled by the agent, it disappears from future runs.

#### 💳 Do I need a paid Apify plan to use this Actor?

No. The free Apify plan is enough for testing and small runs (10 records per run). A paid plan lifts the limit and gives you access to scheduling, higher concurrency, and larger datasets.

#### ⚖️ Is this data legal to use?

The BienIci search API is public. The Actor reads only what any visitor to bienici.com can see. Downstream republishing or commercial use is your responsibility under your own terms and the publisher's.

#### 🆘 What if I need help?

Our support team is here to help. Contact us through the Apify platform or use the Tally form linked below.

***

### 🔌 Integrate with any app

BienIci Scraper connects to any cloud service via [Apify integrations](https://apify.com/integrations):

- [**Make**](https://docs.apify.com/platform/integrations/make) - Automate multi-step workflows
- [**Zapier**](https://docs.apify.com/platform/integrations/zapier) - Connect with 5,000+ apps
- [**Slack**](https://docs.apify.com/platform/integrations/slack) - Get notified when a new listing matches your filters
- [**Airbyte**](https://docs.apify.com/platform/integrations/airbyte) - Pipe French listings into your warehouse
- [**GitHub**](https://docs.apify.com/platform/integrations/github) - Trigger runs from commits and releases
- [**Google Drive**](https://docs.apify.com/platform/integrations/drive) - Export datasets straight to Sheets

You can also use webhooks to trigger downstream actions when a run finishes. Push fresh BienIci listings into your CRM or product backend.

***

### 🔗 Recommended Actors

- [**🏠 Greatschools Scraper**](https://apify.com/parseforge/greatschools-scraper) - U.S. school ratings paired well with relocation data
- [**🛥️ YATCO Yacht Listing Scraper**](https://apify.com/parseforge/yatco-scraper) - Luxury yacht inventory
- [**🏛️ James Edition Real Estate Scraper**](https://apify.com/parseforge/james-edition-real-estate-scraper) - Luxury international real estate
- [**🚗 Copart Public Search Scraper**](https://apify.com/parseforge/copart-public-search-scraper) - Salvage vehicle auctions
- [**📰 PR Newswire Scraper**](https://apify.com/parseforge/pr-newswire-scraper) - Press releases and corporate announcements

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for more public-data scrapers.

***

**🆘 Need Help?** [**Open our contact form**](https://tally.so/r/BzdKgA) to request a new scraper, propose a custom data project, or report an issue.

***

> **⚠️ Disclaimer:** this Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by BienIci or any of its publishing partners. All trademarks mentioned are the property of their respective owners. Only publicly available real-estate listings are collected.

# Actor input Schema

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

Rent listings or properties for sale

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

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

## `propertyType` (type: `array`):

One or more BienIci propertyType slugs. Empty = all types.

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

Minimum price; for rent this is monthly rent in EUR, for buy this is total price

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

Maximum price; for rent this is monthly rent in EUR, for buy this is total price

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

Minimum living surface in square meters

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

Maximum living surface in square meters

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

Minimum number of rooms (pièces)

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

Minimum number of bedrooms

## `postalCode` (type: `string`):

French postal code prefix (e.g. '75' for Paris, '69' for Lyon, '13' for Marseille). Leave empty for nationwide results.

## Actor input object example

```json
{
  "transactionType": "buy",
  "maxItems": 10
}
```

# Actor output Schema

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

Overview of scraped data

## `fullData` (type: `string`):

Complete dataset

# 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 = {
    "transactionType": "buy",
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/bienici-real-estate-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 = {
    "transactionType": "buy",
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/bienici-real-estate-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 '{
  "transactionType": "buy",
  "maxItems": 10
}' |
apify call parseforge/bienici-real-estate-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Bien Ici French Real Estate Scraper",
        "description": "Scrape French real estate listings from BienIci. Get rent or sale price, surface, rooms, postal code, address, agent contact, photos, and 40+ fields. No API key required.",
        "version": "0.0",
        "x-build-id": "SCKuhHsqkyONgeDSO"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~bienici-real-estate-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-bienici-real-estate-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/parseforge~bienici-real-estate-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-bienici-real-estate-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/parseforge~bienici-real-estate-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-bienici-real-estate-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": [
                    "transactionType"
                ],
                "properties": {
                    "transactionType": {
                        "title": "Transaction type",
                        "enum": [
                            "rent",
                            "buy"
                        ],
                        "type": "string",
                        "description": "Rent listings or properties for sale"
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    },
                    "propertyType": {
                        "title": "Property type(s)",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "One or more BienIci propertyType slugs. Empty = all types.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "flat",
                                "house",
                                "loft",
                                "townhouse",
                                "castle",
                                "mansion",
                                "building",
                                "parking",
                                "land",
                                "premises",
                                "office",
                                "shop",
                                "others"
                            ],
                            "enumTitles": [
                                "Flat / Apartment",
                                "House",
                                "Loft",
                                "Townhouse",
                                "Castle",
                                "Mansion",
                                "Building",
                                "Parking",
                                "Land",
                                "Premises",
                                "Office",
                                "Shop",
                                "Other"
                            ]
                        }
                    },
                    "priceMin": {
                        "title": "Min price (EUR)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum price; for rent this is monthly rent in EUR, for buy this is total price"
                    },
                    "priceMax": {
                        "title": "Max price (EUR)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum price; for rent this is monthly rent in EUR, for buy this is total price"
                    },
                    "surfaceMin": {
                        "title": "Min surface (m²)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum living surface in square meters"
                    },
                    "surfaceMax": {
                        "title": "Max surface (m²)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum living surface in square meters"
                    },
                    "roomsMin": {
                        "title": "Min rooms",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum number of rooms (pièces)"
                    },
                    "bedroomsMin": {
                        "title": "Min bedrooms",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum number of bedrooms"
                    },
                    "postalCode": {
                        "title": "Postal code",
                        "type": "string",
                        "description": "French postal code prefix (e.g. '75' for Paris, '69' for Lyon, '13' for Marseille). Leave empty for nationwide results."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```