Archive

Posts Tagged ‘artificial-intelligence’

Complete Guide to the UK Vehicle Registration #API: Access #DVLA Data, #MOT History, and More

August 25, 2025 Leave a comment

Are you developing an application that needs instant access to UK vehicle information? The UK Vehicle Registration API provides comprehensive access to DVLA data, MOT history, tax information, and vehicle specifications through a simple integration. This powerful tool allows developers to retrieve detailed vehicle information using just a Vehicle Registration Mark (VRM). Here: https://regcheck.org.uk/

What is the UK Vehicle Registration API?

The UK Vehicle Registration API is a SOAP-based web service that provides instant access to official UK vehicle data. By simply entering a vehicle registration number (VRM), you can retrieve comprehensive information about cars, motorcycles, and commercial vehicles registered with the DVLA.

Key Features:

  • Instant VRM lookups for all UK-registered vehicles
  • Complete MOT history with test results and failure reasons
  • Tax status information including expiry dates
  • Comprehensive vehicle specifications including make, model, engine details
  • Support for special territories including Isle of Man and Jersey
  • Both XML and JSON response formats

UK Vehicle Data Available

Standard Vehicle Information

When you query the UK endpoint using a vehicle registration number, you’ll receive:

  • Make and Model – Manufacturer and specific vehicle model
  • Year of Registration – When the vehicle was first registered
  • VIN Number – Complete Vehicle Identification Number
  • ABI Code – Association of British Insurers classification code
  • Body Style – Vehicle type (saloon, hatchback, SUV, etc.)
  • Engine Size – Displacement in cubic centimeters
  • Number of Doors – Vehicle door configuration
  • Transmission Type – Manual or automatic
  • Fuel Type – Petrol, diesel, electric, hybrid
  • Immobiliser Status – Security system information
  • Number of Seats – Seating capacity
  • Driver Side – Left or right-hand drive
  • Vehicle Color – Primary exterior color

Example Response for UK Vehicle Data

{
  "ABICode": "32130768",
  "Description": "MERCEDES-BENZ E220 SE CDI",
  "RegistrationYear": "2013",
  "CarMake": {
    "CurrentTextValue": "MERCEDES-BENZ"
  },
  "CarModel": {
    "CurrentTextValue": "E220 SE CDI"
  },
  "EngineSize": {
    "CurrentTextValue": "2143"
  },
  "FuelType": {
    "CurrentTextValue": "Diesel"
  },
  "Transmission": {
    "CurrentTextValue": "Automatic"
  },
  "NumberOfDoors": {
    "CurrentTextValue": "4DR"
  },
  "BodyStyle": {
    "CurrentTextValue": "Saloon"
  },
  "Colour": "WHITE",
  "VehicleIdentificationNumber": "WDD2120022A899877"
}

MOT History API – Complete Test Records

One of the most valuable features of the UK Vehicle API is access to complete MOT history data. This service covers all UK cars (excluding Northern Ireland) and provides detailed test information including:

MOT Data Includes:

  • Test Date – When each MOT was conducted
  • Test Result – Pass or Fail status
  • Odometer Reading – Mileage at time of test
  • Test Number – Official MOT test reference
  • Failure Reasons – Detailed list of any failures
  • Advisory Notes – Items that need attention
  • Expiry Date – When the MOT certificate expires

MOT History Response Example

[
  {
    "TestDate": "8 November 2016",
    "ExpiryDate": "16 November 2017",
    "Result": "Pass",
    "Odometer": "61,706 miles",
    "TestNumber": "2754 6884 4000",
    "FailureReasons": [],
    "Advisories": []
  },
  {
    "TestDate": "8 November 2016",
    "Result": "Fail",
    "Odometer": "61,703 miles",
    "TestNumber": "5901 3690 4542",
    "FailureReasons": [
      "Nearside Rear Brake pipe excessively corroded (3.6.B.2c)",
      "Offside Rear Brake pipe excessively corroded (3.6.B.2c)"
    ],
    "Advisories": []
  }
]

Extended Vehicle Information with Tax Data

The API also provides enhanced vehicle information including tax and emissions data:

  • Make and Registration Date
  • Year of Manufacture
  • CO2 Emissions – Environmental impact rating
  • Tax Status – Current road tax status
  • Tax Due Date – When road tax expires
  • Vehicle Type Approval – EU approval classification
  • Wheelplan – Axle configuration
  • Weight Information – Gross vehicle weight

UK Motorcycle Support

For motorcycles registered in the UK, use the dedicated CheckMotorBikeUK endpoint. This returns motorcycle-specific information:

  • Make and Model – Manufacturer and bike model
  • Year of Registration
  • Engine Size – Engine displacement
  • Variant – Specific model variant
  • Colour – Primary color
  • VIN – Complete chassis number
  • Engine Number – Engine identification

