Calculer l'empreinte carbone d'un trajet par API — Guide ESG développeur

1. L'explosion des exigences ESG pour les entreprises

Les exigences ESG (Environnemental, Social, Gouvernance) encadrent désormais légalement le reporting carbone des entreprises européennes. La directive CSRD s'applique aux grandes entreprises depuis 2025 et impose de déclarer les émissions des scopes 1, 2 et 3. En France, le bilan GES est obligatoire tous les 4 ans pour les entreprises de plus de 500 salariés. Le marché des logiciels de gestion carbone est estimé à 2,8 milliards de dollars en 2025, avec une croissance de 25 % par an.

La pression ESG (Environnemental, Social, Gouvernance) sur les entreprises n'a jamais été aussi forte. Entre les nouvelles réglementations européennes, les exigences des investisseurs et les attentes des clients, mesurer et réduire son empreinte carbone est passé du statut de "bonne pratique" à celui d'obligation légale pour de nombreuses organisations.

Plusieurs textes réglementaires clés encadrent désormais le reporting carbone :

• CSRD (Corporate Sustainability Reporting Directive) : applicable depuis 2025 pour les grandes entreprises européennes (plus de 250 salariés), elle impose un reporting non financier incluant les émissions de GES (Gaz à Effet de Serre) selon les 3 scopes. Plus de 50 000 entreprises européennes sont concernées dés 2025.
• Taxonomie verte de l'UE : les entreprises doivent démontrer que leurs activités sont alignées avec les objectifs climatiques européens pour accéder à certains financements.
• Bilan Carbone obligatoire (France) : les entreprises de plus de 500 salariés (250 outre-mer) doivent publier leur bilan GES tous les 4 ans, selon l'article L. 229-25 du Code de l'environnement.
• SFDR (Sustainable Finance Disclosure Regulation) : les produits financiers doivent divulguer leurs métriques d'impact carbone.

2. Comment fonctionne le calcul d'empreinte carbone

Le calcul d'empreinte carbone repose sur la formule : Émissions (kg CO₂e) = Donnée d'activité × Facteur d'émission. Le CO₂ équivalent (CO₂e) est une unité normalisée qui convertit tous les gaz à effet de serre selon leur Potentiel de Réchauffement Global (PRG) sur 100 ans, défini par le GIEC (rapport AR6, 2021). Le méthane a un PRG de 28, le protoxyde d'azote un PRG de 273.

Le calcul d'empreinte carbone repose sur un principe simple : multiplier une donnée d'activité (kilomètres parcourus, kWh consommés, kg de viande) par un facteur d'émission exprimé en kg CO₂ équivalent (CO₂e) par unité.

Formule de base :

Émissions (kg CO₂e) = Donnée d'activité × Facteur d'émission

Exemples :
Paris → Lyon en voiture diesel (400 km) :
  → 400 km × 0.218 kg CO₂e/km = 87.2 kg CO₂e

Paris → Lyon en TGV (400 km) :
  → 400 km × 0.00293 kg CO₂e/km·passager = 1.17 kg CO₂e

Différence : le train émet 74x moins que la voiture diesel

Le CO₂ équivalent (CO₂e) est une unité normalisée qui convertit tous les gaz à effet de serre en une mesure commune basée sur leur Potentiel de Réchauffement Global (PRG) sur 100 ans, tel que défini par le GIEC (Groupe d'experts Intergouvernemental sur l'Évolution du Climat). Par exemple, le méthane (CH₄) a un PRG de 28, ce qui signifie qu'1 kg de CH₄ = 28 kg CO₂e.

Les sources de facteurs d'émission

La qualité d'un calcul carbone dépend entièrement de la qualité des facteurs d'émission utilisés. Les deux références principales sont :

L'API HubActiva Carbon utilise exclusivement les facteurs de la Base Carbone ADEME, garantissant la conformité des calculs avec les exigences de reporting français et européen. La Base Carbone ADEME recense plus de 5 000 facteurs d'émission couvrant les transports, l'énergie, l'alimentation et le bâtiment, avec une mise à jour annuelle.

