Rechercher des transactions immobilières (DVF)

L'API Infoparcelle donne accès à l'historique complet des Demandes de Valeurs Foncières (DVF), la base de données officielle des transactions immobilières en France. Ce guide vous explique comment rechercher et analyser les ventes immobilières.

Vue d'ensemble

L'endpoint /api/v1/dvfs permet de rechercher des transactions immobilières par différents critères : localisation, type de bien, prix, surfaces, dates de vente, etc.

Fonctionnalités principales

✅ Accès aux ventes depuis 2014
✅ Filtrage par type de bien (maisons, appartements, terrains, etc.)
✅ Filtrage par prix et surfaces
✅ Filtrage par dates de transaction
✅ Données géographiques (coordonnées GPS, codes postaux, communes)
✅ Format JSON ou GeoJSON
✅ Pagination par curseur

Données DVF disponibles

Les DVF (Demandes de Valeurs Foncières) contiennent les informations suivantes :

📅 Date de mutation : Date de la transaction
💰 Valeur foncière : Prix de vente
🏠 Type de bien : Maison, appartement, terrain, etc.
📏 Surfaces : Terrain, habitable, bâtie
🗺️ Localisation : Coordonnées GPS, commune, parcelles cadastrales
📊 Compteurs : Nombre de lots, locaux, parcelles

Recherche basique

Par code postal

cURL
JavaScript
PHP
Python

curl -X GET \
  "https://app.infoparcelle.fr/api/v1/dvfs?code_postal=75008&limite=10&champs=id_mutation,date_mutation,nature_mutation,bati_type,surface_batie,valeur_fonciere,municipalite" \
  -H "Authorization: Bearer VOTRE_CLE_API"

const apiKey = process.env.INFOPARCELLE_API_KEY;

const response = await fetch(
  'https://app.infoparcelle.fr/api/v1/dvfs?' +
  new URLSearchParams({
    code_postal: '75008',
    limite: '10',
  }),
  {
    headers: {
      'Authorization': `Bearer ${apiKey}`,
    },
  }
);

const transactions = await response.json();
console.log(transactions);

<?php
$apiKey = getenv('INFOPARCELLE_API_KEY');

$url = 'https://app.infoparcelle.fr/api/v1/dvfs?' . http_build_query([
    'code_postal' => '75008',
    'limite' => '10'
]);

$options = [
    'http' => [
        'header' => "Authorization: Bearer $apiKey\r\n",
        'method' => 'GET'
    ]
];

$context = stream_context_create($options);
$response = file_get_contents($url, false, $context);
$data = json_decode($response, true);

print_r($data);
?>

import os
import requests

api_key = os.getenv('INFOPARCELLE_API_KEY')

response = requests.get(
    'https://app.infoparcelle.fr/api/v1/dvfs',
    params={
        'code_postal': '75008',
        'limite': 10
    },
    headers={'Authorization': f'Bearer {api_key}'}
)

transactions = response.json()
print(transactions)

Par commune

cURL
JavaScript
PHP
Python

# Transactions à Lyon (code INSEE 69123)
curl "https://app.infoparcelle.fr/api/v1/dvfs?code_municipalite=69123&limite=20" \
  -H "Authorization: Bearer VOTRE_CLE_API"

const apiKey = process.env.INFOPARCELLE_API_KEY;

const response = await fetch(
  'https://app.infoparcelle.fr/api/v1/dvfs?' +
  new URLSearchParams({
    code_municipalite: '69123',
    limite: '20',
  }),
  {
    headers: {
      'Authorization': `Bearer ${apiKey}`,
    },
  }
);

const transactions = await response.json();
console.log(transactions);

<?php
$apiKey = getenv('INFOPARCELLE_API_KEY');

$url = 'https://app.infoparcelle.fr/api/v1/dvfs?' . http_build_query([
    'code_municipalite' => '69123',
    'limite' => '20'
]);

$options = [
    'http' => [
        'header' => "Authorization: Bearer $apiKey\r\n",
        'method' => 'GET'
    ]
];

$context = stream_context_create($options);
$response = file_get_contents($url, false, $context);
$data = json_decode($response, true);

print_r($data);
?>

import os
import requests

api_key = os.getenv('INFOPARCELLE_API_KEY')

response = requests.get(
    'https://app.infoparcelle.fr/api/v1/dvfs',
    params={
        'code_municipalite': '69123',
        'limite': 20
    },
    headers={'Authorization': f'Bearer {api_key}'}
)

transactions = response.json()
print(transactions)

Filtrer par type de bien

Maisons

cURL
JavaScript
PHP
Python

# Ventes de maisons à Bordeaux
curl "https://app.infoparcelle.fr/api/v1/dvfs?code_postal=33000&code_type_bien=111&limite=20" \
  -H "Authorization: Bearer VOTRE_CLE_API"

const apiKey = process.env.INFOPARCELLE_API_KEY;

// Ventes de maisons à Bordeaux
const response = await fetch(
  'https://app.infoparcelle.fr/api/v1/dvfs?' +
  new URLSearchParams({
    code_postal: '33000',
    code_type_bien: '111',  // UNE MAISON
    limite: '20',
  }),
  {
    headers: { 'Authorization': `Bearer ${apiKey}` }
  }
);

const ventesMailsons = await response.json();

<?php
$apiKey = getenv('INFOPARCELLE_API_KEY');

// Ventes de maisons à Bordeaux
$url = 'https://app.infoparcelle.fr/api/v1/dvfs?' . http_build_query([
    'code_postal' => '33000',
    'code_type_bien' => '111',  // UNE MAISON
    'limite' => '20'
]);

$options = [
    'http' => [
        'header' => "Authorization: Bearer $apiKey\r\n",
        'method' => 'GET'
    ]
];

$context = stream_context_create($options);
$response = file_get_contents($url, false, $context);
$ventesMailsons = json_decode($response, true);
?>

import os
import requests

api_key = os.getenv('INFOPARCELLE_API_KEY')

# Ventes de maisons à Bordeaux
response = requests.get(
    'https://app.infoparcelle.fr/api/v1/dvfs',
    params={
        'code_postal': '33000',
        'code_type_bien': '111',  # UNE MAISON
        'limite': 20
    },
    headers={'Authorization': f'Bearer {api_key}'}
)

ventes_maisons = response.json()

Codes des maisons :

110 - MAISON - INDETERMINEE
111 - UNE MAISON
112 - DES MAISONS

Appartements

cURL
JavaScript
PHP
Python

# Ventes d'appartements à Nice
curl "https://app.infoparcelle.fr/api/v1/dvfs?code_postal=06000&code_type_bien=121&limite=30" \
  -H "Authorization: Bearer VOTRE_CLE_API"

const apiKey = process.env.INFOPARCELLE_API_KEY;

// Ventes d'appartements à Nice
const response = await fetch(
  'https://app.infoparcelle.fr/api/v1/dvfs?' +
  new URLSearchParams({
    code_postal: '06000',
    code_type_bien: '121',  // UN APPARTEMENT
    limite: '30',
  }),
  {
    headers: { 'Authorization': `Bearer ${apiKey}` }
  }
);

const ventesAppartements = await response.json();

<?php
$apiKey = getenv('INFOPARCELLE_API_KEY');

// Ventes d'appartements à Nice
$url = 'https://app.infoparcelle.fr/api/v1/dvfs?' . http_build_query([
    'code_postal' => '06000',
    'code_type_bien' => '121',  // UN APPARTEMENT
    'limite' => '30'
]);

$options = [
    'http' => [
        'header' => "Authorization: Bearer $apiKey\r\n",
        'method' => 'GET'
    ]
];

$context = stream_context_create($options);
$response = file_get_contents($url, false, $context);
$ventesAppartements = json_decode($response, true);
?>

import os
import requests

api_key = os.getenv('INFOPARCELLE_API_KEY')

# Ventes d'appartements à Nice
response = requests.get(
    'https://app.infoparcelle.fr/api/v1/dvfs',
    params={
        'code_postal': '06000',
        'code_type_bien': '121',  # UN APPARTEMENT
        'limite': 30
    },
    headers={'Authorization': f'Bearer {api_key}'}
)

