Guides

Vehicle registration

Comprehensive capture and extraction of vehicle registration documents.

Suggest Edits

Verification of vehicle registration is a critical step in ensuring compliance with transportation regulations and vehicle ownership documentation. It allows you to confirm the validity of a vehicle's registration, ensuring that it matches the information provided by the owner. This verification is essential for promoting road safety, abiding by legal requirements, and establishing trust in the ownership and operation of vehicles on public roads.

Introduction

Datakeen's OCR service automatically extracts information from Vehicle registrations.

  • Information is captured as structured data and can be extracted as a .json file through our API.
  • MRZ controls are information based checks operated on the MRZ band.
  • Authenticity checks generate a compliance score to determine whether the document is authentic.
Extracted informationControls
- Registration number (A)
- Date of first registration (B)
- Owner's name (C.1)
- Joint owner's name (C.4.1)
- Vehicle make (D.1)
- Vehicle type (D.2)
- National type identification code (D.2.1)
- Commercial name (D.3)
- Unique identification number (E)
- Date of registration certificate (I)
- National administrative power (P.6)
- MRZ band
- Commercial name (D.3) from MRZ strip
- Vehicle make (D.1) from MRZ strip
- Date of first registration (B) from MRZ strip
- Registration number (A) from MRZ strip		- MRZ validity check
- MRZ conformity check
- Match vehicle make (D.1) with information sent
- Match of trade name (D.3) with information sent
- Match date of first registration (B) with information sent
- Match registration number (A) with information sent

Setting up the API

The synchronous API model extracts data from vehicle registrations in real time. The synchronous API model also performs verification checks in order to control Document Validity, MRZ conformity and Data consistency.

📘

API token is required

In order to perform any call, you will need an API token that can be retrieved thanks your API credentials. To learn about authentification, please refer to this page

curl --request POST \
     --url https://api.datakeen.co/api/v1/reco/vehicle-registration \
     --header 'accept: application/json' \
     --header 'content-type: application/json'

npm install api --save

const sdk = require('api')('@datakeen/v1.4.0#ax268r1ilnd0liqe');

sdk.postRecoVehicleRegistration()
  .then(({ data }) => console.log(data))
  .catch(err => console.error(err));

require 'uri'
require 'net/http'

url = URI("https://api.datakeen.co/api/v1/reco/vehicle-registration")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["accept"] = 'application/json'
request["content-type"] = 'application/json'

response = http.request(request)
puts response.read_body

composer require guzzlehttp/guzzle

<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api.datakeen.co/api/v1/reco/vehicle-registration', [
  'headers' => [
    'accept' => 'application/json',
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

python -m pip install requests

import requests

url = "https://api.datakeen.co/api/v1/reco/vehicle-registration"

headers = {
    "accept": "application/json",
    "content-type": "application/json"
}

response = requests.post(url, headers=headers)

print(response.text)

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_WRITEDATA, stdout);
curl_easy_setopt(hnd, CURLOPT_URL, "https://api.datakeen.co/api/v1/reco/vehicle-registration");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "accept: application/json");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

dotnet add package RestSharp

using RestSharp;


var options = new RestClientOptions("https://api.datakeen.co/api/v1/reco/vehicle-registration");
var client = new RestClient(options);
var request = new RestRequest("");
request.AddHeader("accept", "application/json");
request.AddHeader("content-type", "application/json");
var response = await client.PostAsync(request);

Console.WriteLine("{0}", response.Content);


CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_WRITEDATA, stdout);
curl_easy_setopt(hnd, CURLOPT_URL, "https://api.datakeen.co/api/v1/reco/vehicle-registration");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "accept: application/json");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "https://api.datakeen.co/api/v1/reco/vehicle-registration" {:content-type :json
                                                       :accept :json})

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://api.datakeen.co/api/v1/reco/vehicle-registration"

	req, _ := http.NewRequest("POST", url, nil)

	req.Header.Add("accept", "application/json")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(string(body))

}

POST /api/v1/reco/vehicle-registration HTTP/1.1
Accept: application/json
Content-Type: application/json
Host: api.datakeen.co

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("https://api.datakeen.co/api/v1/reco/vehicle-registration")
  .post(null)
  .addHeader("accept", "application/json")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

const options = {
  method: 'POST',
  headers: {accept: 'application/json', 'content-type': 'application/json'}
};