3. Les 3 catégories : transport, énergie, alimentation

L'API HubActiva Carbon couvre trois catégories d'émissions : transport (voiture, TGV, avion, bus, vélo avec facteurs ADEME par mode), énergie (électricité par pays, gaz naturel, fuel, bois-énergie) et alimentation (bœuf, poulet, fromage, légumes en kg CO₂e/kg). Le secteur des transports représente 31 % des émissions de gaz à effet de serre en France selon l'ADEME (2023). La voiture électrique émet 91 % de moins que la voiture diesel en France, grâce au mix électrique nucléaire.

L'API HubActiva Carbon couvre trois grandes catégories d'émissions, correspondant aux principales sources mesurables pour les applications métier :

4. Calculer en Python avec l'API HubActiva Carbon

Le client Python pour l'API HubActiva Carbon utilise requests.Session et des dataclasses pour structurer les réponses. Les méthodes calculate_transport(), calculate_energy() et calculate_food() couvrent les trois catégories d'émissions. Chaque réponse inclut le résultat en kg CO₂e, le facteur d'émission utilisé, sa source (Base Carbone ADEME) et la description. Compatible Python 3.8+, Django, FastAPI.

Voici un client Python complet pour interroger l'API HubActiva Carbon, avec des exemples pour les trois catégories :

import requests
from dataclasses import dataclass
from typing import Optional


@dataclass
class CarbonResult:
    co2e_kg: float
    activity_value: float
    activity_unit: str
    emission_factor: float
    factor_source: str  # 'ADEME Base Carbone'
    category: str
    subcategory: str
    description: str


class HubActivaCarbonClient:
    BASE_URL = "https://hubactiva-carbon.p.rapidapi.com"
    
    def __init__(self, api_key: str):
        self.session = requests.Session()
        self.session.headers.update({
            "X-RapidAPI-Key": api_key,
            "X-RapidAPI-Host": "hubactiva-carbon.p.rapidapi.com",
            "Content-Type": "application/json"
        })

    def calculate_transport(
        self,
        mode: str,           # 'car_diesel', 'car_electric', 'tgv', 'plane', 'bus'
        distance_km: float,
        passengers: int = 1,
        country: str = "FR"
    ) -> CarbonResult:
        """Calcule les émissions CO₂e pour un trajet."""
        response = self.session.post(
            f"{self.BASE_URL}/transport",
            json={
                "mode": mode,
                "distance_km": distance_km,
                "passengers": passengers,
                "country": country
            },
            timeout=10
        )
        response.raise_for_status()
        return CarbonResult(**response.json())

    def calculate_energy(
        self,
        energy_type: str,    # 'electricity', 'gas', 'fuel', 'wood'
        quantity_kwh: float,
        country: str = "FR"
    ) -> CarbonResult:
        """Calcule les émissions CO₂e pour une consommation énergétique."""
        response = self.session.post(
            f"{self.BASE_URL}/energy",
            json={
                "energy_type": energy_type,
                "quantity_kwh": quantity_kwh,
                "country": country
            }
        )
        response.raise_for_status()
        return CarbonResult(**response.json())

    def calculate_food(
        self,
        food_type: str,      # 'beef', 'chicken', 'cheese', 'vegetables', etc.
        quantity_kg: float
    ) -> CarbonResult:
        """Calcule les émissions CO₂e pour une consommation alimentaire."""
        response = self.session.post(
            f"{self.BASE_URL}/food",
            json={
                "food_type": food_type,
                "quantity_kg": quantity_kg
            }
        )
        response.raise_for_status()
        return CarbonResult(**response.json())