ventes_appartements = response.json()

Codes des appartements :

120 - APPARTEMENT INDETERMINE
121 - UN APPARTEMENT
122 - DEUX APPARTEMENTS

Terrains

cURL
JavaScript
PHP
Python

# Ventes de terrains à bâtir (TAB) à Toulouse
curl "https://app.infoparcelle.fr/api/v1/dvfs?code_municipalite=31555&code_type_bien=21&limite=20" \
  -H "Authorization: Bearer VOTRE_CLE_API"

const apiKey = process.env.INFOPARCELLE_API_KEY;

// Ventes de terrains à bâtir (TAB) à Toulouse
const response = await fetch(
  'https://app.infoparcelle.fr/api/v1/dvfs?' +
  new URLSearchParams({
    code_municipalite: '31555',
    code_type_bien: '21',
    limite: '20',
  }),
  {
    headers: { 'Authorization': `Bearer ${apiKey}` }
  }
);

const ventesTerrains = await response.json();

<?php
$apiKey = getenv('INFOPARCELLE_API_KEY');

// Ventes de terrains à bâtir (TAB) à Toulouse
$url = 'https://app.infoparcelle.fr/api/v1/dvfs?' . http_build_query([
    'code_municipalite' => '31555',
    'code_type_bien' => '21',
    'limite' => '20'
]);

$options = [
    'http' => [
        'header' => "Authorization: Bearer $apiKey\r\n",
        'method' => 'GET'
    ]
];

$context = stream_context_create($options);
$response = file_get_contents($url, false, $context);
$ventesTerrains = json_decode($response, true);
?>

import os
import requests

api_key = os.getenv('INFOPARCELLE_API_KEY')

# Ventes de terrains à bâtir (TAB) à Toulouse
response = requests.get(
    'https://app.infoparcelle.fr/api/v1/dvfs',
    params={
        'code_municipalite': '31555',
        'code_type_bien': '21',
        'limite': 20
    },
    headers={'Authorization': f'Bearer {api_key}'}
)

ventes_terrains = response.json()

Codes des terrains :

20 - TERRAIN NON BATIS INDETERMINE
21 - TERRAIN DE TYPE TAB (Terrain à bâtir)
221 - TERRAIN D'AGREMENT
232 - TERRAIN FORESTIER
2311 - TERRAIN VITICOLE
2313 - TERRAIN DE TYPE TERRE ET PRE

Locaux d'activité

cURL
JavaScript
PHP
Python

# Ventes de locaux d'activité à Paris
curl "https://app.infoparcelle.fr/api/v1/dvfs?code_municipalite=75056&code_type_bien=14&limite=15" \
  -H "Authorization: Bearer VOTRE_CLE_API"

const apiKey = process.env.INFOPARCELLE_API_KEY;

// Ventes de locaux d'activité à Paris
const response = await fetch(
  'https://app.infoparcelle.fr/api/v1/dvfs?' +
  new URLSearchParams({
    code_municipalite: '75056',
    code_type_bien: '14',  // ACTIVITE
    limite: '15',
  }),
  {
    headers: { 'Authorization': `Bearer ${apiKey}` }
  }
);

const locauxActivite = await response.json();

<?php
$apiKey = getenv('INFOPARCELLE_API_KEY');

// Ventes de locaux d'activité à Paris
$url = 'https://app.infoparcelle.fr/api/v1/dvfs?' . http_build_query([
    'code_municipalite' => '75056',
    'code_type_bien' => '14',  // ACTIVITE
    'limite' => '15'
]);

$options = [
    'http' => [
        'header' => "Authorization: Bearer $apiKey\r\n",
        'method' => 'GET'
    ]
];

$context = stream_context_create($options);
$response = file_get_contents($url, false, $context);
$locauxActivite = json_decode($response, true);
?>

import os
import requests

api_key = os.getenv('INFOPARCELLE_API_KEY')

# Ventes de locaux d'activité à Paris
response = requests.get(
    'https://app.infoparcelle.fr/api/v1/dvfs',
    params={
        'code_municipalite': '75056',
        'code_type_bien': '14',  # ACTIVITE
        'limite': 15
    },
    headers={'Authorization': f'Bearer {api_key}'}
)

locaux_activite = response.json()

Filtrer par prix

Fourchette de prix

cURL
JavaScript
PHP
Python

# Appartements vendus entre 200k et 400k€ à Lyon
curl "https://app.infoparcelle.fr/api/v1/dvfs?code_municipalite=69123&code_type_bien=121&valeur_fonciere_min=200000&valeur_fonciere_max=400000&limite=30" \
  -H "Authorization: Bearer VOTRE_CLE_API"

const apiKey = process.env.INFOPARCELLE_API_KEY;

// Appartements vendus entre 200k et 400k€ à Lyon
const response = await fetch(
  'https://app.infoparcelle.fr/api/v1/dvfs?' +
  new URLSearchParams({
    code_municipalite: '69123',
    code_type_bien: '121',
    valeur_fonciere_min: '200000',
    valeur_fonciere_max: '400000',
    limite: '30',
  }),
  {
    headers: { 'Authorization': `Bearer ${apiKey}` }
  }
);

const transactions = await response.json();

<?php
$apiKey = getenv('INFOPARCELLE_API_KEY');

// Appartements vendus entre 200k et 400k€ à Lyon
$url = 'https://app.infoparcelle.fr/api/v1/dvfs?' . http_build_query([
    'code_municipalite' => '69123',
    'code_type_bien' => '121',
    'valeur_fonciere_min' => '200000',
    'valeur_fonciere_max' => '400000',
    'limite' => '30'
]);

$options = [
    'http' => [
        'header' => "Authorization: Bearer $apiKey\r\n",
        'method' => 'GET'
    ]
];

$context = stream_context_create($options);
$response = file_get_contents($url, false, $context);
$transactions = json_decode($response, true);
?>

import os
import requests

api_key = os.getenv('INFOPARCELLE_API_KEY')

# Appartements vendus entre 200k et 400k€ à Lyon
response = requests.get(
    'https://app.infoparcelle.fr/api/v1/dvfs',
    params={
        'code_municipalite': '69123',
        'code_type_bien': '121',
        'valeur_fonciere_min': '200000',
        'valeur_fonciere_max': '400000',
        'limite': 30
    },
    headers={'Authorization': f'Bearer {api_key}'}
)

transactions = response.json()

Prix au m² estimé

# Calculer le prix au m² moyen
def calculer_prix_m2(transactions):
    prix_m2_list = []

    for t in transactions:
        if t['surface_batie'] and t['surface_batie'] > 0:
            prix_m2 = t['valeur_fonciere'] / t['surface_batie']
            prix_m2_list.append(prix_m2)

    if prix_m2_list:
        return sum(prix_m2_list) / len(prix_m2_list)
    return 0

# Utilisation
response = requests.get(
    'https://app.infoparcelle.fr/api/v1/dvfs',
    params={
        'code_postal': '75008',
        'code_type_bien': '121',
        'limite': 50
    },
    headers={'Authorization': f'Bearer {api_key}'}
)

transactions = response.json()
prix_m2_moyen = calculer_prix_m2(transactions)
print(f"Prix au m² moyen : {prix_m2_moyen:.2f} €")

Filtrer par surface

Surface habitable

cURL
JavaScript
PHP
Python

# Appartements de 60 à 100 m² vendus à Marseille
curl "https://app.infoparcelle.fr/api/v1/dvfs?code_municipalite=13055&bati_type=7&surface_habitable_min=60&surface_habitable_max=100&limite=20" \
  -H "Authorization: Bearer VOTRE_CLE_API"

const apiKey = process.env.INFOPARCELLE_API_KEY;

// Appartements de 60 à 100 m² vendus à Marseille
const response = await fetch(
  'https://app.infoparcelle.fr/api/v1/dvfs?' +
  new URLSearchParams({
    code_municipalite: '13055',
    bati_type: '7',
    surface_habitable_min: '60',
    surface_habitable_max: '100',
    limite: '20',
  }),
  {
    headers: { 'Authorization': `Bearer ${apiKey}` }
  }
);

