Comment obtenir les données de transactions immobilières en France ? Guide complet 2026

Pourquoi récupérer les données de transactions immobilières ?

Quand on veut estimer un bien, analyser un marché local, alimenter un outil métier ou simplement comprendre l'évolution des prix dans son quartier, il faut accéder aux données de transactions immobilières. En France, ces données existent et sont publiques depuis avril 2019, grâce à l'ouverture des Demandes de Valeurs Foncières (DVF) par la Direction Générale des Finances Publiques (DGFiP). Cela représente plus de 25 millions de mutations enregistrées depuis 2014 couvrant l'ensemble du territoire (à l'exception de l'Alsace, de la Moselle et de Mayotte).

Cet article répond directement à la question : comment obtenir concrètement ces données ? Vous trouverez ci-dessous les quatre méthodes principales, classées de la plus brute à la plus prête à l'emploi, avec des exemples de code en Python et en JavaScript / Node.js que vous pouvez copier-coller pour démarrer dès aujourd'hui.

Quelles sont les sources officielles pour les transactions immobilières ?

Avant de coder, il faut comprendre qu'il existe plusieurs canaux pour les transactions immobilières, et ils ne se valent pas tous selon votre besoin.

1. Le fichier DVF brut sur data.gouv.fr (gratuit)

La source canonique est le jeu de données « Demandes de valeurs foncières » publié par la DGFiP sur data.gouv.fr. C'est un ensemble de fichiers CSV mis à jour deux fois par an (avril et octobre, voir notre calendrier des mises à jour DVF). Chaque fichier annuel pèse entre 250 Mo et 600 Mo non compressé et contient 40 colonnes par transaction.

Avantage : c'est totalement gratuit et exhaustif. Inconvénient : il faut télécharger plusieurs gigaoctets de CSV, les charger en base, gérer le dédoublonnage (chaque mutation peut apparaître plusieurs fois pour différents lots) et écrire vos propres requêtes spatiales. Comptez 1 à 3 jours de travail développeur pour un premier pipeline propre.

2. DVF+ par le Cerema (géolocalisé)

Le Cerema publie une version enrichie nommée DVF+ qui ajoute à chaque transaction des coordonnées GPS (latitude, longitude) reconstituées via le cadastre et la Base Adresse Nationale. Indispensable pour toute analyse spatiale (cartes, rayons, isochrones), DVF+ est aussi gratuit mais reste un téléchargement de fichiers, sans interface programmatique standardisée.

3. Une API DVF clé en main

Une API de transactions immobilières comme Immo API donne accès aux mêmes données mais à travers des endpoints REST/JSON : interroger une commune, calculer un prix médian, récupérer les transactions dans un rayon. Pas de téléchargement, pas de base à maintenir, vous appelez un endpoint et vous récupérez du JSON exploitable en une seconde. Idéal pour intégrer des données fraîches dans une application web ou mobile sans héberger 60 Go de données.

4. Patrim (service officiel pour particuliers)

L'administration fiscale propose Patrim, accessible depuis votre espace personnel impots.gouv.fr. Le service est gratuit mais limité : il vous faut un projet déclaré (succession, donation, ISF/IFI), l'interface n'est pas exportable et il n'y a pas d'API. À utiliser ponctuellement pour un dossier précis, pas pour de l'analyse en série.

Comment télécharger les fichiers DVF (méthode sans API) ?

Si vous avez du temps, peu de budget et besoin d'analyses très fines, la méthode bruteforce reste pertinente. Voici la marche à suivre.

Étape 1 : récupérer les fichiers

Sur la page data.gouv.fr / DVF, téléchargez les fichiers CSV par année (un fichier par année et par département, ou un fichier national selon le millésime). Pour récupérer tout en ligne de commande, un simple script Python suffit.

import urllib.request
years = [2020, 2021, 2022, 2023, 2024, 2025]
base = "https://www.data.gouv.fr/fr/datasets/r/"
# remplacer par les UUID listés sur la fiche du jeu
for y in years:
    urllib.request.urlretrieve(f"{base}<uuid-{y}>", f"dvf_{y}.txt.gz")

Étape 2 : charger les données proprement

Avec pandas, charger un fichier DVF prend 5 à 30 secondes selon la taille. La séparation est en pipe (|), pas en virgule, et les décimales utilisent la virgule française :

import pandas as pd

df = pd.read_csv(
    "dvf_2024.txt",
    sep="|",
    decimal=",",
    low_memory=False,
)
df = df[df["nature_mutation"] == "Vente"]
df = df.dropna(subset=["valeur_fonciere", "surface_reelle_bati"])
df["prix_m2"] = df["valeur_fonciere"] / df["surface_reelle_bati"]

