Home > Uncategorized > Italian Vehicle Registration API: Complete Guide to Vehicle Data Lookup in Italy

Italian Vehicle Registration API: Complete Guide to Vehicle Data Lookup in Italy

September 16, 2025 Leave a comment Go to comments

https://www.targa.co.it/

Italy operates a sophisticated vehicle registration system managed by the Ministry of Transport, covering over 39 million registered vehicles across the country’s 20 regions. The Italian Vehicle Registration API provides developers and businesses with access to comprehensive vehicle specifications, technical data, and insurance information for vehicles registered throughout Italy, from the industrial north to the southern regions.

Overview of Italian Vehicle Registration System

Italy’s vehicle registration system is centralized under the Motorizzazione Civile (Department of Motor Vehicles) and integrated with the PRA (Pubblico Registro Automobilistico – Public Automotive Registry). The system maintains detailed records for all vehicle types, from traditional cars to motorcycles, providing standardized identification across all Italian provinces.

The Italian license plate system has evolved over time:

  • Current format (1994-present): Two letters + three numbers + two letters (AB 123 CD)
  • Regional identification: Letters indicate the province of registration
  • Special formats: Diplomatic, military, and temporary plates with distinct patterns

Italian Vehicle API Features

The Italy endpoint provides comprehensive vehicle information with focus on technical specifications and power ratings:

Available Data for Cars

When querying Italian car registrations, you can retrieve:

  • Make and Model – Complete manufacturer and vehicle model identification
  • Registration Year – Year when the vehicle was first registered in Italy
  • Engine Specifications – Engine displacement and detailed power ratings
  • Fuel Type – Fuel classification (Diesel, Benzina/Petrol, GPL, Metano, Electric)
  • Technical Details – Version information, number of doors, ABS and airbag status
  • Power Ratings – Multiple power measurements (CV, KW, Fiscal Power)
  • VIN Number – Vehicle Identification Number when available
  • K-Type Code – European vehicle type approval identifier

Sample Car Response Format

{
  "Description": "MINI Mini 2.0 Cooper SD Countryman ALL4 Automatica",
  "RegistrationYear": "2017",
  "CarMake": {
    "CurrentTextValue": "MINI"
  },
  "CarModel": {
    "CurrentTextValue": "Mini Countryman F60"
  },
  "EngineSize": {
    "CurrentTextValue": "2.0"
  },
  "FuelType": {
    "CurrentTextValue": "Diesel"
  },
  "MakeDescription": {
    "CurrentTextValue": "MINI"
  },
  "ModelDescription": {
    "CurrentTextValue": "Mini Countryman F60"
  },
  "NumberOfDoors": "5",
  "Version": "Mini 2.0 Cooper SD Countryman ALL4 Automatica",
  "ABS": "",
  "AirBag": "",
  "Vin": "",
  "KType": "",
  "PowerCV": "190",
  "PowerKW": "140",
  "PowerFiscal": "20"
}

Motorcycle Support

Italy also provides dedicated motorcycle data through the CheckItalyMotorbike endpoint:

{
  "Description": "Ducati Monster 600 25KW - 34 CV",
  "RegistrationYear": "1999",
  "CarMake": {
    "CurrentTextValue": "Ducati"
  },
  "CarModel": {
    "CurrentTextValue": "Monster 600"
  },
  "MakeDescription": {
    "CurrentTextValue": "Ducati"
  },
  "ModelDescription": {
    "CurrentTextValue": "Monster 600"
  },
  "Version": "25KW - 34 CV"
}

Insurance Information Support

The Italian system also provides access to current insurance information through the CheckInsuranceStatusItaly endpoint:

<InsuranceDetails>
  <Company>IPTIQ EMEA P&C SA</Company>
  <Expiry>2025-01-23T00:00:00</Expiry>
  <IsInsured>true</IsInsured>
  <Region>VE</Region>
</InsuranceDetails>

API Implementation

Endpoint Usage

The Italian Vehicle API uses multiple endpoints:

  1. Cars: /CheckItaly – For passenger vehicles and commercial vehicles
  2. Motorcycles: /CheckItalyMotorbike – For motorcycles and scooters
  3. Insurance: /CheckInsuranceStatusItaly – For insurance verification