const transactions = await response.json();

<?php
$apiKey = getenv('INFOPARCELLE_API_KEY');

// Appartements de 60 à 100 m² vendus à Marseille
$url = 'https://app.infoparcelle.fr/api/v1/dvfs?' . http_build_query([
    'code_municipalite' => '13055',
    'bati_type' => '7',
    'surface_habitable_min' => '60',
    'surface_habitable_max' => '100',
    'limite' => '20'
]);

$options = [
    'http' => [
        'header' => "Authorization: Bearer $apiKey\r\n",
        'method' => 'GET'
    ]
];

$context = stream_context_create($options);
$response = file_get_contents($url, false, $context);
$transactions = json_decode($response, true);
?>

import os
import requests

api_key = os.getenv('INFOPARCELLE_API_KEY')

# Appartements de 60 à 100 m² vendus à Marseille
response = requests.get(
    'https://app.infoparcelle.fr/api/v1/dvfs',
    params={
        'code_municipalite': '13055',
        'bati_type': '7',
        'surface_habitable_min': '60',
        'surface_habitable_max': '100',
        'limite': 20
    },
    headers={'Authorization': f'Bearer {api_key}'}
)

transactions = response.json()

Surface de terrain

cURL
JavaScript
PHP
Python

# Maisons avec terrain de 500 à 1500 m² à Nantes
curl "https://app.infoparcelle.fr/api/v1/dvfs?code_postal=44000&bati_type=1&surface_terrain_min=500&surface_terrain_max=1500&limite=20" \
  -H "Authorization: Bearer VOTRE_CLE_API"

const apiKey = process.env.INFOPARCELLE_API_KEY;

// Maisons avec terrain de 500 à 1500 m² à Nantes
const response = await fetch(
  'https://app.infoparcelle.fr/api/v1/dvfs?' +
  new URLSearchParams({
    code_postal: '44000',
    bati_type: '1',  // Maison
    surface_terrain_min: '500',
    surface_terrain_max: '1500',
    limite: '20',
  }),
  {
    headers: { 'Authorization': `Bearer ${apiKey}` }
  }
);

const maisonsAvecJardin = await response.json();

<?php
$apiKey = getenv('INFOPARCELLE_API_KEY');

// Maisons avec terrain de 500 à 1500 m² à Nantes
$url = 'https://app.infoparcelle.fr/api/v1/dvfs?' . http_build_query([
    'code_postal' => '44000',
    'bati_type' => '1',  // Maison
    'surface_terrain_min' => '500',
    'surface_terrain_max' => '1500',
    'limite' => '20'
]);

$options = [
    'http' => [
        'header' => "Authorization: Bearer $apiKey\r\n",
        'method' => 'GET'
    ]
];

$context = stream_context_create($options);
$response = file_get_contents($url, false, $context);
$maisonsAvecJardin = json_decode($response, true);
?>

import os
import requests

api_key = os.getenv('INFOPARCELLE_API_KEY')

# Maisons avec terrain de 500 à 1500 m² à Nantes
response = requests.get(
    'https://app.infoparcelle.fr/api/v1/dvfs',
    params={
        'code_postal': '44000',
        'bati_type': '1',  # Maison
        'surface_terrain_min': '500',
        'surface_terrain_max': '1500',
        'limite': 20
    },
    headers={'Authorization': f'Bearer {api_key}'}
)

maisons_avec_jardin = response.json()

Filtrer par date

Transactions récentes

cURL
JavaScript
PHP
Python

# Ventes depuis janvier 2024 à Strasbourg
curl "https://app.infoparcelle.fr/api/v1/dvfs?code_postal=67000&date_mutation_min=2024-01-01&limite=30" \
  -H "Authorization: Bearer VOTRE_CLE_API"

const apiKey = process.env.INFOPARCELLE_API_KEY;

// Ventes depuis janvier 2024 à Strasbourg
const response = await fetch(
  'https://app.infoparcelle.fr/api/v1/dvfs?' +
  new URLSearchParams({
    code_postal: '67000',
    date_mutation_min: '2024-01-01',
    limite: '30',
  }),
  {
    headers: { 'Authorization': `Bearer ${apiKey}` }
  }
);

const transactionsRecentes = await response.json();

<?php
$apiKey = getenv('INFOPARCELLE_API_KEY');

// Ventes depuis janvier 2024 à Strasbourg
$url = 'https://app.infoparcelle.fr/api/v1/dvfs?' . http_build_query([
    'code_postal' => '67000',
    'date_mutation_min' => '2024-01-01',
    'limite' => '30'
]);

$options = [
    'http' => [
        'header' => "Authorization: Bearer $apiKey\r\n",
        'method' => 'GET'
    ]
];

$context = stream_context_create($options);
$response = file_get_contents($url, false, $context);
$transactionsRecentes = json_decode($response, true);
?>

import os
import requests

api_key = os.getenv('INFOPARCELLE_API_KEY')

# Ventes depuis janvier 2024 à Strasbourg
response = requests.get(
    'https://app.infoparcelle.fr/api/v1/dvfs',
    params={
        'code_postal': '67000',
        'date_mutation_min': '2024-01-01',
        'limite': 30
    },
    headers={'Authorization': f'Bearer {api_key}'}
)

transactions_recentes = response.json()

Période spécifique

cURL
JavaScript
PHP
Python

# Ventes entre 2022 et 2023 à Lille
curl "https://app.infoparcelle.fr/api/v1/dvfs?code_municipalite=59350&date_mutation_min=2022-01-01&date_mutation_max=2023-12-31&limite=50" \
  -H "Authorization: Bearer VOTRE_CLE_API"

const apiKey = process.env.INFOPARCELLE_API_KEY;

// Ventes entre 2022 et 2023 à Lille
const response = await fetch(
  'https://app.infoparcelle.fr/api/v1/dvfs?' +
  new URLSearchParams({
    code_municipalite: '59350',
    date_mutation_min: '2022-01-01',
    date_mutation_max: '2023-12-31',
    limite: '50',
  }),
  {
    headers: { 'Authorization': `Bearer ${apiKey}` }
  }
);

const ventes20222023 = await response.json();

<?php
$apiKey = getenv('INFOPARCELLE_API_KEY');

// Ventes entre 2022 et 2023 à Lille
$url = 'https://app.infoparcelle.fr/api/v1/dvfs?' . http_build_query([
    'code_municipalite' => '59350',
    'date_mutation_min' => '2022-01-01',
    'date_mutation_max' => '2023-12-31',
    'limite' => '50'
]);

$options = [
    'http' => [
        'header' => "Authorization: Bearer $apiKey\r\n",
        'method' => 'GET'
    ]
];

$context = stream_context_create($options);
$response = file_get_contents($url, false, $context);
$ventes20222023 = json_decode($response, true);
?>

import os
import requests

api_key = os.getenv('INFOPARCELLE_API_KEY')

# Ventes entre 2022 et 2023 à Lille
response = requests.get(
    'https://app.infoparcelle.fr/api/v1/dvfs',
    params={
        'code_municipalite': '59350',
        'date_mutation_min': '2022-01-01',
        'date_mutation_max': '2023-12-31',
        'limite': 50
    },
    headers={'Authorization': f'Bearer {api_key}'}
)

ventes_2022_2023 = response.json()

Filtrer par nature de mutation

Ventes classiques

cURL
JavaScript
PHP
Python

# Ventes uniquement (pas d'échanges, expropriations, etc.)
curl "https://app.infoparcelle.fr/api/v1/dvfs?code_postal=13001&nature_mutation=3&limite=20" \
  -H "Authorization: Bearer VOTRE_CLE_API"

const apiKey = process.env.INFOPARCELLE_API_KEY;

// Ventes uniquement (pas d'échanges, expropriations, etc.)
const response = await fetch(
  'https://app.infoparcelle.fr/api/v1/dvfs?' +
  new URLSearchParams({
    code_postal: '13001',
    nature_mutation: '3',
    limite: '20',
  }),
  {
    headers: { 'Authorization': `Bearer ${apiKey}` }
  }
);

const ventes = await response.json();

<?php
$apiKey = getenv('INFOPARCELLE_API_KEY');