Étape 3 : filtrer une commune et calculer un prix médian

paris11 = df[df["code_commune"] == "75111"]
appartements = paris11[paris11["type_local"] == "Appartement"]
print(appartements["prix_m2"].median())  # ~10 300 €/m²

Cette méthode fonctionne bien pour des analyses ponctuelles. Mais dès que vous voulez intégrer ces données dans une application en production, l'API est plus simple.

Comment obtenir les transactions via une API en Python ?

L'usage typique d'une API DVF est de récupérer les transactions comparables autour d'un bien à estimer. Voici un exemple complet en Python avec requests :

import requests

API_BASE = "https://api.immoapi.app/v1"
HEADERS = {"Authorization": "Bearer VOTRE_CLE_API"}

# 1) Statistiques agrégées sur une commune
r = requests.get(
    f"{API_BASE}/stats",
    params={
        "code_commune": "75111",
        "type_local": "Appartement",
        "periode": "12m",
    },
    headers=HEADERS,
)
stats = r.json()
print(f"Prix médian : {stats['median']} €/m²")
print(f"Volume 12 mois : {stats['count']} ventes")

# 2) Transactions individuelles dans un rayon
r = requests.get(
    f"{API_BASE}/mutations/nearby",
    params={
        "lat": 48.857,
        "lon": 2.378,
        "radius_m": 500,
        "type_local": "Appartement",
        "surface_min": 50,
        "surface_max": 70,
        "limit": 50,
    },
    headers=HEADERS,
)
for tx in r.json()["mutations"]:
    print(tx["date"], tx["valeur_fonciere"], tx["surface"], "m²")

En cinq lignes utiles, vous avez un prix médian de quartier et la liste des biens comparables. Pas de téléchargement, pas de schéma à maintenir.

Comment obtenir les transactions via une API en JavaScript / Node.js ?

Côté backend Node.js (ou même côté navigateur si vous avez exposé une API publique en lecture), la fetch API moderne fait le travail. Exemple ES2024 :

const API_BASE = "https://api.immoapi.app/v1";
const headers = { Authorization: `Bearer ${process.env.IMMOAPI_KEY}` };

async function getStats(codeCommune) {
  const url = new URL(`${API_BASE}/stats`);
  url.searchParams.set("code_commune", codeCommune);
  url.searchParams.set("type_local", "Appartement");
  url.searchParams.set("periode", "12m");
  const res = await fetch(url, { headers });
  return res.json();
}

async function getNearby(lat, lon, radius = 500) {
  const url = new URL(`${API_BASE}/mutations/nearby`);
  url.searchParams.set("lat", lat);
  url.searchParams.set("lon", lon);
  url.searchParams.set("radius_m", radius);
  const res = await fetch(url, { headers });
  return res.json();
}

const stats = await getStats("75111");
console.log(`Prix médian ${stats.median} €/m² sur ${stats.count} ventes`);

Dans un projet Next.js ou React, on encapsule ces appels dans une route handler (App Router) ou un getServerSideProps pour éviter d'exposer la clé API côté client. Les développeurs habitués à structurer un projet avec Claude Code peuvent générer ces wrappers TypeScript en quelques minutes.

Quels endpoints utiliser selon votre cas d'usage ?

Pour vous orienter, voici la correspondance entre un besoin métier et l'endpoint à appeler.

Estimer un bien précis : /mutations/nearby avec l'adresse géocodée et une fenêtre de surface ± 30 %.
Calculer un prix moyen de quartier : /stats avec code_commune + type_local.
Suivre un marché en continu : webhooks de veille immobilière qui notifient à chaque nouvelle vente publiée.
Détecter des opportunités : script marchand de biens DVF qui scanne des décotes par commune.
Cartographier un département : combinaison /stats par commune + couches GeoJSON IGN.

Quels pièges éviter quand on manipule les données DVF ?

Quelle que soit la méthode choisie, certains pièges sont récurrents.

Le dédoublonnage

Une même mutation peut apparaître sur plusieurs lignes si elle concerne plusieurs lots de copropriété. Si vous additionnez naïvement les valeurs foncières, vous obtenez un total faux. La règle est de grouper par identifiant_mutation ou, à défaut, par la combinaison (date + adresse + prix). L'API renvoie déjà des objets dédoublonnés, c'est l'un de ses gros avantages opérationnels.

