Network Programming in .NET

TLDR: https://www.inmatriculareapi.ro/
Romania, as a member of the European Union since 2007, maintains a modern vehicle registration system that provides comprehensive vehicle information through digital databases. The Romanian Vehicle Registration API offers developers and businesses access to detailed vehicle specifications, ownership documents, and technical data for vehicles registered throughout Romania’s 42 counties.

Overview of Romanian Vehicle Registration System

Romania’s vehicle registration system is centralized under the Romanian National Agency for Fiscal Administration (ANAF) and the Romanian Automobile Registry (RAR). The system covers all Romanian counties from Bucharest (București) to the smallest rural regions, providing standardized vehicle identification and technical specifications.

The Romanian license plate format typically consists of:

• County Code – 1-2 letters identifying the county of registration
• Numbers – Sequential numerical identifier
• Letters – Additional letter combinations

Romanian Vehicle API Features

The Romania endpoint provides comprehensive vehicle information including:

Available Data

When querying Romanian vehicle registrations, you can retrieve:

• Make and Model – Complete manufacturer and vehicle model information
• Registration Year – Year when the vehicle was first registered
• Engine Specifications – Engine size in cubic centimeters and power in kilowatts
• Fuel Type – Fuel classification (benzina/petrol, motorina/diesel, GPL/LPG, electric)
• VIN Number – Complete 17-character Vehicle Identification Number
• CIV Document – Vehicle Identity Document (Cartea de Identitate a Vehiculului)
• Vehicle Type – Classification (Autoturism/passenger car, Autoutilitară/utility vehicle, etc.)
• Technical Specifications – Weight, number of seats, variant information
• Registration Region – County or city where the vehicle is registered
• Representative Image – Visual identification of the vehicle type

Sample Response Format

{
  "Description": "Renault Clio",
  "RegistrationYear": "1999",
  "CarMake": {
    "CurrentTextValue": "Renault"
  },
  "CarModel": {
    "CurrentTextValue": "Clio"
  },
  "MakeDescription": {
    "CurrentTextValue": "Renault"
  },
  "ModelDescription": {
    "CurrentTextValue": "Clio"
  },
  "Type": "Autoturism",
  "VIN": "VF1CB0A0F20507251",
  "CIV": "J350228",
  "Variant": "",
  "Weight": "955",
  "FuelType": "benzina",
  "NumberOfSeats": "5",
  "Power": "43",
  "EngineSize": "1149",
  "Region": "București",
  "ImageUrl": "http://www.inmatriculareapi.ro/image.aspx/@UmVuYXVsdCBDbGlv"
}

API Implementation

Endpoint Usage

The Romanian Vehicle API uses the /CheckRomania endpoint and requires two parameters:

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

Basic Implementation Example