# Exemple : calculer l'empreinte d'un déplacement professionnel
if __name__ == "__main__":
    client = HubActivaCarbonClient(api_key="votre_clé_rapidapi")
    
    trajets = [
        ("car_diesel", 400, "Paris-Lyon voiture"),
        ("tgv", 400, "Paris-Lyon TGV"),
        ("plane", 1740, "Paris-Barcelone avion"),
        ("car_electric", 400, "Paris-Lyon électrique"),
    ]
    
    print(f"{'Trajet':<25} {'CO₂e (kg)':>12} {'Facteur source'}")
    print("-" * 60)
    
    for mode, km, label in trajets:
        result = client.calculate_transport(mode=mode, distance_km=km)
        print(f"{label:<25} {result.co2e_kg:>10.2f}  {result.factor_source}")
    
    # Output :
    # Paris-Lyon voiture         87.20  ADEME Base Carbone v23.2
    # Paris-Lyon TGV              1.17  ADEME Base Carbone v23.2
    # Paris-Barcelone avion     448.92  ADEME Base Carbone v23.2
    # Paris-Lyon électrique       7.60  ADEME Base Carbone v23.2

5. Calculer en JavaScript

Le client JavaScript pour l'API Carbon HubActiva utilise une classe CarbonClient avec des méthodes transport(), energy() et food(). Les appels sont des requêtes fetch POST vers les endpoints /transport, /energy et /food. Aucune bibliothèque tierce n'est requise. Le client fonctionne dans le navigateur (ES2017+) et sous Node.js 18+ sans configuration supplémentaire.

Voici comment intégrer l'API Carbon dans une application JavaScript — frontend ou backend Node.js :

// Client Carbon HubActiva
class CarbonClient {
  constructor(apiKey) {
    this.apiKey = apiKey;
    this.baseUrl = 'https://hubactiva-carbon.p.rapidapi.com';
    this.headers = {
      'Content-Type': 'application/json',
      'X-RapidAPI-Key': apiKey,
      'X-RapidAPI-Host': 'hubactiva-carbon.p.rapidapi.com'
    };
  }

  async transport({ mode, distanceKm, passengers = 1, country = 'FR' }) {
    const res = await fetch(`${this.baseUrl}/transport`, {
      method: 'POST',
      headers: this.headers,
      body: JSON.stringify({ mode, distance_km: distanceKm, passengers, country })
    });
    if (!res.ok) throw new Error(`API error: ${res.status}`);
    return res.json();
  }

  async energy({ energyType, quantityKwh, country = 'FR' }) {
    const res = await fetch(`${this.baseUrl}/energy`, {
      method: 'POST',
      headers: this.headers,
      body: JSON.stringify({ energy_type: energyType, quantity_kwh: quantityKwh, country })
    });
    return res.json();
  }

  /** Calcul d'un trajet multi-segment (ex: voiture → train → avion) */
  async multiLeg(segments) {
    const results = await Promise.all(
      segments.map(seg => this.transport(seg))
    );
    const totalCo2e = results.reduce((sum, r) => sum + r.co2e_kg, 0);
    return {
      total_co2e_kg: Math.round(totalCo2e * 100) / 100,
      segments: results,
      equivalent_km_car: Math.round(totalCo2e / 0.218)
    };
  }
}

// Exemple : calculer l'empreinte d'un voyage professionnel Paris → NYC
const carbon = new CarbonClient('votre_clé_rapidapi');

// Vol Paris-New York (aller-retour)
carbon.transport({ mode: 'plane', distanceKm: 5831 * 2 })
  .then(result => {
    console.log(`Paris-NYC A/R : ${result.co2e_kg} kg CO₂e`);
    // → Paris-NYC A/R : 2274.12 kg CO₂e
    // Équivalent à 10 ans de TGV Paris-Lyon (225 km, hebdomadaire)
  });

