Network Programming in .NET

https://www.immatriculationapi.com/

France operates one of Europe’s most sophisticated vehicle registration systems, covering over 38 million registered vehicles across its 101 departments. The French Vehicle Registration API provides developers and businesses with access to comprehensive vehicle specifications, technical data, and registration information for vehicles registered throughout metropolitan France and overseas territories.

Overview of French Vehicle Registration System

France’s vehicle registration system is managed by the Ministry of the Interior through the National Secure Registration System (SIV – Système d’Immatriculation des Véhicules). Since 2009, France has used a standardized license plate format that includes two letters, three numbers, and two letters (AA-123-AA), replacing the older regional system.

The centralized system maintains detailed technical specifications for all registered vehicles, including data from:

• ANTS (Agence Nationale des Titres Sécurisés) – National Agency for Secure Documents
• UTAC-CERAM – Technical services for automotive certification
• SRA (Sécurité et Réparation Automobiles) – Automotive security and repair classifications

French Vehicle API Features

The France endpoint provides comprehensive vehicle information including technical specifications and security classifications:

Available Data

When querying French vehicle registrations, you can retrieve:

• Make and Model – Complete manufacturer and vehicle model identification
• Registration Year – Year when the vehicle was first registered in France
• Engine Specifications – Engine size, fuel type, and power ratings
• Technical Details – Transmission type, body style, and variant information
• Registration Date – Exact date of first vehicle registration
• SRA Classifications – Security and theft risk classifications
• CNIT Code – French National Vehicle Identification Code
• K-Type ID – European vehicle type approval identifier
• Environmental Data – CO2 emissions and cylinder count

Sample Response Format

{
  "Description": "RENAULT SCÉNIC III",
  "RegistrationYear": "2016",
  "CarMake": {
    "CurrentTextValue": "RENAULT"
  },
  "CarModel": {
    "CurrentTextValue": "SCÉNIC III"
  },
  "EngineSize": {
    "CurrentTextValue": "5"
  },
  "FuelType": {
    "CurrentTextValue": "DIESEL"
  },
  "MakeDescription": {
    "CurrentTextValue": "RENAULT"
  },
  "ModelDescription": {
    "CurrentTextValue": "SCÉNIC III"
  },
  "BodyStyle": {
    "CurrentTextValue": "MONOSPACE COMPACT"
  },
  "RegistrationDate": "2016-06-24",
  "ExtendedData": {
    "anneeSortie": "2016",
    "boiteDeVitesse": "",
    "carburantVersion": "D",
    "libVersion": "1.5 dCi 1461cm3 110cv",
    "libelleModele": "SCÉNIC III",
    "marque": "RE",
    "puissance": "5",
    "nbPlace": "5",
    "datePremiereMiseCirculation": "24062016",
    "numSerieMoteur": "VF1JZ890H55864144",
    "puissanceDyn": "110",
    "KtypeId": "5853",
    "EngineCC": "1461",
    "Co2": "105",
    "Cylinders": "4",
    "CNIT": "M10RENVP472E768"
  }
}

API Implementation

Endpoint Usage

The French Vehicle API uses the /CheckFrance endpoint and requires two parameters:

1. Registration Number – The complete French license plate number
2. Username – Your API authentication credentials

Basic Implementation Example

// JavaScript example for French vehicle lookup
async function lookupFrenchVehicle(registrationNumber, username) {
  const apiUrl = `https://www.immatriculationapi.com/api/reg.asmx/CheckFrance?RegistrationNumber=${registrationNumber}&username=${username}`;
  
  try {
    const response = await fetch(apiUrl);
    const xmlText = await response.text();
    
    // Parse XML response
    const parser = new DOMParser();
    const xmlDoc = parser.parseFromString(xmlText, "text/xml");
    const jsonData = xmlDoc.getElementsByTagName("vehicleJson")[0].textContent;
    const vehicleInfo = JSON.parse(jsonData);
    
    return {
      make: vehicleInfo.MakeDescription.CurrentTextValue,
      model: vehicleInfo.ModelDescription.CurrentTextValue,
      year: vehicleInfo.RegistrationYear,
      engineSize: vehicleInfo.ExtendedData.EngineCC,
      power: vehicleInfo.ExtendedData.puissanceDyn,
      fuel: vehicleInfo.FuelType.CurrentTextValue,
      bodyStyle: vehicleInfo.BodyStyle.CurrentTextValue,
      registrationDate: vehicleInfo.RegistrationDate,
      co2: vehicleInfo.ExtendedData.Co2,
      cylinders: vehicleInfo.ExtendedData.Cylinders,
      vin: vehicleInfo.ExtendedData.numSerieMoteur,
      cnit: vehicleInfo.ExtendedData.CNIT
    };
  } catch (error) {
    console.error('French vehicle lookup failed:', error);
    return null;
  }
}