// Ventes uniquement (pas d'échanges, expropriations, etc.)
$url = 'https://app.infoparcelle.fr/api/v1/dvfs?' . http_build_query([
    'code_postal' => '13001',
    'nature_mutation' => '3',
    'limite' => '20'
]);

$options = [
    'http' => [
        'header' => "Authorization: Bearer $apiKey\r\n",
        'method' => 'GET'
    ]
];

$context = stream_context_create($options);
$response = file_get_contents($url, false, $context);
$ventes = json_decode($response, true);
?>

import os
import requests

api_key = os.getenv('INFOPARCELLE_API_KEY')

# Ventes uniquement (pas d'échanges, expropriations, etc.)
response = requests.get(
    'https://app.infoparcelle.fr/api/v1/dvfs',
    params={
        'code_postal': '13001',
        'nature_mutation': '3',
        'limite': 20
    },
    headers={'Authorization': f'Bearer {api_key}'}
)

ventes = response.json()

Natures de mutation :

0 - Adjudication : Vente aux enchères publiques
1 - Echange : Échange de biens immobiliers
2 - Expropriation : Acquisition forcée pour cause d'utilité publique
3 - Vente : Vente classique
4 - Vente en l'état futur d'achèvement (VEFA)
5 - Vente terrain à bâtir

VEFA uniquement

cURL
JavaScript
PHP
Python

# Ventes VEFA à Montpellier
curl "https://app.infoparcelle.fr/api/v1/dvfs?code_municipalite=34172&vefa=true&limite=20" \
  -H "Authorization: Bearer VOTRE_CLE_API"

const apiKey = process.env.INFOPARCELLE_API_KEY;

// Ventes VEFA à Montpellier
const response = await fetch(
  'https://app.infoparcelle.fr/api/v1/dvfs?' +
  new URLSearchParams({
    code_municipalite: '34172',
    vefa: 'true',
    limite: '20',
  }),
  {
    headers: { 'Authorization': `Bearer ${apiKey}` }
  }
);

const ventesVefa = await response.json();

<?php
$apiKey = getenv('INFOPARCELLE_API_KEY');

// Ventes VEFA à Montpellier
$url = 'https://app.infoparcelle.fr/api/v1/dvfs?' . http_build_query([
    'code_municipalite' => '34172',
    'vefa' => 'true',
    'limite' => '20'
]);

$options = [
    'http' => [
        'header' => "Authorization: Bearer $apiKey\r\n",
        'method' => 'GET'
    ]
];

$context = stream_context_create($options);
$response = file_get_contents($url, false, $context);
$ventesVefa = json_decode($response, true);
?>

import os
import requests

api_key = os.getenv('INFOPARCELLE_API_KEY')

# Ventes VEFA à Montpellier
response = requests.get(
    'https://app.infoparcelle.fr/api/v1/dvfs',
    params={
        'code_municipalite': '34172',
        'vefa': 'true',
        'limite': 20
    },
    headers={'Authorization': f'Bearer {api_key}'}
)

ventes_vefa = response.json()

Tri et pagination

Trier les résultats

cURL
JavaScript
PHP
Python

# Trier par prix décroissant
curl "https://app.infoparcelle.fr/api/v1/dvfs?code_postal=75008&champ_tri=valeur_fonciere&ordre_tri=desc&limite=20" \
  -H "Authorization: Bearer VOTRE_CLE_API"

const apiKey = process.env.INFOPARCELLE_API_KEY;

// Trier par prix décroissant
const response = await fetch(
  'https://app.infoparcelle.fr/api/v1/dvfs?' +
  new URLSearchParams({
    code_postal: '75008',
    champ_tri: 'valeur_fonciere',
    ordre_tri: 'desc',
    limite: '20',
  }),
  {
    headers: { 'Authorization': `Bearer ${apiKey}` }
  }
);

const transactionsTriees = await response.json();

<?php
$apiKey = getenv('INFOPARCELLE_API_KEY');

// Trier par prix décroissant
$url = 'https://app.infoparcelle.fr/api/v1/dvfs?' . http_build_query([
    'code_postal' => '75008',
    'champ_tri' => 'valeur_fonciere',
    'ordre_tri' => 'desc',
    'limite' => '20'
]);

$options = [
    'http' => [
        'header' => "Authorization: Bearer $apiKey\r\n",
        'method' => 'GET'
    ]
];

$context = stream_context_create($options);
$response = file_get_contents($url, false, $context);
$transactionsTriees = json_decode($response, true);
?>

import os
import requests

api_key = os.getenv('INFOPARCELLE_API_KEY')

# Trier par prix décroissant
response = requests.get(
    'https://app.infoparcelle.fr/api/v1/dvfs',
    params={
        'code_postal': '75008',
        'champ_tri': 'valeur_fonciere',
        'ordre_tri': 'desc',
        'limite': 20
    },
    headers={'Authorization': f'Bearer {api_key}'}
)

transactions_triees = response.json()

Champs de tri disponibles :

id_mutation - Identifiant unique
date_mutation - Date de vente (défaut)
nature_mutation - Nature de la transaction
bati_type - Type de bâti
code_type_bien - Code du type de bien
valeur_fonciere - Prix de vente
surface_batie - Surface bâtie

Pagination avec curseur

cURL
JavaScript
PHP
Python

# Page 1
curl -i "https://app.infoparcelle.fr/api/v1/dvfs?code_postal=75001&limite=20" \
  -H "Authorization: Bearer VOTRE_CLE_API"

# Récupérer le curseur depuis le header X-Pagination-Next-Cursor

# Page 2 (remplacer CURSEUR par la valeur obtenue)
curl "https://app.infoparcelle.fr/api/v1/dvfs?code_postal=75001&limite=20&curseur=CURSEUR" \
  -H "Authorization: Bearer VOTRE_CLE_API"

const apiKey = process.env.INFOPARCELLE_API_KEY;

// Page 1
let response = await fetch(
  'https://app.infoparcelle.fr/api/v1/dvfs?code_postal=75001&limite=20',
  {
    headers: { 'Authorization': `Bearer ${apiKey}` }
  }
);

let transactions = await response.json();
let nextCursor = response.headers.get('X-Pagination-Next-Cursor');

// Page 2
if (nextCursor) {
  response = await fetch(
    `https://app.infoparcelle.fr/api/v1/dvfs?code_postal=75001&limite=20&curseur=${nextCursor}`,
    {
      headers: { 'Authorization': `Bearer ${apiKey}` }
    }
  );

  const transactionsPage2 = await response.json();
  transactions = [...transactions, ...transactionsPage2];
}

<?php
$apiKey = getenv('INFOPARCELLE_API_KEY');

// Page 1
$url = 'https://app.infoparcelle.fr/api/v1/dvfs?' . http_build_query([
    'code_postal' => '75001',
    'limite' => '20'
]);

$options = [
    'http' => [
        'header' => "Authorization: Bearer $apiKey\r\n",
        'method' => 'GET'
    ]
];

$context = stream_context_create($options);
$response = file_get_contents($url, false, $context);
$transactions = json_decode($response, true);

// Récupérer le curseur depuis les headers
$nextCursor = null;
foreach ($http_response_header as $header) {
    if (stripos($header, 'X-Pagination-Next-Cursor:') !== false) {
        $nextCursor = trim(substr($header, strpos($header, ':') + 1));
        break;
    }
}

// Page 2
if ($nextCursor) {
    $url = 'https://app.infoparcelle.fr/api/v1/dvfs?' . http_build_query([
        'code_postal' => '75001',
        'limite' => '20',
        'curseur' => $nextCursor
    ]);

    $response2 = file_get_contents($url, false, $context);
    $transactionsPage2 = json_decode($response2, true);
    $transactions = array_merge($transactions, $transactionsPage2);
}
?>

import os
import requests

api_key = os.getenv('INFOPARCELLE_API_KEY')

# Page 1
response = requests.get(
    'https://app.infoparcelle.fr/api/v1/dvfs',
    params={
        'code_postal': '75001',
        'limite': 20
    },
    headers={'Authorization': f'Bearer {api_key}'}
)