Motorcycle Response Example

{
  "Description": "HONDA ST1300 A",
  "RegistrationYear": "2005",
  "CarMake": {
    "CurrentTextValue": "HONDA"
  },
  "CarModel": {
    "CurrentTextValue": "ST1300 A"
  },
  "EngineSize": {
    "CurrentTextValue": "1261"
  },
  "BodyStyle": {
    "CurrentTextValue": "Motorbike"
  },
  "FuelType": {
    "CurrentTextValue": "PETROL"
  },
  "Colour": "YELLOW",
  "VehicleIdentificationNumber": "JH2SC51A92M007472"
}

Isle of Man Vehicle Support

Vehicles registered in the Isle of Man (identified by “MN”, “MAN”, or “MANX” in the registration) return enhanced data including:

  • Standard vehicle information (make, model, engine size)
  • Version details – Specific trim level
  • CO2 emissions – Environmental data
  • Tax status – “Active” or expired
  • Tax expiry date – When road tax is due
  • Wheelplan – Vehicle configuration

Isle of Man Response Example

{
  "Description": "HONDA JAZZ",
  "RegistrationYear": 2012,
  "CarMake": {
    "CurrentTextValue": "HONDA"
  },
  "Version": "I-VTEC ES",
  "Colour": "SILVER",
  "Co2": "126",
  "RegistrationDate": "06/07/2012",
  "WheelPlan": "2-AXLE Rigid",
  "Taxed": "Active",
  "TaxExpiry": "31/07/2018"
}

Integration and Implementation

API Endpoint

The service is available at: https://www.regcheck.org.uk/api/reg.asmx

WSDL Definition

Access the service definition at: https://www.regcheck.org.uk/api/reg.asmx?wsdl

Authentication

All API calls require a valid username. You can obtain a test account with 10 free credits after email verification.

Sample Implementation (PHP)

<?php
$username = 'Your_Username_Here';
$regNumber = 'AB12CDE';

$xmlData = file_get_contents("https://www.regcheck.org.uk/api/reg.asmx/Check?RegistrationNumber=" . $regNumber . "&username=" . $username);

$xml = simplexml_load_string($xmlData);
$strJson = $xml->vehicleJson;
$json = json_decode($strJson);

echo "Vehicle: " . $json->Description;
echo "Year: " . $json->RegistrationYear;
echo "Fuel: " . $json->FuelType->CurrentTextValue;
?>

Use Cases for UK Vehicle API

For Businesses:

  • Insurance Companies – Instant vehicle verification and risk assessment
  • Car Dealers – Vehicle history checks and specifications
  • Fleet Management – MOT tracking and compliance monitoring
  • Automotive Marketplaces – Automated vehicle data population
  • Garage Services – Customer vehicle information lookup

For Developers:

  • Mobile Apps – Vehicle checking applications
  • Web Platforms – Integrated vehicle lookup features
  • Compliance Tools – MOT and tax reminder systems
  • Data Validation – Verify vehicle registration details

Benefits of Using the UK Vehicle Registration API

  1. Official DVLA Data – Access to authoritative government vehicle records
  2. Real-time Information – Instant access to current vehicle status
  3. Comprehensive Coverage – Supports cars, motorcycles, and commercial vehicles
  4. Historical Data – Complete MOT history with detailed records
  5. Multiple Formats – Both XML and JSON response options
  6. Reliable Service – High uptime and consistent performance
  7. Cost Effective – Credit-based pricing with free test options

Getting Started

To begin using the UK Vehicle Registration API:

  1. Sign up for a free test account at regcheck.org.uk
  2. Verify your email address to receive 10 free credits
  3. Test the API with sample vehicle registration numbers
  4. Purchase additional credits as needed for production use
  5. Implement the API in your application using provided documentation

Security and Compliance

The API includes several security features:

  • IP Address Restrictions – Lock access to specific IP addresses
  • Credit Monitoring – Balance alerts and daily usage limits
  • Secure Connections – HTTPS encryption for all API calls
  • Data Protection – Compliance with UK data protection regulations

Conclusion

The UK Vehicle Registration API provides developers and businesses with comprehensive access to official DVLA data, MOT records, and vehicle specifications. Whether you’re building a consumer app for vehicle checks or integrating vehicle data into business systems, this API offers the reliability and data coverage needed for professional applications.

With support for standard UK vehicles, motorcycles, and special territories like the Isle of Man, plus detailed MOT history and tax information, the UK Vehicle Registration API is the most complete solution for accessing UK vehicle data programmatically.

Ready to get started? Visit the RegCheck website to create your free account and begin exploring UK vehicle data today.

Categories: Uncategorized Tags: , , ,

C# – using #OpenCV to determine if an image contains an image of a car (or a duck)