// Usage example
lookupFrenchVehicle("EG258MA", "your_username")
  .then(data => {
    if (data) {
      console.log(`Vehicle: ${data.make} ${data.model} (${data.year})`);
      console.log(`Engine: ${data.engineSize}cc, ${data.power}cv`);
      console.log(`Fuel: ${data.fuel}`);
      console.log(`CO2: ${data.co2}g/km`);
      console.log(`Registration: ${data.registrationDate}`);
    }
  });

Python Implementation

import requests
import xml.etree.ElementTree as ET
import json
from datetime import datetime

class FrenchVehicleAPI:
    def __init__(self, username):
        self.username = username
        self.base_url = "https://www.immatriculationapi.com/api/reg.asmx/CheckFrance"
    
    def validate_french_registration(self, registration):
        """Validate French registration number format"""
        if not registration:
            return False, "Registration number is required"
        
        # Remove spaces and convert to uppercase
        reg = registration.replace(" ", "").replace("-", "").upper()
        
        # Modern French format: 2 letters + 3 numbers + 2 letters
        # Old format validation could be added for historical plates
        if len(reg) < 6 or len(reg) > 9:
            return False, "Invalid registration length"
        
        return True, reg
    
    def lookup(self, registration_number):
        """Lookup French vehicle with comprehensive error handling"""
        # Validate registration format
        is_valid, processed_reg = self.validate_french_registration(registration_number)
        if not is_valid:
            return {"error": processed_reg}
        
        try:
            params = {
                'RegistrationNumber': processed_reg,
                'username': self.username
            }
            
            response = requests.get(self.base_url, params=params, timeout=15)
            response.raise_for_status()
            
            # Parse XML response
            root = ET.fromstring(response.content)
            json_element = root.find('.//vehicleJson')
            
            if json_element is None or not json_element.text:
                return {"error": "No vehicle data found for this registration number"}
            
            vehicle_data = json.loads(json_element.text)
            extended_data = vehicle_data.get('ExtendedData', {})
            
            # Process and structure the response
            return {
                'success': True,
                'description': vehicle_data.get('Description'),
                'make': vehicle_data.get('MakeDescription', {}).get('CurrentTextValue'),
                'model': vehicle_data.get('ModelDescription', {}).get('CurrentTextValue'),
                'registration_year': vehicle_data.get('RegistrationYear'),
                'body_style': vehicle_data.get('BodyStyle', {}).get('CurrentTextValue'),
                'fuel_type': vehicle_data.get('FuelType', {}).get('CurrentTextValue'),
                'registration_date': vehicle_data.get('RegistrationDate'),
                'engine_cc': extended_data.get('EngineCC'),
                'power_cv': extended_data.get('puissanceDyn'),
                'co2_emissions': extended_data.get('Co2'),
                'cylinders': extended_data.get('Cylinders'),
                'vin': extended_data.get('numSerieMoteur'),
                'cnit': extended_data.get('CNIT'),
                'ktype_id': extended_data.get('KtypeId'),
                'seats': extended_data.get('nbPlace'),
                'make_code': extended_data.get('marque'),
                'fuel_version': extended_data.get('carburantVersion'),
                'version_details': extended_data.get('libVersion'),
                'manufacture_year': extended_data.get('anneeSortie'),
                'first_registration': extended_data.get('datePremiereMiseCirculation'),
                'raw_data': vehicle_data
            }
            
        except requests.Timeout:
            return {"error": "Request timed out - please try again"}
        except requests.RequestException as e:
            return {"error": f"Network error: {str(e)}"}
        except ET.ParseError:
            return {"error": "Invalid response format from API"}
        except json.JSONDecodeError:
            return {"error": "Could not parse vehicle data"}
        except Exception as e:
            return {"error": f"Unexpected error: {str(e)}"}

# Usage example
api = FrenchVehicleAPI("your_username")
result = api.lookup("EG258MA")