transactions = response.json()
next_cursor = response.headers.get('X-Pagination-Next-Cursor')

# Page 2
if next_cursor:
    response = requests.get(
        'https://app.infoparcelle.fr/api/v1/dvfs',
        params={
            'code_postal': '75001',
            'limite': 20,
            'curseur': next_cursor
        },
        headers={'Authorization': f'Bearer {api_key}'}
    )

    transactions_page2 = response.json()
    transactions = transactions + transactions_page2

Format GeoJSON

Pour afficher les transactions sur une carte :

cURL
JavaScript
PHP
Python

curl "https://app.infoparcelle.fr/api/v1/dvfs?code_postal=75008&format=geojson&limite=20" \
  -H "Authorization: Bearer VOTRE_CLE_API"

const apiKey = process.env.INFOPARCELLE_API_KEY;

const response = await fetch(
  'https://app.infoparcelle.fr/api/v1/dvfs?' +
  new URLSearchParams({
    code_postal: '75008',
    format: 'geojson',
    limite: '20',
  }),
  {
    headers: { 'Authorization': `Bearer ${apiKey}` }
  }
);

const geojson = await response.json();
console.log(geojson);

<?php
$apiKey = getenv('INFOPARCELLE_API_KEY');

$url = 'https://app.infoparcelle.fr/api/v1/dvfs?' . http_build_query([
    'code_postal' => '75008',
    'format' => 'geojson',
    'limite' => '20'
]);

$options = [
    'http' => [
        'header' => "Authorization: Bearer $apiKey\r\n",
        'method' => 'GET'
    ]
];

$context = stream_context_create($options);
$response = file_get_contents($url, false, $context);
$geojson = json_decode($response, true);

print_r($geojson);
?>

import os
import requests

api_key = os.getenv('INFOPARCELLE_API_KEY')

response = requests.get(
    'https://app.infoparcelle.fr/api/v1/dvfs',
    params={
        'code_postal': '75008',
        'format': 'geojson',
        'limite': 20
    },
    headers={'Authorization': f'Bearer {api_key}'}
)

geojson = response.json()
print(geojson)

{
  "type": "FeatureCollection",
  "features": [
    {
      "type": "Feature",
      "geometry": {
        "type": "Point",
        "coordinates": [2.3522, 48.8566]
      },
      "properties": {
        "id_mutation": "2023-12345",
        "date_mutation": "2023-06-15",
        "nature_mutation": "Vente",
        "valeur_fonciere": 350000,
        "code_type_bien": 121,
        "libelle_type": "UN APPARTEMENT",
        "bati_type": 7,
        "surface_batie": 75.5,
        "municipalite": {
          "code": "75056",
          "nom": "Paris"
        }
      }
    }
  ]
}

Personnaliser les champs retournés

cURL
JavaScript
PHP
Python

# Demander uniquement certains champs
curl "https://app.infoparcelle.fr/api/v1/dvfs?code_postal=75008&champs=id_mutation,date_mutation,valeur_fonciere,surface_batie,municipalite&limite=20" \
  -H "Authorization: Bearer VOTRE_CLE_API"

const apiKey = process.env.INFOPARCELLE_API_KEY;

// Demander uniquement certains champs
const response = await fetch(
  'https://app.infoparcelle.fr/api/v1/dvfs?' +
  new URLSearchParams({
    code_postal: '75008',
    champs: 'id_mutation,date_mutation,valeur_fonciere,surface_batie,municipalite',
    limite: '20',
  }),
  {
    headers: { 'Authorization': `Bearer ${apiKey}` }
  }
);

const transactions = await response.json();

<?php
$apiKey = getenv('INFOPARCELLE_API_KEY');

// Demander uniquement certains champs
$url = 'https://app.infoparcelle.fr/api/v1/dvfs?' . http_build_query([
    'code_postal' => '75008',
    'champs' => 'id_mutation,date_mutation,valeur_fonciere,surface_batie,municipalite',
    'limite' => '20'
]);

$options = [
    'http' => [
        'header' => "Authorization: Bearer $apiKey\r\n",
        'method' => 'GET'
    ]
];

$context = stream_context_create($options);
$response = file_get_contents($url, false, $context);
$transactions = json_decode($response, true);
?>

import os
import requests

api_key = os.getenv('INFOPARCELLE_API_KEY')

# Demander uniquement certains champs
response = requests.get(
    'https://app.infoparcelle.fr/api/v1/dvfs',
    params={
        'code_postal': '75008',
        'champs': 'id_mutation,date_mutation,valeur_fonciere,surface_batie,municipalite',
        'limite': 20
    },
    headers={'Authorization': f'Bearer {api_key}'}
)

transactions = response.json()

Champs disponibles :

id_mutation - Identifiant unique
date_mutation - Date de signature
nature_mutation - Nature de la mutation
valeur_fonciere - Prix
vefa - Indicateur VEFA
code_type_bien - Code du type
libelle_type - Libellé descriptif
bati_type - Type calculé
nb_lots, nb_parcelles, nb_locaux
nb_maisons, nb_appartements, nb_dependances
surface_terrain, surface_batie
surface_maisons, surface_appartements
parcelles - Liste des parcelles (max 10)
municipalite - Informations commune
centre - Point GPS

Cas d'usage avancés

1. Analyse de marché local

JavaScript
PHP
Python

async function analyserMarcheImmobilier(codePostal, annee = 2024) {
  /**
   * Analyse le marché immobilier pour un code postal donné
   */
  const apiKey = process.env.INFOPARCELLE_API_KEY;

  const response = await fetch(
    'https://app.infoparcelle.fr/api/v1/dvfs?' +
    new URLSearchParams({
      code_postal: codePostal,
      date_mutation_min: `${annee}-01-01`,
      nature_mutation: '3',  // Ventes uniquement
      limite: '50'
    }),
    {
      headers: { 'Authorization': `Bearer ${apiKey}` }
    }
  );

  const transactions = await response.json();

  // Calculer les statistiques
  const stats = {
    total_ventes: transactions.length,
    prix_moyen: 0,
    prix_median: 0,
    prix_m2_moyen: 0,
    par_type: {}
  };

  if (transactions.length === 0) {
    return stats;
  }

  // Prix moyen
  stats.prix_moyen = transactions.reduce((sum, t) => sum + t.valeur_fonciere, 0) / transactions.length;

  // Prix médian
  const prixTries = transactions.map(t => t.valeur_fonciere).sort((a, b) => a - b);
  stats.prix_median = prixTries[Math.floor(prixTries.length / 2)];

  // Prix au m² moyen
  const prixM2List = transactions
    .filter(t => t.surface_batie && t.surface_batie > 0)
    .map(t => t.valeur_fonciere / t.surface_batie);

  if (prixM2List.length > 0) {
    stats.prix_m2_moyen = prixM2List.reduce((sum, p) => sum + p, 0) / prixM2List.length;
  }

  // Répartition par type
  transactions.forEach(t => {
    const typeBien = t.libelle_type || 'Inconnu';
    stats.par_type[typeBien] = (stats.par_type[typeBien] || 0) + 1;
  });

  return stats;
}

// Utilisation
const stats = await analyserMarcheImmobilier('75008', 2024);
console.log('Analyse du marché immobilier 75008:');
console.log(`  Total ventes: ${stats.total_ventes}`);
console.log(`  Prix moyen: ${stats.prix_moyen.toLocaleString('fr-FR', {maximumFractionDigits: 0})} €`);
console.log(`  Prix médian: ${stats.prix_median.toLocaleString('fr-FR', {maximumFractionDigits: 0})} €`);
console.log(`  Prix m² moyen: ${Math.round(stats.prix_m2_moyen)} €/m²`);
console.log(`  Répartition:`, stats.par_type);