// JavaScript example for Romanian vehicle lookup
async function lookupRomanianVehicle(registrationNumber, username) {
  const apiUrl = `https://www.inmatriculareapi.ro/api/reg.asmx/CheckRomania?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.EngineSize,
      power: vehicleInfo.Power,
      fuel: vehicleInfo.FuelType,
      vin: vehicleInfo.VIN,
      civ: vehicleInfo.CIV,
      region: vehicleInfo.Region,
      weight: vehicleInfo.Weight,
      seats: vehicleInfo.NumberOfSeats,
      type: vehicleInfo.Type
    };
  } catch (error) {
    console.error('Romanian vehicle lookup failed:', error);
    return null;
  }
}

// Usage example
lookupRomanianVehicle("B123ABC", "your_username")
  .then(data => {
    if (data) {
      console.log(`Vehicle: ${data.make} ${data.model} (${data.year})`);
      console.log(`Engine: ${data.engineSize}cc, ${data.power}kW`);
      console.log(`Fuel: ${data.fuel}`);
      console.log(`CIV: ${data.civ}`);
      console.log(`Region: ${data.region}`);
    }
  });

Python Implementation

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

class RomanianVehicleAPI:
    def __init__(self, username):
        self.username = username
        self.base_url = "https://www.inmatriculareapi.ro/api/reg.asmx/CheckRomania"
    
    def validate_registration_format(self, registration):
        """Validate Romanian registration number format"""
        if not registration or len(registration.strip()) < 6:
            return False, "Registration number too short"
        
        # Remove spaces and convert to uppercase
        reg = registration.replace(" ", "").upper()
        
        # Basic format validation (letters + numbers + letters)
        if not any(c.isalpha() for c in reg) or not any(c.isdigit() for c in reg):
            return False, "Invalid format - must contain both letters and numbers"
        
        return True, reg
    
    def lookup(self, registration_number):
        """Lookup Romanian vehicle with comprehensive error handling"""
        # Validate registration format
        is_valid, processed_reg = self.validate_registration_format(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)
            
            # 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'),
                'vehicle_type': vehicle_data.get('Type'),
                'vin': vehicle_data.get('VIN'),
                'civ': vehicle_data.get('CIV'),
                'engine_size': vehicle_data.get('EngineSize'),
                'power_kw': vehicle_data.get('Power'),
                'fuel_type': vehicle_data.get('FuelType'),
                'weight_kg': vehicle_data.get('Weight'),
                'number_of_seats': vehicle_data.get('NumberOfSeats'),
                'region': vehicle_data.get('Region'),
                'variant': vehicle_data.get('Variant'),
                'image_url': vehicle_data.get('ImageUrl'),
                '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 = RomanianVehicleAPI("your_username")
result = api.lookup("B123ABC")

if result.get('success'):
    print(f"Vehicle: {result['make']} {result['model']}")
    print(f"Year: {result['registration_year']}")
    print(f"Engine: {result['engine_size']}cc, {result['power_kw']}kW")
    print(f"Fuel: {result['fuel_type']}")
    print(f"VIN: {result['vin']}")
    print(f"CIV: {result['civ']}")
    print(f"Region: {result['region']}")
    print(f"Weight: {result['weight_kg']}kg")
    print(f"Seats: {result['number_of_seats']}")
else:
    print(f"Error: {result['error']}")

Romanian Vehicle Registration Format

County Codes

Romanian license plates begin with county codes that identify the registration location:

Major Cities and Counties:

• B – București (Bucharest) – Capital city
• AB – Alba – Alba Iulia
• AG – Argeș – Pitești
• AR – Arad – Arad
• BC – Bacău – Bacău
• BH – Bihor – Oradea
• BN – Bistrița-Năsăud – Bistrița
• BR – Brăila – Brăila
• BT – Botoșani – Botoșani
• BV – Brașov – Brașov
• BZ – Buzău – Buzău
• CJ – Cluj – Cluj-Napoca
• CL – Călărași – Călărași
• CS – Caraș-Severin – Reșița
• CT – Constanța – Constanța
• CV – Covasna – Sfântu Gheorghe
• DB – Dâmbovița – Târgoviște
• DJ – Dolj – Craiova
• GJ – Gorj – Târgu Jiu
• GL – Galați – Galați
• GR – Giurgiu – Giurgiu
• HD – Hunedoara – Deva
• HR – Harghita – Miercurea Ciuc
• IF – Ilfov – Buftea
• IL – Ialomița – Slobozia
• IS – Iași – Iași
• MH – Mehedinți – Drobeta-Turnu Severin
• MM – Maramureș – Baia Mare
• MS – Mureș – Târgu Mureș
• NT – Neamț – Piatra Neamț
• OT – Olt – Slatina
• PH – Prahova – Ploiești
• SB – Sibiu – Sibiu
• SJ – Sălaj – Zalău
• SM – Satu Mare – Satu Mare
• SV – Suceava – Suceava
• TL – Tulcea – Tulcea
• TM – Timiș – Timișoara
• TR – Teleorman – Alexandria
• VL – Vâlcea – Râmnicu Vâlcea
• VN – Vrancea – Focșani
• VS – Vaslui – Vaslui

Understanding Romanian Vehicle Data

Vehicle Types (Tip Vehicul)

• Autoturism – Passenger car
• Autoutilitară – Utility vehicle/van
• Autocamion – Truck
• Autobus/Autobuz – Bus
• Motocicletă – Motorcycle
• Moped – Moped
• Remorcă – Trailer

Fuel Types (Tip Combustibil)

• Benzină – Petrol/Gasoline
• Motorină – Diesel
• GPL – Liquefied Petroleum Gas
• Electric – Electric vehicle
• Hibrid – Hybrid (petrol/electric or diesel/electric)

CIV Document

The CIV (Cartea de Identitate a Vehiculului) is Romania’s vehicle identity document, similar to a vehicle registration certificate. It contains:

• Vehicle technical specifications
• Ownership history
• Registration details
• Environmental compliance information

Use Cases for Romanian Vehicle API

Insurance Industry

• Policy Underwriting – Access technical specifications for risk assessment
• Claims Processing – Verify vehicle details during accident claims
• Fraud Prevention – Cross-reference VIN and CIV data for authenticity
• Premium Calculation – Engine power and weight for insurance categories

Automotive Dealers

• Vehicle History – Verify registration and technical details
• Import/Export – VIN verification for cross-border transactions
• Inventory Management – Automated vehicle data population
• Trade Valuations – Technical specifications for pricing

Fleet Management

• Asset Tracking – Maintain detailed vehicle records
• Compliance Monitoring – Ensure registration validity across fleet
• Maintenance Planning – Engine specifications for service schedules
• Environmental Reporting – Fuel type and emissions data

Government and Law Enforcement

• Vehicle Identification – Quick lookups during traffic enforcement
• Registration Verification – Confirm vehicle legitimacy
• Import Control – VIN verification for customs procedures
• Investigation Support – Vehicle tracking and identification

Mobile Applications

• Car Shopping Apps – Instant vehicle specification lookup
• Insurance Apps – Quick vehicle verification for quotes
• Service Apps – Technical specifications for maintenance booking
• Parking Apps – Vehicle identification and validation

Error Handling Best Practices

function handleRomanianVehicleLookup(registration, username) {
  // Validate input format
  if (!registration || registration.length < 6) {
    return Promise.reject(new Error("Invalid registration number format"));
  }
  
  // Clean registration number
  const cleanReg = registration.replace(/\s+/g, '').toUpperCase();
  
  return lookupRomanianVehicle(cleanReg, username)
    .then(data => {
      if (!data) {
        throw new Error("No vehicle data returned");
      }
      
      // Validate essential fields
      if (!data.make || !data.model) {
        throw new Error("Incomplete vehicle data received");
      }
      
      return data;
    })
    .catch(error => {
      console.error('Romanian vehicle lookup error:', error);
      
      // Return structured error response
      return {
        error: true,
        message: error.message,
        registration: registration,
        timestamp: new Date().toISOString()
      };
    });
}

Data Privacy and Compliance

GDPR Compliance

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

• The API returns technical vehicle specifications, not personal owner data
• VIN and CIV numbers are vehicle identifiers, not personal information
• Consider data retention policies when caching API responses
• Implement proper access controls for vehicle data systems

Usage Limitations

• API is intended for legitimate business purposes
• Vehicle data should not be used for unauthorized tracking
• Respect rate limits and terms of service
• Implement proper error handling to avoid excessive requests

Getting Started

Account Setup

1. Register for API access at the Romanian vehicle API portal
2. Verify your email address and business credentials
3. Test with sample registration numbers like “B123ABC”
4. Purchase credits for production usage

Integration Testing

Test with various Romanian registration formats:

• Bucharest format: B123ABC, B456DEF
• County formats: CJ12ABC, TM34DEF, CT56GHI
• Different vehicle types to understand data variations

Production Considerations

• Implement robust error handling for network issues
• Cache responses appropriately to reduce API calls
• Monitor API usage and credit consumption
• Plan for data updates and system maintenance windows

Conclusion

The Romanian Vehicle Registration API provides comprehensive access to vehicle data across all Romanian counties and cities. With detailed technical specifications, official document references (CIV), and standardized data formats, the API supports diverse applications from insurance processing to fleet management.

Romania’s centralized registration system ensures consistent data quality while the API’s detailed response format provides all necessary vehicle information for professional applications. Understanding Romanian vehicle types, fuel classifications, and regional codes enhances the effectiveness of API integration.

The system’s compliance with EU data protection standards and focus on technical specifications rather than personal data makes it suitable for business applications requiring vehicle verification and specification lookup.

Start integrating Romanian vehicle data today by registering for API access and exploring the comprehensive database of Romanian vehicle registrations.

Please visit https://www.inmatriculareapi.ro/ to get started.