All endpoints require:

  • Registration Number – The complete Italian license plate number
  • Username – Your API authentication credentials

Basic Implementation Example

// JavaScript example for Italian vehicle lookup
class ItalianVehicleAPI {
  constructor(username) {
    this.username = username;
    this.baseUrl = "https://www.targa.co.it/api/bespokeapi.asmx";
  }
  
  async lookupCar(registrationNumber) {
    const apiUrl = `${this.baseUrl}/CheckItaly?RegistrationNumber=${registrationNumber}&username=${this.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.EngineSize.CurrentTextValue,
        fuel: vehicleInfo.FuelType.CurrentTextValue,
        powerCV: vehicleInfo.PowerCV,
        powerKW: vehicleInfo.PowerKW,
        powerFiscal: vehicleInfo.PowerFiscal,
        doors: vehicleInfo.NumberOfDoors,
        version: vehicleInfo.Version,
        vin: vehicleInfo.Vin,
        kType: vehicleInfo.KType
      };
    } catch (error) {
      console.error('Italian car lookup failed:', error);
      return null;
    }
  }
  
  async lookupMotorcycle(registrationNumber) {
    const apiUrl = `${this.baseUrl}/CheckItalyMotorbike?RegistrationNumber=${registrationNumber}&username=${this.username}`;
    
    try {
      const response = await fetch(apiUrl);
      const jsonData = await response.json();
      
      return {
        make: jsonData.MakeDescription.CurrentTextValue,
        model: jsonData.ModelDescription.CurrentTextValue,
        year: jsonData.RegistrationYear,
        version: jsonData.Version
      };
    } catch (error) {
      console.error('Italian motorcycle lookup failed:', error);
      return null;
    }
  }
  
  async checkInsurance(registrationNumber) {
    const apiUrl = `${this.baseUrl}/CheckInsuranceStatusItaly?RegistrationNumber=${registrationNumber}&username=${this.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 company = xmlDoc.getElementsByTagName("Company")[0]?.textContent;
      const expiry = xmlDoc.getElementsByTagName("Expiry")[0]?.textContent;
      const isInsured = xmlDoc.getElementsByTagName("IsInsured")[0]?.textContent === "true";
      const region = xmlDoc.getElementsByTagName("Region")[0]?.textContent;
      
      return {
        company,
        expiry,
        isInsured,
        region
      };
    } catch (error) {
      console.error('Italian insurance lookup failed:', error);
      return null;
    }
  }
}

// Usage examples
const api = new ItalianVehicleAPI("your_username");

// Car lookup
api.lookupCar("BN071VN").then(data => {
  if (data) {
    console.log(`Car: ${data.make} ${data.model} (${data.year})`);
    console.log(`Engine: ${data.engineSize}L ${data.fuel}`);
    console.log(`Power: ${data.powerCV}CV / ${data.powerKW}KW`);
  }
});

// Motorcycle lookup
api.lookupMotorcycle("AA123BB").then(data => {
  if (data) {
    console.log(`Motorcycle: ${data.make} ${data.model} (${data.year})`);
    console.log(`Version: ${data.version}`);
  }
});

// Insurance check
api.checkInsurance("BN071VN").then(data => {
  if (data) {
    console.log(`Insurance: ${data.company}`);
    console.log(`Expiry: ${data.expiry}`);
    console.log(`Status: ${data.isInsured ? 'Insured' : 'Not insured'}`);
  }
});

Python Implementation

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