<?php
function analyser_marche_immobilier($code_postal, $annee = 2024, $api_key) {
    /**
     * Analyse le marché immobilier pour un code postal donné
     */
    $params = http_build_query([
        'code_postal' => $code_postal,
        'date_mutation_min' => "$annee-01-01",
        'nature_mutation' => '3',  // Ventes uniquement
        'limite' => '50'
    ]);

    $ch = curl_init("https://app.infoparcelle.fr/api/v1/dvfs?$params");
    curl_setopt($ch, CURLOPT_HTTPHEADER, ["Authorization: Bearer $api_key"]);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    $response = curl_exec($ch);
    curl_close($ch);

    $transactions = json_decode($response, true);

    // Calculer les statistiques
    $stats = [
        'total_ventes' => count($transactions),
        'prix_moyen' => 0,
        'prix_median' => 0,
        'prix_m2_moyen' => 0,
        'par_type' => []
    ];

    if (empty($transactions)) {
        return $stats;
    }

    // Prix moyen
    $stats['prix_moyen'] = array_sum(array_column($transactions, 'valeur_fonciere')) / count($transactions);

    // Prix médian
    $prix_tries = array_column($transactions, 'valeur_fonciere');
    sort($prix_tries);
    $stats['prix_median'] = $prix_tries[floor(count($prix_tries) / 2)];

    // Prix au m² moyen
    $prix_m2_list = [];
    foreach ($transactions as $t) {
        if (!empty($t['surface_batie']) && $t['surface_batie'] > 0) {
            $prix_m2_list[] = $t['valeur_fonciere'] / $t['surface_batie'];
        }
    }
    if (!empty($prix_m2_list)) {
        $stats['prix_m2_moyen'] = array_sum($prix_m2_list) / count($prix_m2_list);
    }

    // Répartition par type
    foreach ($transactions as $t) {
        $type_bien = $t['libelle_type'] ?? 'Inconnu';
        $stats['par_type'][$type_bien] = ($stats['par_type'][$type_bien] ?? 0) + 1;
    }

    return $stats;
}

// Utilisation
$api_key = getenv('INFOPARCELLE_API_KEY');
$stats = analyser_marche_immobilier('75008', 2024, $api_key);
echo "Analyse du marché immobilier 75008:\n";
echo "  Total ventes: {$stats['total_ventes']}\n";
echo "  Prix moyen: " . number_format($stats['prix_moyen'], 0, ',', ' ') . " €\n";
echo "  Prix médian: " . number_format($stats['prix_median'], 0, ',', ' ') . " €\n";
echo "  Prix m² moyen: " . round($stats['prix_m2_moyen']) . " €/m²\n";
echo "  Répartition: " . json_encode($stats['par_type']) . "\n";
?>

import os
import requests