La surface réelle bâtie ≠ surface Carrez ≠ surface habitable

Le DVF renvoie la surface réelle bâtie (souvent Carrez pour les copropriétés, mais pas garanti). Pour les maisons, cela peut différer significativement de la surface habitable (loi Boutin). Annoncez toujours le prix au m² avec sa définition.

Les valeurs aberrantes

Une vente à 1 € (cession familiale), une vente d'un parking codé comme appartement, ou un château vendu pour 10 millions dans un village : ces outliers détruisent une moyenne. Filtrez sur nature_mutation = Vente, écartez les valeurs < 10 000 € et > 99e percentile, ou préférez la médiane à la moyenne.

Le rythme de mise à jour

Les données sont publiées deux fois par an avec un délai de 3 à 9 mois après la transaction. Une vente signée en mars 2026 n'apparaîtra pas avant la publication d'octobre 2026. Pour un marché en mouvement rapide, croisez avec d'autres signaux (annonces, indices Notaires) ou utilisez une API qui agrège plusieurs sources.

Combien coûte l'accès aux données de transactions immobilières ?

Les données brutes sont 100 % gratuites sur data.gouv.fr et chez le Cerema. Vos seuls coûts sont l'hébergement (60 Go en base si vous chargez tout), le temps développeur d'ingestion et la maintenance lors des mises à jour semestrielles.

Une API tierce facture l'accès aux requêtes, avec typiquement une formule freemium : quelques centaines à quelques milliers d'appels gratuits par mois, puis un abonnement de quelques dizaines à quelques centaines d'euros pour des usages professionnels. Pour une proptech qui sert 100 utilisateurs par jour, l'API revient nettement moins cher qu'un développeur back-end maintenant un pipeline DVF interne.

Foire aux questions

Les données DVF sont-elles vraiment gratuites ?

Oui, totalement. Le jeu de données est publié sous Licence Ouverte (Etalab 2.0), ce qui autorise la consultation, la redistribution, la réutilisation commerciale et la création de produits dérivés sans frais et sans demande d'autorisation. Une API tierce facture le service rendu (infrastructure, performance, dédoublonnage), pas les données elles-mêmes.

Le DVF couvre-t-il toute la France ?

Presque. Le DVF couvre la France métropolitaine et les DOM, à l'exception de l'Alsace (Bas-Rhin, Haut-Rhin), de la Moselle et de Mayotte. Ces territoires relèvent d'un régime foncier différent (livre foncier hérité du droit allemand pour l'Alsace-Moselle). Pour ces zones, les notaires restent la source principale.

Quel format de fichier propose le DVF ?

Le format officiel est un CSV avec séparateur pipe (|) et décimales à la virgule, encodage UTF-8. Une variante existe au format GeoJSON pour DVF+ géolocalisé. Les APIs renvoient quant à elles du JSON classique, plus simple à manipuler dans une application moderne.

Puis-je obtenir les ventes en temps réel ?

Non, pas vraiment. Le DVF officiel est mis à jour tous les six mois. La donnée la plus récente disponible dans une publication d'octobre concerne typiquement les ventes signées jusqu'au mois de mars précédent. Pour du « quasi temps réel », il faut compléter par d'autres sources (annonces, déclarations de mutation auprès des syndics, indices flash Notaires).

Quelle est la différence entre DVF et BIEN/PERVAL ?

BIEN et PERVAL sont les bases historiques des notaires (PERVAL en province, BIEN en Île-de-France). Elles sont alimentées avant l'enregistrement fiscal donc plus fraîches, mais payantes et fermées. Le DVF, lui, est alimenté en aval par l'administration fiscale, gratuit, mais publié avec décalage. Notre article PERVAL vs DVF détaille les différences pour un développeur.

Comment authentifier mes appels à une API DVF ?

Les APIs DVF modernes utilisent une clé API transmise dans l'en-tête Authorization: Bearer <clé>. Côté backend, stockez la clé dans une variable d'environnement (.env) ; côté frontend, exposez plutôt un proxy serveur pour ne jamais laisser fuiter la clé dans le navigateur. Consultez notre guide développeur Immo API pour un exemple complet.

Faut-il être développeur pour utiliser le DVF ?

Non. Pour une consultation ponctuelle, l'outil Explore DVF d'Etalab propose une carte interactive accessible à tous. Pour une utilisation régulière sans coder, des plugins Tableau, Power BI ou des dashboards no-code (Airtable, Notion) peuvent consommer une API DVF directement. Notre guide DVF débutant détaille ces options non techniques.