# France Property Valuation 🇫🇷 Estimation DVF & Comparables (`tagadanar/french-property-valuation`) Actor

Value any French address from official sold prices (DVF): median price per m², an estimate for your surface, the yearly trend and the comparable sales behind it. One row per real sale, Carrez surface first. Estimation immobilière, platform usage included.

- **URL**: https://apify.com/tagadanar/french-property-valuation.md
- **Developed by:** [Tagada Data](https://apify.com/tagadanar) (community)
- **Categories:** Real estate, AI, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.40 / 1,000 comparable sales

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/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

## France Property Valuation (DVF): price per m², estimate and comparable sales for any address

**Type a French address, get what the flats or houses around it actually sold for.** This actor values any address in France from the official register of notarised sales (**DVF**, *Demandes de valeurs foncières*, DGFiP / Etalab): the median price per m² and its quartiles, an estimated price for your surface, the year-by-year trend, and the list of comparable sales it was computed from, closest and most similar first.

Built for **estate agents preparing an avis de valeur, property investors, buyers and sellers checking a price, notaries, lenders, proptech teams and AI agents** (API and MCP).

### Why the numbers are cleaner than raw DVF

Raw DVF is one line per *component* of a sale, and every line repeats the full sale price. A flat sold with its cellar is two lines; two flats sold in one deed are two lines at the price of both; a flat sold with a shop carries the shop's price too. Divide that price by one line's surface, as most DVF tools do, and the price per m² is wrong for a large share of the market (measured on Clichy 2021 to 2025: 15,307 raw lines, 5,590 sales, **3,529** usable single-flat sales).

This actor puts the sale back together before it computes anything:

- **One row per real sale**, grouped by mutation.
- **Only sales of exactly one dwelling** of your type. A flat with its cellar or parking stays in (the outbuilding is counted). Block sales of several flats, and flats sold with a shop or a house, are left out, because their price cannot be split.
- **Standard sales only.** VEFA new-builds, exchanges and court auctions are a different market.
- **Loi Carrez surface first**, when the deed carries one that agrees with the built surface, because that is the surface the flat was sold on.
- **Outliers cut against the local market**, not a national band: a sale far outside the quartiles of the sales around *your* address is dropped (2,000 €/m² is a bargain in Paris and the going rate in many towns).

### What you get

One **valuation** row per address:

| Field | Example | Meaning |
|---|---|---|
| `matchedAddress` | 20 Place Bellecour 69002 Lyon | What the national address base (BAN) matched |
| `comparablesCount` | 50 | Clean sales used |
| `pricePerM2Median` / `Q1` / `Q3` | 5,754 / 4,904 / 7,071 | Sold price per m², median and quartiles |
| `pricePerM2P10` / `P90` | 4,393 / 8,006 | The cheap and expensive ends of the street |
| `estimatedPriceLow` / `estimatedPrice` / `estimatedPriceHigh` | 221,000 / 259,000 / 318,000 | Quartiles × your surface (when you give one) |
| `byYear` | 2023: 6,064, 2024: 5,854, 2025: 4,959 | Median per year, with the number of sales |
| `trendPct` | -18.2 | First to last year with at least 5 sales |
| `confidence` | high | From the number of sales and how far the search had to widen |
| `radiusUsed` | 500 | Radius actually used (see below) |

Then the **comparable sales** behind it, best match first (closest, most recent, closest in size): `date`, `price`, `pricePerM2`, `surface` and whether it is the Carrez or built surface, `rooms`, `outbuildings`, `landSurface` for houses, `address`, `commune`, `distanceMeters`, `parcelId` and the DVF `mutationId` so any line can be checked against the register.

Every row carries your address as typed (`query`), so a batch of 100 addresses stays easy to join back.

### Input

```json
{
    "addresses": ["20 place Bellecour, 69002 Lyon", "12 rue de Rivoli, 75004 Paris"],
    "propertyType": "Appartement",
    "surface": 45,
    "rooms": 2,
    "radiusMeters": 500,
    "years": ["2023", "2024", "2025"],
    "maxComparables": 30
}
```

| Input | Default | What it does |
|---|---|---|
| `addresses` | (required) | French addresses, one per line, up to 100. `lat, lon` works too. |
| `propertyType` | `Appartement` | `Appartement` or `Maison`. Only that type is compared. |
| `surface` | none | Your living area. Comparables are kept within ±25 % of it, and you get an estimated price. |
| `rooms` | none | Keep only sales with exactly this number of main rooms (pièces). |
| `radiusMeters` | `500` | Search radius. Below 10 matching sales it doubles on its own, up to 2,000 m, and `radiusUsed` tells you. |
| `years` | 2023 to 2025 | Which years of sales to use (2021 to 2025 are published). |
| `maxComparables` | `30` | Comparable sales returned per address, 0 for the valuation alone. |

Paris, Lyon and Marseille are handled per arrondissement, and a search near a town boundary reads every commune the radius touches (an address in Lyon 2e near the Rhône also gets the 3e and 7e sales across the river).

### Use cases

- **Estate agents**: the comparables table for an *avis de valeur* or a price-reduction conversation, with the address of every sale so the seller can check it.
- **Sellers and buyers**: is the asking price in line with what the building next door sold for?
- **Investors**: screen a list of addresses for price per m² and trend before visiting.
- **Lenders, notaries, auditors**: a documented, reproducible market value from public data.
- **Proptech and AI agents**: a valuation API over MCP, *"what is a 45 m² flat worth at 20 rue X, Lyon?"*

### Pricing

Pay per result, platform usage included, no subscription:

| Event | Price | When |
|---|---|---|
| Property valued | **$0.03** | Per address valued (at least 5 matching sales) |
| Comparable sale | **$0.002** ($2 per 1,000) | Per comparable sale returned |
| Actor start | $0.001 | Once per run |

A valuation with its 30 best comparables costs **$0.09**, or **$0.063** on the Gold plan (Bronze, Silver and Gold discounts apply). The valuation alone (`maxComparables: 0`) is $0.03.

**Misses are free:** an address the address base cannot find, one in Alsace-Moselle (not in DVF), or one with fewer than 5 matching sales comes back as a row with an explanation and is not charged.

### FAQ

**Where does the data come from?** The official geo-DVF files published by Etalab from DGFiP records (files.data.gouv.fr), geocoded with the national address base (BAN, IGN Géoplateforme). Nothing is estimated from asking prices.

**How recent is it?** DVF covers 2021 to 2025 today. It is published twice a year, so 2026 sales are not out yet. `latestSaleInData` shows the most recent sale date the run saw.

**Is this an estimation immobilière like MeilleursAgents?** It is the part of one that can be checked: real sold prices around the address, cleaned and summarised. It does not see the condition of the property, the floor, the view or the renovation, so treat the median as the market's middle and place your property within the quartiles.

**Why do I get fewer comparables than DVF lines?** Because block sales, mixed sales and non-standard sales are removed, and one sale is one row. That is the point.

**Does it work for houses (maisons)?** Yes. Set `propertyType` to `Maison`; the price per m² is on the living area, and `landSurface` gives the land sold with it.

**Alsace, Moselle, Mayotte?** DVF does not cover them (land registry kept under local law), so those addresses return `not-covered`, free.

**Can I use GPS coordinates?** Yes, type `48.8698, 2.3316` as the address.

### Other French real-estate actors

- [**DVF Sold House Prices by Commune**](https://apify.com/tagadanar/french-real-estate-dvf): every raw DVF transaction for a commune or postal code, when you want the whole register rather than a valuation.
- [**Real Estate Deal Score**](https://apify.com/tagadanar/french-real-estate-deal-score): PAP asking prices scored against DVF sold prices.
- [**SeLoger Scraper**](https://apify.com/tagadanar/french-real-estate-seloger) and [**PAP Real Estate Listings**](https://apify.com/tagadanar/french-real-estate-pap): current asking prices, to compare with what actually sold.

***

### Something missing?

Open an issue on this Actor and say what you need. I read every request, and small additions usually ship within days.

*Keywords: estimation immobilière, estimation appartement, prix au m², prix m2 par adresse, DVF, valeurs foncières, ventes comparables, termes de comparaison, avis de valeur, prix de vente immobilier, French property valuation, France house prices, sold prices France, comparable sales, property comps, AVM France, price per square meter France, loi Carrez.*

# Changelog

This Actor's version history is a separate document: https://apify.com/tagadanar/french-property-valuation/changelog.md

# Actor input Schema

## `addresses` (type: `array`):

One French address per line, the way you would type it into a map: <code>12 rue de la Paix, 75002 Paris</code>. GPS coordinates also work (<code>48.8698, 2.3316</code>). Up to 100 per run.

## `propertyType` (type: `string`):

Only sales of this type are used as comparables.

## `surface` (type: `number`):

Living area of the property you are valuing. Comparables are then limited to ±25 % of it, and you get an estimated price (low, median, high), not just a price per m². Leave empty for the neighbourhood's price per m² across all sizes.

## `rooms` (type: `integer`):

Main rooms as French deeds count them (a 2-pièces is 2). When set, only sales with exactly this count are used.

## `radiusMeters` (type: `integer`):

Comparable sales are searched within this distance of the address. If fewer than 10 sales match, the radius doubles automatically (up to 2,000 m) and the one used is reported.

## `years` (type: `array`):

Which years of recorded sales to use. Leave empty for the three most recent (2023, 2024, 2025).

## `maxComparables` (type: `integer`):

How many of the best-matching sales to return with each valuation, closest and most similar first. Set 0 to get the valuation alone.

## Actor input object example

```json
{
  "addresses": [
    "1 place de la Bourse, 33000 Bordeaux"
  ],
  "propertyType": "Appartement",
  "radiusMeters": 500,
  "maxComparables": 30
}
```

# Actor output Schema

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

One valuation row per address, followed by its comparable sales.

# 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 = {
    "addresses": [
        "1 place de la Bourse, 33000 Bordeaux"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("tagadanar/french-property-valuation").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 = { "addresses": ["1 place de la Bourse, 33000 Bordeaux"] }

# Run the Actor and wait for it to finish
run = client.actor("tagadanar/french-property-valuation").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 '{
  "addresses": [
    "1 place de la Bourse, 33000 Bordeaux"
  ]
}' |
apify call tagadanar/french-property-valuation --silent --output-dataset

```

## MCP server setup

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

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/IZuXaV2Id7tOENPck/builds/6dJf8eK0e1pGwwVrj/openapi.json