// Calcul multi-segment : RER + TGV + taxi
carbon.multiLeg([
  { mode: 'rer', distanceKm: 30 },
  { mode: 'tgv', distanceKm: 750 },
  { mode: 'car_diesel', distanceKm: 15, passengers: 4 }
]).then(trip => {
  console.log(`Total trajet : ${trip.total_co2e_kg} kg CO₂e`);
  console.log(`Équivalent : ${trip.equivalent_km_car} km en voiture diesel`);
});

6. Cas d'usage : apps de voyage, logistique, dashboards ESG

L'API Carbon s'intègre dans trois types d'applications : les outils de réservation de voyage (affichage du CO₂e par option de transport), les plateformes logistiques (calcul de l'empreinte fret pour les rapports CSRD scope 3) et les dashboards ESG d'entreprise (agrégation des émissions par catégorie pour le bilan GES annuel). L'alimentation représente en moyenne 22 % de l'empreinte carbone d'un Français, soit environ 2,1 tonnes CO₂e par an.

Applications de voyage et booking

Les plateformes de réservation de voyages (trains, avions, hôtels) intègrent de plus en plus l'empreinte carbone directement dans l'interface de choix. Des acteurs comme Booking.com, Google Flights ou Trainline affichent le CO₂e estimé pour chaque option. Pour les développeurs, l'API Carbon permet d'ajouter cette fonctionnalité en quelques heures.

Cas d'usage typique :

• Afficher le CO₂e à côté du prix pour chaque option de transport
• Calculer l'empreinte d'un itinéraire complet (multi-segment)
• Proposer des alternatives moins carbonées ("Si vous prenez le train, vous émettez 74x moins")
• Permettre la compensation carbone en lien avec un partenaire (Gold Standard, Verra)

Plateformes logistiques et supply chain

Le transport de marchandises représente 7 % des émissions mondiales de GES. Les entreprises soumises à la CSRD doivent désormais calculer les émissions de leur Scope 3 (transports amont et aval). Pour les développeurs d'ERP, TMS (Transport Management System) ou plateformes e-commerce :

# Calcul d'empreinte carbone pour une expédition de marchandises
result = client.session.post(
    'https://hubactiva-carbon.p.rapidapi.com/freight',
    json={
        "mode": "truck_diesel",      # camion, train, bateau, avion
        "distance_km": 850,
        "weight_tonnes": 12.5,
        "full_load": False           # groupage ou chargement complet
    }
).json()

print(f"Expédition Paris-Marseille 12.5t : {result['co2e_kg']:.1f} kg CO₂e")
print(f"Facteur : {result['emission_factor']} kg CO₂e/(t·km)")
# → Expédition Paris-Marseille 12.5t : 892.5 kg CO₂e
# → Facteur : 0.0839 kg CO₂e/(t·km) [ADEME Base Carbone]

Dashboards ESG pour entreprises

Pour les DSI qui développent des tableaux de bord ESG internes, l'API Carbon s'intègre dans un pipeline de données qui agrège les sources d'émissions :

• Scope 1 (émissions directes) : consommation de gaz, fuel, véhicules de société
• Scope 2 (énergie achetée) : électricité, chaleur des bâtiments
• Scope 3 (émissions indirectes) : déplacements professionnels, transport de marchandises, achats fournisseurs

7. Accéder à l'API Carbon HubActiva

L'API HubActiva Carbon est disponible sur RapidAPI. Elle utilise exclusivement les facteurs d'émission de la Base Carbone ADEME (mise à jour annuelle), couvre les transports, l'énergie et l'alimentation, et retourne le facteur d'émission source avec chaque résultat pour la traçabilité des reportings ESG. Un plan gratuit de 300 calculs par mois est disponible.

L'API HubActiva Carbon est disponible sur RapidAPI. Elle offre :

• Facteurs d'émission basés sur la Base Carbone ADEME (mise à jour annuelle)
• Catégories : transport, énergie, alimentation, fret
• Support multi-pays pour l'électricité (facteurs par pays)
• Réponse JSON incluant le facteur d'émission et sa source pour la traçabilité
• Plan gratuit : 300 calculs/mois