class ItalianVehicleAPI:
    def __init__(self, username):
        self.username = username
        self.base_url = "https://www.targa.co.it/api/bespokeapi.asmx"
    
    def validate_italian_registration(self, registration):
        """Validate Italian registration number format"""
        if not registration:
            return False, "Registration number is required"
        
        # Remove spaces and convert to uppercase
        reg = registration.replace(" ", "").upper()
        
        # Basic Italian format validation
        if len(reg) < 6 or len(reg) > 7:
            return False, "Invalid registration length"
        
        return True, reg
    
    def lookup_car(self, registration_number):
        """Lookup Italian car with comprehensive error handling"""
        is_valid, processed_reg = self.validate_italian_registration(registration_number)
        if not is_valid:
            return {"error": processed_reg}
        
        try:
            url = f"{self.base_url}/CheckItaly"
            params = {
                'RegistrationNumber': processed_reg,
                'username': self.username
            }
            
            response = requests.get(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 car data found for this registration number"}
            
            vehicle_data = json.loads(json_element.text)
            
            return {
                'success': True,
                'type': 'car',
                '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'),
                'engine_size': vehicle_data.get('EngineSize', {}).get('CurrentTextValue'),
                'fuel_type': vehicle_data.get('FuelType', {}).get('CurrentTextValue'),
                'power_cv': vehicle_data.get('PowerCV'),
                'power_kw': vehicle_data.get('PowerKW'),
                'power_fiscal': vehicle_data.get('PowerFiscal'),
                'doors': vehicle_data.get('NumberOfDoors'),
                'version': vehicle_data.get('Version'),
                'vin': vehicle_data.get('Vin'),
                'k_type': vehicle_data.get('KType'),
                'abs': vehicle_data.get('ABS'),
                'airbag': vehicle_data.get('AirBag'),
                'raw_data': vehicle_data
            }
            
        except Exception as e:
            return {"error": f"Car lookup failed: {str(e)}"}
    
    def lookup_motorcycle(self, registration_number):
        """Lookup Italian motorcycle"""
        is_valid, processed_reg = self.validate_italian_registration(registration_number)
        if not is_valid:
            return {"error": processed_reg}
        
        try:
            url = f"{self.base_url}/CheckItalyMotorbike"
            params = {
                'RegistrationNumber': processed_reg,
                'username': self.username
            }
            
            response = requests.get(url, params=params, timeout=15)
            response.raise_for_status()
            
            motorcycle_data = response.json()
            
            return {
                'success': True,
                'type': 'motorcycle',
                'description': motorcycle_data.get('Description'),
                'make': motorcycle_data.get('MakeDescription', {}).get('CurrentTextValue'),
                'model': motorcycle_data.get('ModelDescription', {}).get('CurrentTextValue'),
                'registration_year': motorcycle_data.get('RegistrationYear'),
                'version': motorcycle_data.get('Version'),
                'raw_data': motorcycle_data
            }
            
        except Exception as e:
            return {"error": f"Motorcycle lookup failed: {str(e)}"}
    
    def check_insurance(self, registration_number):
        """Check Italian vehicle insurance status"""
        is_valid, processed_reg = self.validate_italian_registration(registration_number)
        if not is_valid:
            return {"error": processed_reg}
        
        try:
            url = f"{self.base_url}/CheckInsuranceStatusItaly"
            params = {
                'RegistrationNumber': processed_reg,
                'username': self.username
            }
            
            response = requests.get(url, params=params, timeout=15)
            response.raise_for_status()
            
            # Parse XML response
            root = ET.fromstring(response.content)
            
            company = root.find('.//Company')
            expiry = root.find('.//Expiry')
            is_insured = root.find('.//IsInsured')
            region = root.find('.//Region')
            
            return {
                'success': True,
                'company': company.text if company is not None else None,
                'expiry': expiry.text if expiry is not None else None,
                'is_insured': is_insured.text == 'true' if is_insured is not None else False,
                'region': region.text if region is not None else None
            }
            
        except Exception as e:
            return {"error": f"Insurance check failed: {str(e)}"}

# Usage examples
api = ItalianVehicleAPI("your_username")

# Car lookup
car_result = api.lookup_car("BN071VN")
if car_result.get('success'):
    print(f"Car: {car_result['make']} {car_result['model']}")
    print(f"Year: {car_result['registration_year']}")
    print(f"Engine: {car_result['engine_size']}L {car_result['fuel_type']}")
    print(f"Power: {car_result['power_cv']}CV / {car_result['power_kw']}KW")
    print(f"Doors: {car_result['doors']}")
    print(f"Version: {car_result['version']}")