November 19, 2024 Leave a comment

TL;DR; Here is the repo: https://github.com/infiniteloopltd/IsItACar

This demo application can take an image and derermine if the image is that of a Car, or not a car. My test image was of a duck, which was very defintely not car-like. But sillyness aside, this can be very useful for image upload validation – if you want to ensure that your car-sales website doesn’t allow their users to upload nonsense pictures, but only of cars, then this code could be useful.

Why Use Emgu.CV for Computer Vision?

Emgu.CV simplifies the use of OpenCV in C# projects, providing an intuitive interface while keeping the full functionality of OpenCV. For tasks like object detection, it is an ideal choice due to its performance and flexibility.

Prerequisites

Before diving into the code, make sure you have the following set up:

  • Visual Studio (or another preferred C# development environment)
  • Emgu.CV library installed via NuGet:
    • Search for Emgu.CV and Emgu.CV.runtime.windows in the NuGet Package Manager and install them.

Setting Up Your Project

We’ll write a simple application to detect cars in an image. The code uses a pre-trained Haar cascade classifier, which is a popular method for object detection.

The Code

Here’s a complete example demonstrating how to load an image from a byte array and run car detection using Emgu.CV:

csharpCopy codeusing Emgu.CV;
using Emgu.CV.CvEnum;
using Emgu.CV.Structure;
using System;
using System.Drawing;
using System.IO;

class Program
{
    static void Main(string[] args)
    {
        // Load the image into a byte array (this could come from a database or API)
        byte[] imageBytes = File.ReadAllBytes("path_to_your_image.jpg");

        // Create a Mat object to hold the decoded image
        Mat mat = new Mat();

        // Decode the image from the byte array into the Mat object
        CvInvoke.Imdecode(imageBytes, ImreadModes.Color, mat);

        // Convert the Mat to an Image<Bgr, byte> for further processing
        Image<Bgr, byte> image = mat.ToImage<Bgr, byte>();

        // Load the Haar cascade for car detection
        string cascadeFilePath = "path_to_haarcascade_car.xml"; // Download a Haar cascade for cars
        CascadeClassifier carClassifier = new CascadeClassifier(cascadeFilePath);

        // Convert to grayscale for better detection performance
        using (var grayImage = image.Convert<Gray, byte>())
        {
            // Detect cars in the image
            Rectangle[] cars = carClassifier.DetectMultiScale(
                grayImage, 
                scaleFactor: 1.1, 
                minNeighbors: 5, 
                minSize: new Size(30, 30));

            // Draw rectangles around detected cars
            foreach (var car in cars)
            {
                image.Draw(car, new Bgr(Color.Red), 2);
            }

            // Save or display the image with the detected cars
            image.Save("output_image_with_cars.jpg");
            Console.WriteLine($"Detected {cars.Length} car(s) in the image.");
        }
    }
}

Breaking Down the Code

  1. Loading the Image as a Byte Array:csharpCopy codebyte[] imageBytes = File.ReadAllBytes("path_to_your_image.jpg"); Instead of loading an image from a file directly, we load it into a byte array. This approach is beneficial if your image data is not file-based but comes from a more dynamic source, such as a database.
  2. Decoding the Image:csharpCopy codeMat mat = new Mat(); CvInvoke.Imdecode(imageBytes, ImreadModes.Color, mat); We use CvInvoke.Imdecode to convert the byte array into a Mat object, which is OpenCV’s matrix representation of images.
  3. Converting Mat to Image<Bgr, byte>:csharpCopy codeImage<Bgr, byte> image = mat.ToImage<Bgr, byte>(); The Mat is converted to Image<Bgr, byte> to make it easier to work with Emgu.CV functions.
  4. Car Detection Using Haar Cascades:csharpCopy codeRectangle[] cars = carClassifier.DetectMultiScale(grayImage, 1.1, 5, new Size(30, 30)); The Haar cascade method is used for object detection. You’ll need to download a Haar cascade XML file for cars and provide the path.
  5. Drawing Detected Cars:csharpCopy codeimage.Draw(car, new Bgr(Color.Red), 2); Rectangles are drawn around detected cars, and the image is saved or displayed.

Downloading Haar Cascade for Cars

To detect cars, you need a pre-trained Haar cascade file. You can find these files on the OpenCV GitHub repository or by searching online for “haarcascade for car detection.”

Conclusion

This example demonstrates a simple yet powerful way to use Emgu.CV for car detection in C#. While Haar cascades are efficient, modern machine learning methods like YOLO or SSD are more accurate for complex tasks. However, for basic object detection, this approach is easy to implement and performs well for simpler use cases.

Feel free to experiment with different parameters to improve detection accuracy or try integrating more advanced models for more complex scenarios. Happy coding!

Categories: Uncategorized Tags: , , ,