def analyser_marche_immobilier(code_postal, annee=2024):
    """
    Analyse le marché immobilier pour un code postal donné
    """
    api_key = os.getenv('INFOPARCELLE_API_KEY')

    response = requests.get(
        'https://app.infoparcelle.fr/api/v1/dvfs',
        params={
            'code_postal': code_postal,
            'date_mutation_min': f'{annee}-01-01',
            'nature_mutation': '3',  # Ventes uniquement
            'limite': 50
        },
        headers={'Authorization': f'Bearer {api_key}'}
    )

    transactions = response.json()

    # Calculer les statistiques
    stats = {
        'total_ventes': len(transactions),
        'prix_moyen': 0,
        'prix_median': 0,
        'prix_m2_moyen': 0,
        'par_type': {}
    }

    if not transactions:
        return stats

    # Prix moyen
    stats['prix_moyen'] = sum(t['valeur_fonciere'] for t in transactions) / len(transactions)

    # Prix médian
    prix_tries = sorted(t['valeur_fonciere'] for t in transactions)
    stats['prix_median'] = prix_tries[len(prix_tries) // 2]

    # Prix au m² moyen
    prix_m2_list = [
        t['valeur_fonciere'] / t['surface_batie']
        for t in transactions
        if t.get('surface_batie') and t['surface_batie'] > 0
    ]
    if prix_m2_list:
        stats['prix_m2_moyen'] = sum(prix_m2_list) / len(prix_m2_list)

    # Répartition par type
    for t in transactions:
        type_bien = t.get('libelle_type', 'Inconnu')
        stats['par_type'][type_bien] = stats['par_type'].get(type_bien, 0) + 1

    return stats

# Utilisation
stats = analyser_marche_immobilier('75008', annee=2024)
print(f"Analyse du marché immobilier 75008:")
print(f"  Total ventes: {stats['total_ventes']}")
print(f"  Prix moyen: {stats['prix_moyen']:,.0f} €")
print(f"  Prix médian: {stats['prix_median']:,.0f} €")
print(f"  Prix m² moyen: {stats['prix_m2_moyen']:.0f} €/m²")
print(f"  Répartition: {stats['par_type']}")

2. Détection d'opportunités

JavaScript
PHP
Python

async function trouverOpportunites(codePostal) {
  /**
   * Trouver les biens vendus en dessous du prix du marché
   */
  const apiKey = process.env.INFOPARCELLE_API_KEY;

  // 1. Récupérer les ventes récentes
  const response = await fetch(
    'https://app.infoparcelle.fr/api/v1/dvfs?' +
    new URLSearchParams({
      code_postal: codePostal,
      date_mutation_min: '2023-01-01',
      code_type_bien: '121',  // Appartements
      limite: '50',
    }),
    {
      headers: { 'Authorization': `Bearer ${apiKey}` }
    }
  );

  const transactions = await response.json();

  // 2. Calculer le prix au m² moyen
  const prixM2List = transactions
    .filter(t => t.surface_batie > 0)
    .map(t => t.valeur_fonciere / t.surface_batie);

  const prixM2Moyen = prixM2List.reduce((a, b) => a + b, 0) / prixM2List.length;

  // 3. Trouver les ventes < 85% du prix moyen
  const opportunites = transactions.filter(t => {
    if (!t.surface_batie || t.surface_batie === 0) return false;
    const prixM2 = t.valeur_fonciere / t.surface_batie;
    return prixM2 < prixM2Moyen * 0.85;
  });

  return {
    prixM2Moyen,
    opportunites: opportunites.map(t => ({
      date: t.date_mutation,
      prix: t.valeur_fonciere,
      surface: t.surface_batie,
      prixM2: Math.round(t.valeur_fonciere / t.surface_batie),
      economie: Math.round((prixM2Moyen - t.valeur_fonciere / t.surface_batie) * t.surface_batie),
    })),
  };
}

// Utilisation
const resultats = await trouverOpportunites('75008');
console.log(`Prix m² moyen: ${Math.round(resultats.prixM2Moyen)} €/m²`);
console.log(`Opportunités trouvées: ${resultats.opportunites.length}`);

<?php
function trouver_opportunites($code_postal, $api_key) {
    /**
     * Trouver les biens vendus en dessous du prix du marché
     */
    // 1. Récupérer les ventes récentes
    $params = http_build_query([
        'code_postal' => $code_postal,
        'date_mutation_min' => '2023-01-01',
        'code_type_bien' => '121',  // Appartements
        'limite' => '50'
    ]);

    $ch = curl_init("https://app.infoparcelle.fr/api/v1/dvfs?$params");
    curl_setopt($ch, CURLOPT_HTTPHEADER, ["Authorization: Bearer $api_key"]);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    $response = curl_exec($ch);
    curl_close($ch);

    $transactions = json_decode($response, true);

    // 2. Calculer le prix au m² moyen
    $prix_m2_list = [];
    foreach ($transactions as $t) {
        if (!empty($t['surface_batie']) && $t['surface_batie'] > 0) {
            $prix_m2_list[] = $t['valeur_fonciere'] / $t['surface_batie'];
        }
    }

    $prix_m2_moyen = array_sum($prix_m2_list) / count($prix_m2_list);

    // 3. Trouver les ventes < 85% du prix moyen
    $opportunites = [];
    foreach ($transactions as $t) {
        if (empty($t['surface_batie']) || $t['surface_batie'] == 0) continue;

        $prix_m2 = $t['valeur_fonciere'] / $t['surface_batie'];
        if ($prix_m2 < $prix_m2_moyen * 0.85) {
            $opportunites[] = [
                'date' => $t['date_mutation'],
                'prix' => $t['valeur_fonciere'],
                'surface' => $t['surface_batie'],
                'prix_m2' => round($prix_m2),
                'economie' => round(($prix_m2_moyen - $prix_m2) * $t['surface_batie'])
            ];
        }
    }

    return [
        'prix_m2_moyen' => $prix_m2_moyen,
        'opportunites' => $opportunites
    ];
}

// Utilisation
$api_key = getenv('INFOPARCELLE_API_KEY');
$resultats = trouver_opportunites('75008', $api_key);
echo "Prix m² moyen: " . round($resultats['prix_m2_moyen']) . " €/m²\n";
echo "Opportunités trouvées: " . count($resultats['opportunites']) . "\n";
?>

import os
import requests

def trouver_opportunites(code_postal):
    """
    Trouver les biens vendus en dessous du prix du marché
    """
    api_key = os.getenv('INFOPARCELLE_API_KEY')

    # 1. Récupérer les ventes récentes
    response = requests.get(
        'https://app.infoparcelle.fr/api/v1/dvfs',
        params={
            'code_postal': code_postal,
            'date_mutation_min': '2023-01-01',
            'code_type_bien': '121',  # Appartements
            'limite': 50
        },
        headers={'Authorization': f'Bearer {api_key}'}
    )

    transactions = response.json()

    # 2. Calculer le prix au m² moyen
    prix_m2_list = [
        t['valeur_fonciere'] / t['surface_batie']
        for t in transactions
        if t.get('surface_batie') and t['surface_batie'] > 0
    ]

    prix_m2_moyen = sum(prix_m2_list) / len(prix_m2_list)

    # 3. Trouver les ventes < 85% du prix moyen
    opportunites = []
    for t in transactions:
        if not t.get('surface_batie') or t['surface_batie'] == 0:
            continue

        prix_m2 = t['valeur_fonciere'] / t['surface_batie']
        if prix_m2 < prix_m2_moyen * 0.85:
            opportunites.append({
                'date': t['date_mutation'],
                'prix': t['valeur_fonciere'],
                'surface': t['surface_batie'],
                'prix_m2': round(prix_m2),
                'economie': round((prix_m2_moyen - prix_m2) * t['surface_batie'])
            })

    return {
        'prix_m2_moyen': prix_m2_moyen,
        'opportunites': opportunites
    }

# Utilisation
resultats = trouver_opportunites('75008')
print(f"Prix m² moyen: {round(resultats['prix_m2_moyen'])} €/m²")
print(f"Opportunités trouvées: {len(resultats['opportunites'])}")

3. Évolution des prix dans le temps

JavaScript
PHP
Python

async function evolutionPrixTemporelle(codeMunicipalite, typeBien = '121') {
  /**
   * Analyse l'évolution des prix sur plusieurs années
   */
  const apiKey = process.env.INFOPARCELLE_API_KEY;
  const annees = [2020, 2021, 2022, 2023, 2024];
  const evolution = {};

  for (const annee of annees) {
    const response = await fetch(
      'https://app.infoparcelle.fr/api/v1/dvfs?' +
      new URLSearchParams({
        code_municipalite: codeMunicipalite,
        code_type_bien: typeBien,
        date_mutation_min: `${annee}-01-01`,
        date_mutation_max: `${annee}-12-31`,
        limite: '50'
      }),
      {
        headers: { 'Authorization': `Bearer ${apiKey}` }
      }
    );

    const transactions = await response.json();

    if (transactions.length > 0) {
      // Calculer le prix moyen au m²
      const prixM2List = transactions
        .filter(t => t.surface_batie && t.surface_batie > 0)
        .map(t => t.valeur_fonciere / t.surface_batie);

      if (prixM2List.length > 0) {
        evolution[annee] = {
          nb_ventes: transactions.length,
          prix_m2_moyen: prixM2List.reduce((a, b) => a + b, 0) / prixM2List.length
        };
      }
    }
  }

  // Calculer l'évolution en %
  const anneesKeys = Object.keys(evolution).map(Number);
  anneesKeys.forEach((annee, i) => {
    if (i > 0) {
      const anneePrecedente = anneesKeys[i - 1];
      const evolutionPct = (
        (evolution[annee].prix_m2_moyen - evolution[anneePrecedente].prix_m2_moyen)
        / evolution[anneePrecedente].prix_m2_moyen * 100
      );
      evolution[annee].evolution_pct = evolutionPct;
    }
  });

  return evolution;
}

// Utilisation
const evolution = await evolutionPrixTemporelle('75108', '121');
for (const [annee, data] of Object.entries(evolution)) {
  const evolutionTxt = data.evolution_pct !== undefined ?
    ` (${data.evolution_pct > 0 ? '+' : ''}${data.evolution_pct.toFixed(1)}%)` : '';
  console.log(`${annee}: ${Math.round(data.prix_m2_moyen)} €/m² (${data.nb_ventes} ventes)${evolutionTxt}`);
}

<?php
function evolution_prix_temporelle($code_municipalite, $type_bien = '121', $api_key) {
    /**
     * Analyse l'évolution des prix sur plusieurs années
     */
    $annees = [2020, 2021, 2022, 2023, 2024];
    $evolution = [];

    foreach ($annees as $annee) {
        $params = http_build_query([
            'code_municipalite' => $code_municipalite,
            'code_type_bien' => $type_bien,
            'date_mutation_min' => "$annee-01-01",
            'date_mutation_max' => "$annee-12-31",
            'limite' => '50'
        ]);

        $ch = curl_init("https://app.infoparcelle.fr/api/v1/dvfs?$params");
        curl_setopt($ch, CURLOPT_HTTPHEADER, ["Authorization: Bearer $api_key"]);
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
        $response = curl_exec($ch);
        curl_close($ch);

        $transactions = json_decode($response, true);

        if (!empty($transactions)) {
            // Calculer le prix moyen au m²
            $prix_m2_list = [];
            foreach ($transactions as $t) {
                if (!empty($t['surface_batie']) && $t['surface_batie'] > 0) {
                    $prix_m2_list[] = $t['valeur_fonciere'] / $t['surface_batie'];
                }
            }

            if (!empty($prix_m2_list)) {
                $evolution[$annee] = [
                    'nb_ventes' => count($transactions),
                    'prix_m2_moyen' => array_sum($prix_m2_list) / count($prix_m2_list)
                ];
            }
        }
    }

    // Calculer l'évolution en %
    $annees_keys = array_keys($evolution);
    foreach ($annees_keys as $i => $annee) {
        if ($i > 0) {
            $annee_precedente = $annees_keys[$i - 1];
            $evolution_pct = (
                ($evolution[$annee]['prix_m2_moyen'] - $evolution[$annee_precedente]['prix_m2_moyen'])
                / $evolution[$annee_precedente]['prix_m2_moyen'] * 100
            );
            $evolution[$annee]['evolution_pct'] = $evolution_pct;
        }
    }

    return $evolution;
}

// Utilisation
$api_key = getenv('INFOPARCELLE_API_KEY');
$evolution = evolution_prix_temporelle('75108', '121', $api_key);
foreach ($evolution as $annee => $data) {
    $evolution_txt = isset($data['evolution_pct']) ?
        ' (' . ($data['evolution_pct'] > 0 ? '+' : '') . round($data['evolution_pct'], 1) . '%)' : '';
    echo "$annee: " . round($data['prix_m2_moyen']) . " €/m² ({$data['nb_ventes']} ventes)$evolution_txt\n";
}
?>

import os
import requests

def evolution_prix_temporelle(code_municipalite, type_bien='121'):
    """
    Analyse l'évolution des prix sur plusieurs années
    """
    api_key = os.getenv('INFOPARCELLE_API_KEY')
    annees = [2020, 2021, 2022, 2023, 2024]
    evolution = {}

    for annee in annees:
        response = requests.get(
            'https://app.infoparcelle.fr/api/v1/dvfs',
            params={
                'code_municipalite': code_municipalite,
                'code_type_bien': type_bien,
                'date_mutation_min': f'{annee}-01-01',
                'date_mutation_max': f'{annee}-12-31',
                'limite': 50
            },
            headers={'Authorization': f'Bearer {api_key}'}
        )

        transactions = response.json()

        if transactions:
            # Calculer le prix moyen au m²
            prix_m2_list = [
                t['valeur_fonciere'] / t['surface_batie']
                for t in transactions
                if t.get('surface_batie') and t['surface_batie'] > 0
            ]

            if prix_m2_list:
                evolution[annee] = {
                    'nb_ventes': len(transactions),
                    'prix_m2_moyen': sum(prix_m2_list) / len(prix_m2_list)
                }

    # Calculer l'évolution en %
    for i, annee in enumerate(list(evolution.keys())[1:], 1):
        annee_precedente = list(evolution.keys())[i-1]
        evolution_pct = (
            (evolution[annee]['prix_m2_moyen'] - evolution[annee_precedente]['prix_m2_moyen'])
            / evolution[annee_precedente]['prix_m2_moyen'] * 100
        )
        evolution[annee]['evolution_pct'] = evolution_pct

    return evolution

# Utilisation
evolution = evolution_prix_temporelle('75108', type_bien='121')
for annee, data in evolution.items():
    evolution_txt = f" ({data['evolution_pct']:+.1f}%)" if 'evolution_pct' in data else ""
    print(f"{annee}: {data['prix_m2_moyen']:.0f} €/m² ({data['nb_ventes']} ventes){evolution_txt}")

4. Comparaison entre quartiers

JavaScript
PHP
Python

async function comparerQuartiers(codesMunicipalite) {
  /**
   * Comparer les prix entre plusieurs quartiers
   */
  const apiKey = process.env.INFOPARCELLE_API_KEY;
  const resultats = {};

  for (const code of codesMunicipalite) {
    const response = await fetch(
      'https://app.infoparcelle.fr/api/v1/dvfs?' +
      new URLSearchParams({
        code_municipalite: code,
        date_mutation_min: '2024-01-01',
        code_type_bien: '121',
        limite: '50',
      }),
      {
        headers: { 'Authorization': `Bearer ${apiKey}` }
      }
    );

    const transactions = await response.json();

    if (transactions.length > 0) {
      const prixM2List = transactions
        .filter(t => t.surface_batie > 0)
        .map(t => t.valeur_fonciere / t.surface_batie);

      resultats[code] = {
        nom: transactions[0].municipalite.nom,
        nbVentes: transactions.length,
        prixM2Moyen: Math.round(prixM2List.reduce((a, b) => a + b, 0) / prixM2List.length),
      };
    }
  }

  return resultats;
}

// Utilisation : comparer Paris 1er, 8e et 16e
const comparaison = await comparerQuartiers(['75101', '75108', '75116']);
console.table(comparaison);

<?php
function comparer_quartiers($codes_municipalite, $api_key) {
    /**
     * Comparer les prix entre plusieurs quartiers
     */
    $resultats = [];

    foreach ($codes_municipalite as $code) {
        $params = http_build_query([
            'code_municipalite' => $code,
            'date_mutation_min' => '2024-01-01',
            'code_type_bien' => '121',
            'limite' => '50'
        ]);

        $ch = curl_init("https://app.infoparcelle.fr/api/v1/dvfs?$params");
        curl_setopt($ch, CURLOPT_HTTPHEADER, ["Authorization: Bearer $api_key"]);
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
        $response = curl_exec($ch);
        curl_close($ch);

        $transactions = json_decode($response, true);

        if (!empty($transactions)) {
            $prix_m2_list = [];
            foreach ($transactions as $t) {
                if (!empty($t['surface_batie']) && $t['surface_batie'] > 0) {
                    $prix_m2_list[] = $t['valeur_fonciere'] / $t['surface_batie'];
                }
            }

            if (!empty($prix_m2_list)) {
                $resultats[$code] = [
                    'nom' => $transactions[0]['municipalite']['nom'],
                    'nb_ventes' => count($transactions),
                    'prix_m2_moyen' => round(array_sum($prix_m2_list) / count($prix_m2_list))
                ];
            }
        }
    }

    return $resultats;
}

// Utilisation : comparer Paris 1er, 8e et 16e
$api_key = getenv('INFOPARCELLE_API_KEY');
$comparaison = comparer_quartiers(['75101', '75108', '75116'], $api_key);
foreach ($comparaison as $code => $data) {
    echo "$code - {$data['nom']}:\n";
    echo "  Nombre de ventes: {$data['nb_ventes']}\n";
    echo "  Prix m² moyen: {$data['prix_m2_moyen']} €/m²\n\n";
}
?>

import os
import requests

def comparer_quartiers(codes_municipalite):
    """
    Comparer les prix entre plusieurs quartiers
    """
    api_key = os.getenv('INFOPARCELLE_API_KEY')
    resultats = {}

    for code in codes_municipalite:
        response = requests.get(
            'https://app.infoparcelle.fr/api/v1/dvfs',
            params={
                'code_municipalite': code,
                'date_mutation_min': '2024-01-01',
                'code_type_bien': '121',
                'limite': 50
            },
            headers={'Authorization': f'Bearer {api_key}'}
        )

        transactions = response.json()

        if transactions:
            prix_m2_list = [
                t['valeur_fonciere'] / t['surface_batie']
                for t in transactions
                if t.get('surface_batie') and t['surface_batie'] > 0
            ]

            if prix_m2_list:
                resultats[code] = {
                    'nom': transactions[0]['municipalite']['nom'],
                    'nb_ventes': len(transactions),
                    'prix_m2_moyen': round(sum(prix_m2_list) / len(prix_m2_list))
                }

    return resultats

# Utilisation : comparer Paris 1er, 8e et 16e
comparaison = comparer_quartiers(['75101', '75108', '75116'])
for code, data in comparaison.items():
    print(f"{code} - {data['nom']}:")
    print(f"  Nombre de ventes: {data['nb_ventes']}")
    print(f"  Prix m² moyen: {data['prix_m2_moyen']} €/m²\n")

Bonnes pratiques

✅ À faire

Filtrer par localisation (code postal ou commune)
Filtrer par date pour des analyses pertinentes
Utiliser la pagination par curseur pour de grands volumes
Trier les résultats selon vos besoins
Calculer le prix au m² pour comparer les biens
Demander uniquement les champs nécessaires
Gérer les valeurs nulles (certains champs peuvent être vides)
Cacher les résultats pour les recherches fréquentes

❌ À éviter

❌ Ignorer les filtres de date (trop de résultats)
❌ Ne pas gérer les surfaces nulles dans les calculs
❌ Oublier la pagination (limite max : 50 résultats)
❌ Multiplier les requêtes inutiles
❌ Ne pas vérifier les en-têtes de pagination

Limites et précisions

Données disponibles depuis 2014 uniquement
France métropolitaine + DOM uniquement
Maximum 50 résultats par requête (utilisez la pagination)
Champ parcelles limité à 10 parcelles par DVF
Certaines transactions peuvent avoir des données incomplètes
VEFA : Les ventes en l'état futur d'achèvement peuvent avoir des surfaces nulles

Performances

Temps de réponse moyen : < 150ms
Cache côté serveur : 15 minutes
Rate limit : 1200 requêtes/minute

Voir aussi

Référence API - Documentation technique complète de l'API
Parcelles cadastrales - Rechercher les parcelles
Performance énergétique - Rechercher les DPE
Gestion des erreurs - Gérer les erreurs

Vue d'ensemble​

Fonctionnalités principales​

Données DVF disponibles​

Recherche basique​

Par code postal​

Par commune​

Filtrer par type de bien​

Maisons​

Appartements​

Terrains​

Locaux d'activité​

Filtrer par prix​

Fourchette de prix​

Prix au m² estimé​

Filtrer par surface​

Surface habitable​

Surface de terrain​

Filtrer par date​

Transactions récentes​

Période spécifique​

Filtrer par nature de mutation​

Ventes classiques​

VEFA uniquement​

Tri et pagination​

Trier les résultats​

Pagination avec curseur​

Format GeoJSON​

Personnaliser les champs retournés​

Cas d'usage avancés​

1. Analyse de marché local​

2. Détection d'opportunités​

3. Évolution des prix dans le temps​

4. Comparaison entre quartiers​

Bonnes pratiques​

✅ À faire​

❌ À éviter​

Limites et précisions​

Performances​

Voir aussi​