# Motorcycle lookup
bike_result = api.lookup_motorcycle("AA123BB")
if bike_result.get('success'):
    print(f"Motorcycle: {bike_result['make']} {bike_result['model']}")
    print(f"Version: {bike_result['version']}")

# Insurance check
insurance_result = api.check_insurance("BN071VN")
if insurance_result.get('success'):
    print(f"Insurance Company: {insurance_result['company']}")
    print(f"Expiry: {insurance_result['expiry']}")
    print(f"Status: {'Insured' if insurance_result['is_insured'] else 'Not insured'}")
    print(f"Region: {insurance_result['region']}")

Italian Vehicle Registration Format

Current Format (1994-Present)

Italian license plates use the format: AA 123 BB

  • First two letters: Province of registration
  • Three numbers: Sequential numbering
  • Last two letters: Progressive alphabetical sequence

Provincial Codes

Italy’s 107 provinces each have specific letter combinations:

Major Cities:

  • MI – Milano (Milan)
  • RM – Roma (Rome)
  • TO – Torino (Turin)
  • NA – Napoli (Naples)
  • PA – Palermo
  • GE – Genova (Genoa)
  • BO – Bologna
  • FI – Firenze (Florence)
  • BA – Bari
  • CT – Catania

Northern Regions:

  • BG – Bergamo, BS – Brescia, CO – Como, CR – Cremona
  • MN – Mantova, PV – Pavia, SO – Sondrio, VA – Varese

Central Regions:

  • AN – Ancona, AR – Arezzo, FR – Frosinone, LT – Latina
  • PE – Pescara, PG – Perugia, PI – Pisa, SI – Siena

Southern Regions:

  • AV – Avellino, BN – Benevento, CE – Caserta, SA – Salerno
  • CZ – Catanzaro, RC – Reggio Calabria, AG – Agrigento

Understanding Italian Vehicle Data

Power Ratings Explained

Italian vehicle data includes multiple power measurements:

  • PowerCV – Cavalli Vapore (Steam Horsepower) – Traditional Italian power measurement
  • PowerKW – Kilowatts – Standard European power measurement
  • PowerFiscal – Fiscal horsepower for taxation and insurance purposes

Fuel Type Classifications

  • Benzina – Petrol/Gasoline
  • Diesel – Diesel fuel
  • GPL – Liquefied Petroleum Gas (Autogas)
  • Metano – Compressed Natural Gas (CNG)
  • Elettrica – Electric vehicle
  • Ibrida – Hybrid vehicle

Safety Features

  • ABS – Anti-lock Braking System status
  • AirBag – Airbag system information
  • Additional safety features when available in database

Use Cases for Italian Vehicle API

Insurance Industry

  • Premium Calculations – Multiple power ratings for accurate risk assessment
  • Claims Processing – Verify vehicle specifications and safety features
  • Insurance Verification – Real-time insurance status checking
  • Fraud Prevention – Cross-reference vehicle data with insurance records

Automotive Industry

  • Dealership Operations – Verify trade-in vehicle specifications
  • Parts and Service – K-Type codes for parts compatibility
  • Vehicle History – Registration and technical verification
  • Import/Export – Compliance verification for international trade

Fleet Management

  • Asset Tracking – Comprehensive vehicle identification and specs
  • Insurance Management – Monitor insurance status across fleet
  • Maintenance Scheduling – Engine specifications for service planning
  • Compliance Monitoring – Ensure all fleet vehicles are properly insured

Law Enforcement

  • Vehicle Identification – Quick lookups during traffic stops
  • Insurance Verification – Instant insurance status checking
  • Investigation Support – Vehicle history and ownership verification
  • Motorcycle Tracking – Dedicated motorcycle identification system

Mobile Applications

  • Insurance Apps – Instant vehicle data and insurance verification
  • Service Booking – Technical specifications for maintenance
  • Parking Apps – Vehicle verification and permit validation
  • Car Sharing – Vehicle identification and specification display

Italian Automotive Market Context

Major Italian Manufacturers