if result.get('success'):
    print(f"Vehicle: {result['make']} {result['model']}")
    print(f"Year: {result['registration_year']}")
    print(f"Engine: {result['engine_cc']}cc, {result['power_cv']}cv")
    print(f"Fuel: {result['fuel_type']} (Code: {result['fuel_version']})")
    print(f"CO2 Emissions: {result['co2_emissions']}g/km")
    print(f"Body Style: {result['body_style']}")
    print(f"VIN: {result['vin']}")
    print(f"CNIT: {result['cnit']}")
else:
    print(f"Error: {result['error']}")

French Registration Number Formats

Modern Format (2009-Present)

The current French registration system uses the format: XX-123-XX

• First two letters: Random sequence (not location-based)
• Three numbers: Sequential from 001 to 999
• Last two letters: Department identifier or random

Historical Formats (1950-2009)

Older French vehicles may have regional formats:

• 123 XX 75 – Numbers, letters, department code
• Regional variations with different structures

Special Plates

• Diplomatic vehicles – Special CD (Corps Diplomatique) plates
• Temporary plates – TT format for transit
• Military vehicles – Special military identification

Understanding French Vehicle Data

Extended Data Fields Explained

The French API provides rich extended data with specific French terminology:

Technical Specifications:

• anneeSortie – Year of first manufacture
• boiteDeVitesse – Transmission type
• carburantVersion – Fuel type code (D=Diesel, E=Petrol, etc.)
• puissance – Administrative power (chevaux fiscaux)
• puissanceDyn – Dynamic power (chevaux vapeur/CV)
• EngineCC – Engine displacement in cubic centimeters
• Cylinders – Number of cylinders
• Co2 – CO2 emissions in g/km

Identification Codes:

• CNIT – Code National d’Identification du Type (National Type Identification Code)
• KtypeId – European K-Type identification number
• marque – Manufacturer code (RE=Renault, PE=Peugeot, etc.)
• numSerieMoteur – VIN (Vehicle Identification Number)

Registration Information:

• datePremiereMiseCirculation – Date of first registration in format DDMMYYYY
• nbPlace – Number of seats
• libVersion – Detailed version description with engine specs

Fuel Type Classifications

• ESSENCE – Petrol/Gasoline
• DIESEL – Diesel fuel
• ELECTRIQUE – Electric vehicle
• HYBRIDE – Hybrid vehicle
• GPL – Liquefied Petroleum Gas
• GNV – Compressed Natural Gas

French Motorcycle Support

For motorcycles registered in France, use the dedicated motorcycle endpoint: https://www.immatriculationapi.com/api/bespokeapi.asmx?op=CheckMotorBikeFrance

This returns motorcycle-specific data including:

• Engine specifications optimized for motorcycles
• Motorcycle-specific body classifications
• Power ratings appropriate for two-wheeled vehicles

Use Cases for French Vehicle API

Insurance Industry

• Premium Calculations – CO2 emissions and power ratings for environmental taxes
• Claims Processing – VIN verification and technical specifications
• Fraud Prevention – Cross-reference CNIT codes and registration dates
• Fleet Insurance – Bulk vehicle verification for commercial policies

Automotive Industry

• Dealership Operations – Verify vehicle history and specifications
• Parts and Service – CNIT and K-Type codes for parts compatibility
• Import/Export – Technical compliance verification
• Vehicle Valuations – Detailed specifications for pricing models

Fleet Management

• Environmental Compliance – CO2 emissions tracking for corporate reporting
• Maintenance Scheduling – Engine specifications and service requirements
• Fuel Management – Fuel type verification for fleet optimization
• Asset Tracking – Comprehensive vehicle identification

Government and Regulatory

• Environmental Monitoring – Emissions data for pollution control
• Tax Administration – Vehicle specifications for taxation purposes
• Import Control – Technical verification for customs procedures
• Traffic Management – Vehicle classification for access restrictions

Mobile Applications

• Parking Apps – Vehicle identification and permit validation
• Insurance Apps – Instant vehicle data for quote generation
• Service Booking – Technical specs for maintenance appointments
• Car Sharing – Vehicle verification and specification display

French Automotive Market Context

Major French Manufacturers

France is home to several global automotive manufacturers:

Groupe PSA (Stellantis):

• Peugeot – Founded 1810, known for innovative design and diesel technology
• Citroën – Renowned for comfort and hydraulic suspension systems
• DS Automobiles – Premium brand focusing on luxury and French craftsmanship

Renault Group:

• Renault – Major European manufacturer with strong EV presence
• Alpine – Sports car manufacturer
• Dacia – Value brand with simple, reliable vehicles