fetch('https://api.datakeen.co/api/v1/reco/vehicle-registration', options)
  .then(response => response.json())
  .then(response => console.log(response))
  .catch(err => console.error(err));

val client = OkHttpClient()

val request = Request.Builder()
  .url("https://api.datakeen.co/api/v1/reco/vehicle-registration")
  .post(null)
  .addHeader("accept", "application/json")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

#import <Foundation/Foundation.h>

NSDictionary *headers = @{ @"accept": @"application/json",
                           @"content-type": @"application/json" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"https://api.datakeen.co/api/v1/reco/vehicle-registration"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

opam install cohttp-lwt-unix cohttp-async

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "https://api.datakeen.co/api/v1/reco/vehicle-registration" in
let headers = Header.add_list (Header.init ()) [
  ("accept", "application/json");
  ("content-type", "application/json");
] in

Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

$headers=@{}
$headers.Add("accept", "application/json")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri 'https://api.datakeen.co/api/v1/reco/vehicle-registration' -Method POST -Headers $headers

library(httr)

url <- "https://api.datakeen.co/api/v1/reco/vehicle-registration"

response <- VERB("POST", url, content_type("application/json"), accept("application/json"))

content(response, "text")

import Foundation

let headers = [
  "accept": "application/json",
  "content-type": "application/json"
]

let request = NSMutableURLRequest(url: NSURL(string: "https://api.datakeen.co/api/v1/reco/vehicle-registration")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

🚧

Sending multiple documents

Scans, pictures and documents should be sent one by one. If you want to send multiple scans at the same time, please refer to the multi-docs API.

API Response

An instance of the usual response is displayed in the following JSON. You will find the complete information, including extraction and checks. More detailed examples of each extracted field are given below. 

{
    "controls": {
        "matchCarBrand": {
            "value": true
        },
        "matchCarModel": {
            "value": true
        },
        "matchCarRegistrationNumber": {
            "value": true
        },
        "matchFirstRegistrationDate": {
            "value": true
        },
        "mrzConformity": {
            "confidence": 1,
            "value": true
        },
        "mrzValidity": {
            "confidence": 0,
            "value": true
        }
    },
    "extractedInformation": {
        "carBrand": {
            "confidence": 1.0,
            "value": "RENAULT"
        },
        "carModel": {
            "confidence": 1.0,
            "value": "ESPACE"
        },
        "carRegistrationNumber": {
            "confidence": 1.0,
            "value": "DG-596-WV"
        },
        "carType": {
            "confidence": 1.0,
            "value": "JKFKC6"
        },
        "coOwnerName": {
            "confidence": 0.9,
            "value": ""
        },
        "documentRegistrationDate": {
            "confidence": 1.0,
            "value": "03/12/2019"
        },
        "firstRegistrationDate": {
            "confidence": 1.0,
            "value": "20/06/2014"
        },
        "mrz": {
            "confidence": 1,
            "value": "CRFRADG596WV4VF1JKFKC65116205341406207VP<<<<CI<<RENAULT<<<<<<<ESPACE<<<<<<<2019FP0599186"
        },
        "ownerName": {
            "confidence": 1.0,
            "value": "PAUL DUPOND"
        },
        "taxHorsePower": {
            "confidence": 1.0,
            "value": "10"
        },
        "typeNationalIdentificationCode": {
            "confidence": 1.0,
            "value": "M10RENVP416P532"
        },
        "vin": {
            "confidence": 1.0,
            "value": "VF1JKEKE651162053"
        }
    },
    "message": "",
    "status": 200
}

Extracted information format

For each field, the confidence value indicates the degree of certainty of the extraction with regard to the data on the vehicle registration.

Vehicle make (D.1)

The carBrand (key) on the document is returned as a string (value).

carBrandValue
valuestring
confidencenumber
"carBrand": {
  "confidence": 1.0,
  "value": "RENAULT"
}

Commercial name (D.3)

The carModel (key) on the document is returned as a string (value).

carModelValue
valuestring
confidencenumber
"carModel": {
  "confidence": 1.0,
  "value": "ESPACE"
}

Registration number (A)

The carRegistrationNumber (key) on the document is returned as a string (value).

carRegistrationNumberValue
valuestring
confidencenumber
"carRegistrationNumber": {
  "confidence": 1.0,
  "value": "DG-576-WV"
}

Vehicle type (D.2)

The carType (key) on the document is returned as a string (value).

carTypeValue
valuestring
confidencenumber
"carType": {
  "confidence": 1.0,
  "value": "JKFKC6"
}

Joint owner's name (C.4.1)

The coOwnerName (key) on the document is returned as a string (value).

coOwnerNameValue
valuestring
confidencenumber
"coOwnerName": {
  "confidence": 0.9,
  "value": ""
}

Date of registration certificate (I)

The documentRegistrationDate (key) on the document is returned as a string (value).

documentRegistrationDateValue
valuestring
confidencenumber
"documentRegistrationDate": {
  "confidence": 1.0,
  "value": "03/12/2019"
}

Date of first registration (B)

The firstRegistrationDate (key) on the document is returned as a string (value).

firstRegistrationDateValue
valuestring
confidencenumber
"firstRegistrationDate": {
  "confidence": 1.0,
  "value": "20/06/2014"
},

MRZ band

The mrz (key) on the document is returned as a string (value).

mrzValue
valuestring
confidencenumber
"mrz": {
  "confidence": 1,
  "value": "AZERAZERAZER6205341406207VP<<<<CI<<RENAULT<<<<<<<ESPACE<<<<<<<2019FP0599186"
}

Owner's name (C.1)

The ownerName (key) on the document is returned as a string (value).

ownerNameValue
valuestring
confidencenumber
"ownerName": {
  "confidence": 1.0,
  "value": "PAUL DUPOND"
}

National administrative power (P.6)

The taxHorsePower (key) on the document is returned as a string (value).

taxHorsePowerValue
valuestring
confidencenumber
"taxHorsePower": {
  "confidence": 1.0,
  "value": "10"
}

National type identification code (D.2.1)

The typeNationalIdentificationCode (key) on the document is returned as a string (value).

typeNationalIdentificationCodeValue
valuestring
confidencenumber
"typeNationalIdentificationCode": {
  "confidence": 1.0,
  "value": "M10RENVZE36P532"
}

Unique identification number (E)

The vin (key) on the document is returned as a string (value).

vinValue
valuestring
confidencenumber
"vin": {
  "confidence": 1.0,
  "value": "VF1JKZEK4262053"
}

Control results format

The controls applied to each document can be extracted in a boolean format. The confidence field indicated the degree of certainty of the control.

Match vehicle make (D.1) with information sent

The matchCarBrand returns, as a boolean (value), whether the control is passed.

matchCarBrandValue
valueboolean
confidencenumber
"matchCarBrand": {
  "value": true
},
"matchCarModel": {
  "value": true
},
"matchCarRegistrationNumber": {
  "value": true
},
"matchFirstRegistrationDate": {
  "value": true
},
"mrzConformity": {
  "confidence": 1,
  "value": true
},
"mrzValidity": {
  "confidence": 1,
  "value": true
}

MRZ validity check

The mrzValidity returns, as a boolean (value), whether the control is passed.

mrzValidityValue
valueboolean
confidencenumber
"mrzValidity": {
  "confidence": 1,
  "value": true
}

MRZ conformity check

The mrzConformity returns, as a boolean (value), whether the control is passed.

mrzConformityValue
valueboolean
confidencenumber
"mrzConformity": {
  "value": true
}

Match date of first registration (B) with information sent

The matchFirstRegistrationDate returns, as a boolean (value), whether the control is passed.

dateValidityValue
valueboolean
confidencenumber
"matchFirstRegistrationDate": {
  "value": true
}

Match of trade name (D.3) with information sent

The matchCarModel returns, as a boolean (value), whether the control is passed.

matchCarModelValue
valueboolean
confidencenumber
"matchCarModel": {
  "confidence": 1,
  "value": true
},

Match registration number (A) with information sent

The matchCarRegistrationNumber returns, as a boolean (value), whether the control is passed.

matchCarRegistrationNumberValue
valueboolean
confidencenumber
"matchCarRegistrationNumber": {
  "confidence": 0,
  "value": true
}

Additional information

🚧

Loaded scans must pass prerequisites

To provide a qualitative service and a comprehensive data capture, every picture, scan, or document sent to our API must comply with determined prerequisites which can be found on this page

❗️

API limitations

  • Maximum size : 5 MB
  • Maximum number of calls per minute : 10 calls

Updated 11 months ago

What’s Next

Ready to process vehicle registration documents ? See our API Reference for detailed information