Fiat Chrysler Automobiles (Stellantis):

  • Fiat – Italy’s largest automaker, known for compact cars
  • Alfa Romeo – Premium sports and luxury vehicles
  • Lancia – Luxury and performance vehicles
  • Maserati – Luxury sports cars and sedans
  • Ferrari – World-renowned supercars and racing vehicles

Motorcycle Manufacturers:

  • Ducati – High-performance motorcycles
  • Aprilia – Sports and racing motorcycles
  • Moto Guzzi – Traditional Italian motorcycles
  • Benelli – Classic and modern motorcycle designs

Regional Variations

Italy’s diverse geography creates distinct automotive preferences:

Northern Italy: Higher concentration of luxury vehicles and motorcycles Central Italy: Mix of urban compact cars and touring vehicles Southern Italy: Focus on fuel-efficient and practical vehicles Islands (Sicily, Sardinia): Preference for small, maneuverable vehicles

Error Handling and Best Practices

class RobustItalianVehicleAPI extends ItalianVehicleAPI {
  async lookupWithFallback(registrationNumber) {
    let result;
    
    // Try car lookup first
    result = await this.lookupCar(registrationNumber);
    if (result && result.success) {
      return result;
    }
    
    // If car lookup fails, try motorcycle
    result = await this.lookupMotorcycle(registrationNumber);
    if (result && result.success) {
      return result;
    }
    
    return {
      error: true,
      message: "Vehicle not found in car or motorcycle databases",
      registration: registrationNumber
    };
  }
  
  async getCompleteVehicleInfo(registrationNumber) {
    const vehicleInfo = await this.lookupWithFallback(registrationNumber);
    
    if (vehicleInfo.error) {
      return vehicleInfo;
    }
    
    // Add insurance information if vehicle lookup successful
    const insuranceInfo = await this.checkInsurance(registrationNumber);
    
    return {
      ...vehicleInfo,
      insurance: insuranceInfo
    };
  }
}

Data Privacy and Insurance Verification

GDPR Compliance

Italy follows EU data protection regulations:

  • Vehicle technical data is not personal information
  • Insurance verification provides business-relevant data only
  • Implement appropriate data retention and access controls
  • Follow Italian privacy guidelines for automotive data usage

Insurance Verification Benefits

The Italian system’s insurance integration provides unique advantages:

  • Real-time insurance status verification
  • Insurance company identification
  • Coverage expiry date tracking
  • Regional insurance information

Getting Started

Account Registration

  1. Registration – Sign up for Italian vehicle API access
  2. Verification – Complete business verification process
  3. Testing – Use sample registration “BN071VN” for development
  4. Production – Configure endpoints for cars, motorcycles, and insurance

Sample Data for Testing

  • Cars: BN071VN (MINI Countryman from documentation)
  • Motorcycles: Test with various Italian motorcycle registrations
  • Insurance: Verify insurance data integration with sample plates

Integration Planning

  • Determine if your application needs car, motorcycle, or both endpoints
  • Plan for Italian power rating displays (CV, KW, Fiscal)
  • Implement insurance verification workflows
  • Design UI for Italian provincial identification

Conclusion

The Italian Vehicle Registration API provides comprehensive access to Italy’s sophisticated vehicle database, offering detailed technical specifications, multiple power ratings, and integrated insurance verification. The system’s support for both cars and motorcycles, combined with real-time insurance status checking, makes it particularly valuable for insurance companies, fleet managers, and automotive businesses operating in the Italian market.

Italy’s rich automotive heritage and diverse vehicle landscape create unique data requirements that the API addresses through detailed power measurements, safety feature tracking, and provincial identification systems. The integration of insurance verification adds significant value for compliance and business applications.

Understanding Italian vehicle classifications, power rating systems, and regional variations enhances the effectiveness of API integration while supporting the diverse needs of Italy’s automotive ecosystem.

Begin accessing Italian vehicle data by registering for API credentials and exploring the comprehensive database covering cars, motorcycles, and insurance information across all Italian provinces.

https://www.targa.co.it/

Categories: Uncategorized
  1. No comments yet.
  1. No trackbacks yet.

Leave a comment