Specialized Manufacturers:

• Bugatti – Ultra-luxury hypercars
• Venturi – Electric vehicle specialist

French Vehicle Classification System

Administrative Power (Chevaux Fiscaux): France uses a unique administrative power system for taxation:

• Calculated based on CO2 emissions and engine power
• Used for registration taxes and annual road tax
• Ranges typically from 3CV to 20CV+ for standard vehicles

Body Style Classifications:

• BERLINE – Sedan
• BREAK – Station wagon
• MONOSPACE – MPV/Minivan
• COUPÉ – Coupe
• CABRIOLET – Convertible
• COMBISPACE – Compact MPV

Error Handling and Best Practices

class FrenchVehicleLookup {
  constructor(username) {
    this.username = username;
    this.apiUrl = "https://www.immatriculationapi.com/api/reg.asmx/CheckFrance";
  }
  
  async lookupWithRetry(registration, maxRetries = 3) {
    let lastError;
    
    for (let attempt = 1; attempt <= maxRetries; attempt++) {
      try {
        const result = await this.lookup(registration);
        
        if (result && !result.error) {
          return result;
        }
        
        lastError = result?.error || "Unknown error";
        
        // Wait before retry (exponential backoff)
        if (attempt < maxRetries) {
          await new Promise(resolve => setTimeout(resolve, 1000 * attempt));
        }
        
      } catch (error) {
        lastError = error.message;
        
        if (attempt < maxRetries) {
          await new Promise(resolve => setTimeout(resolve, 1000 * attempt));
        }
      }
    }
    
    return {
      error: true,
      message: `Failed after ${maxRetries} attempts: ${lastError}`,
      registration: registration
    };
  }
  
  async lookup(registration) {
    // Validate and clean registration
    const cleanReg = this.cleanRegistration(registration);
    if (!cleanReg) {
      throw new Error("Invalid registration format");
    }
    
    const response = await fetch(`${this.apiUrl}?RegistrationNumber=${cleanReg}&username=${this.username}`);
    
    if (!response.ok) {
      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
    }
    
    // Process response...
    return this.parseResponse(await response.text());
  }
  
  cleanRegistration(registration) {
    if (!registration) return null;
    
    // Remove spaces, hyphens, and convert to uppercase
    const cleaned = registration.replace(/[\s\-]/g, '').toUpperCase();
    
    // Basic validation
    if (cleaned.length < 6 || cleaned.length > 9) {
      return null;
    }
    
    return cleaned;
  }
}

Data Privacy and Compliance

GDPR Compliance

As an EU member state, France follows strict data protection regulations:

• Vehicle technical data is not considered personal information
• VIN numbers are vehicle identifiers, not personal data
• Implement appropriate data retention policies
• Ensure proper access controls and audit trails

Usage Guidelines

• API intended for legitimate business and technical purposes
• Respect rate limits to maintain service quality
• Implement proper caching to reduce unnecessary requests
• Follow French data protection guidelines for automotive data

Getting Started

Account Registration

1. Sign Up – Register for API access through the French vehicle API portal
2. Verification – Complete email and business verification process
3. Testing – Use sample registration “EG258MA” for development
4. Production – Purchase credits and configure production environment

Sample Data for Testing

• EG258MA – Renault Scénic III (sample from documentation)
• Test various registration formats to understand response variations
• Verify error handling with invalid registrations

Integration Planning

• Plan for French-specific data fields in your application
• Consider CO2 emissions display for environmental compliance
• Implement proper error handling for network timeouts
• Design UI to accommodate French technical terminology

Conclusion

The French Vehicle Registration API provides comprehensive access to France’s sophisticated vehicle database, offering detailed technical specifications, environmental data, and regulatory compliance information. The system’s integration of SRA classifications, CNIT codes, and detailed emissions data makes it particularly valuable for insurance, fleet management, and environmental compliance applications.

France’s centralized registration system ensures consistent data quality while the API’s rich extended data provides all necessary information for professional automotive applications. Understanding French vehicle classifications, administrative power calculations, and technical specifications enhances the effectiveness of API integration.

The system’s compliance with EU regulations and focus on environmental data positions it well for modern automotive applications requiring detailed vehicle specifications and emissions information.

Begin integrating French vehicle data by registering for API access and exploring the comprehensive database of French vehicle registrations across all departments and territories.

https://www.immatriculationapi.com/