# French Rental Yield – Rent vs Price by Commune (DVF + Rent Map) (`yck69/french-rental-yield`) Actor

Gross and net rental yield of every French commune and Paris, Lyon and Marseille arrondissement: official asking rents (ANIL rent map 2025) against real sale prices (DVF), price trend, department rankings and a yield simulation for your own property.

- **URL**: https://apify.com/yck69/french-rental-yield.md
- **Developed by:** [yck](https://apify.com/yck69) (community)
- **Categories:** Real estate
- **Features:** Limited permissions
- **Stats:** 21 total users, 0 monthly users, 50.0% runs succeeded, 0 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $5.00 / 1,000 yield rows

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

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

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

## How to integrate an Actor?

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

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

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

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

# README

## French Rental Yield – Rent vs Price by Commune (DVF + Rent Map)

https://www.youtube.com/watch?v=09IAfQOwQ9w

**What does French Rental Yield do?** It tells you **where buy-to-let pays in France**. For any commune — and every arrondissement of Paris, Lyon and Marseille — it compares the **official asking rent per m²** (ANIL / Ministry of Housing rent map, 2025 edition) with the **real median sale price per m²** from notarial deeds (DVF, up to June 2026), and returns the gross yield, an estimated net yield, the price-to-rent ratio and the price trend.

- **Gross and net rental yield** per commune and property type: apartments, 1–2 room apartments, 3+ room apartments, houses.
- **Department rankings**: give `42` or `59` and get every commune with enough sales, best yield first.
- **Simulate your own property**: price, surface and commune → estimated rent, yield and how your price per m² compares with the market.
- **Honest numbers**: medians from thousands of real sales, rent prediction intervals, sale counts, a reliability flag, and no yield when data is too thin.
- **Price trend**: last 12 months vs the 12 months before.

### What data can you get?

<table>
<tr><td>📈 Gross yield</td><td>💶 Net yield estimate</td><td>⏱️ Price-to-rent years</td></tr>
<tr><td>🏷️ Median price €/m²</td><td>📊 Price quartiles</td><td>🔁 12-month trend</td></tr>
<tr><td>🏠 Rent €/m²</td><td>↔️ Rent interval</td><td>🧮 Sales count</td></tr>
<tr><td>✅ Reliability</td><td>🗺️ Arrondissements</td><td>🧾 Property simulation</td></tr>
</table>

### How to use it

1. Click **Try for free** and open the Actor.
2. Enter **communes** or a **department** to rank.
3. Choose property types and your costs assumption.
4. Click **Start** and sort by gross yield.
5. Export, or add your own property for a simulation.

### Input examples

**Compare a few cities (Lyon is split into its 9 arrondissements)**

```json
{
  "communes": ["Lyon", "Saint-Étienne", "Villeurbanne"]
}
```

**Best-yield apartment towns in the Loire department**

```json
{
  "departments": ["42"],
  "propertyTypes": ["apartment"],
  "minSales": 20
}
```

**Is this €250,000, 55 m² flat in Lyon 3e a good investment?**

```json
{
  "communes": ["69003"],
  "property": { "price": 250000, "surfaceM2": 55, "commune": "69003", "type": "apartment" }
}
```

Postal codes and names both work; INSEE codes are written `insee:69123`.

### Output

Real results from the first example (November 2026, apartments, sales July 2024 – June 2026):

| Commune | Gross yield | Net yield (est.) | Price €/m² | Rent €/m²/month | Sales |
|---|---|---|---|---|---|
| Saint-Étienne | 9.88% | 7.41% | 1,200 | 9.88 | 4,859 |
| Villeurbanne | 5.29% | 3.97% | 3,544 | 15.63 | 3,753 |
| Lyon 9e | 5.20% | 3.90% | 3,701 | 16.02 | 1,206 |
| Lyon 3e | 4.41% | 3.31% | 4,465 | 16.40 | 2,603 |
| Lyon 1er | 4.21% | 3.16% | 4,861 | 17.06 | 797 |

```json
{
  "recordType": "commune",
  "communeCode": "42218",
  "commune": "Saint-Étienne",
  "department": "42",
  "propertyType": "apartment",
  "grossYieldPercent": 9.88,
  "netYieldEstimatePercent": 7.41,
  "priceToRentYears": 10.1,
  "medianPricePerM2": 1200,
  "salesCount": 4859,
  "priceChange12mPercent": -0.5,
  "rentPerM2": 9.88,
  "rentFor50m2": 494,
  "priceFor50m2": 60000,
  "reliability": "high",
  "rentSource": "ANIL / DHUP rent map 2025 (asking rents incl. charges)"
}
```

The property simulation for the third example returns: estimated rent **€902/month**, gross yield **4.33%**, and a price per m² **1.8% above** the Lyon 3e median.

| Field | Meaning |
|---|---|
| `grossYieldPercent` | Annual rent ÷ purchase price: `rentPerM2 × 12 ÷ medianPricePerM2`. |
| `netYieldEstimatePercent` | Gross yield minus `costsPercent` (default 25%: property tax, non-recoverable charges, insurance, management, vacancy). Before income tax and loan costs. |
| `priceToRentYears` | Years of rent needed to pay the price. |
| `medianPricePerM2` / `pricePerM2Q1` / `pricePerM2Q3` | Median and quartiles of DVF sales of single dwellings of that type over the period. |
| `rentPerM2` / `rentPerM2Low` / `rentPerM2High` | Asking rent incl. charges and its 95% prediction interval from the rent map. |
| `rentEstimateLevel` | `commune` (estimated from the commune's own listings), or `maille` / `epci` (from neighbouring communes: less precise). |
| `reliability` | `high`, `medium` or `low`, from the number of sales and how the rent was estimated. |

### How much does it cost?

**$5 per 1,000 rows** ($0.005 per commune and property type, or per property simulation). Ranking a whole department typically costs between $0.20 and $2.

### More Actors from this developer

### FAQ

##### Where do the numbers come from?

Rents: the official *carte des loyers* published by the Ministry of Housing with ANIL (asking rents from online listings, model-based per commune, 2025 edition). Prices: DVF, every property sale recorded by the French tax administration, refreshed by this Actor's data pipeline after each semi-annual release. Alsace-Moselle (57, 67, 68) and Mayotte have no DVF data.

##### Why can the yield of small towns look very high?

Cheap towns often have high gross yields, but also more vacancy and less demand. Check `salesCount`, `reliability`, the price trend and the rent interval, and raise `costsPercent` for riskier markets.

##### Are rents including charges?

Yes: the rent map gives asking rents including charges for a typical unit (about 52 m² for apartments, 92 m² for houses). Real signed rents can be a few percent lower.

##### Can I get the underlying sales?

Use French Property Prices (DVF) from the same developer to list every sale, with addresses and surfaces.

##### Can I use it through the API, Make, Zapier or Google Sheets?

Yes. Every run can be started and read through the [Apify API](https://docs.apify.com/api/v2) (JavaScript and Python clients, CLI, MCP), and Apify integrations connect it to Make, Zapier, n8n, Google Sheets, Slack, webhooks and more.

##### Is it legal to use this data?

The Actor only reads public or official open data and doesn't log in anywhere. Check the source's licence and your local rules (for example GDPR when data concerns people) for your use case; if in doubt, ask a lawyer.

##### Something isn't working, or you need another field?

Open an issue on the **Issues** tab: feedback is read and answered.

# Actor input Schema

## `communes` (type: `array`):

Commune names (<code>Saint-Étienne</code>), postal codes (<code>69003</code>) or INSEE codes written <code>insee:69123</code>. Paris, Lyon and Marseille are split into arrondissements.

## `departments` (type: `array`):

Department codes (<code>42</code>, <code>59</code>, <code>2A</code>…): every commune with enough sales is returned, best yield first.

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

Rents and prices are compared like for like.

## `months` (type: `integer`):

Median price over the last N months of DVF sales.

## `minSales` (type: `integer`):

Communes with fewer sales of the type get no yield (too uncertain) and are left out of rankings.

## `costsPercent` (type: `integer`):

Share of the rent lost to property tax, non-recoverable charges, insurance, management and vacancy. 20–30% is typical.

## `property` (type: `object`):

<code>{"price": 250000, "surfaceM2": 55, "commune": "69003", "type": "apartment", "monthlyRent": 950}</code>. <code>monthlyRent</code> is optional: without it, the rent is estimated from the commune's rent per m².

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

Best gross yield first.

## Actor input object example

```json
{
  "communes": [
    "Lyon",
    "Saint-Étienne",
    "Villeurbanne"
  ],
  "propertyTypes": [
    "apartment",
    "house"
  ],
  "months": 24,
  "minSales": 10,
  "costsPercent": 25,
  "maxResults": 500
}
```

# Actor output Schema

## `yields` (type: `string`):

Gross and net yield, price and rent per commune.

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

Every field of every row.

# 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 = {
    "communes": [
        "Lyon",
        "Saint-Étienne",
        "Villeurbanne"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("yck69/french-rental-yield").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 = { "communes": [
        "Lyon",
        "Saint-Étienne",
        "Villeurbanne",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("yck69/french-rental-yield").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "communes": [
    "Lyon",
    "Saint-Étienne",
    "Villeurbanne"
  ]
}' |
apify call yck69/french-rental-yield --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,yck69/french-rental-yield"
        }
    }
}
```

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

## OpenAPI specification

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