Verification of driver licenses is essential for onboarding processes and KYC compliance. It allows you to confirm the identity of an individual, ensuring that they are who they claim to be. This is vital for preventing identity fraud and building trust with your customers.

Introduction

Datakeen's OCR service automatically extracts information from French driver's licences. The platform handles 1989 and 2013 models.

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 located on the front side of the card.
Authenticity checks generate a compliance score to determine whether the card is authentic.

1989 Model

Extracted information
- Name - Surnames - Date of birth - Place of birth - Delivery date - Expiry date - Card number - License categories - Type A issue date - Type B issue date

2013 Model

Extracted information	MRZ controls	Authenticity checks
- Name - Surnames - Date of birth - Place of birth - Delivery date - Expiry date - Card number - License categories - Type A issue date - Type B issue date	- MRZ band - Name on the MRZ - Card number on the MRZ - Expiry Date on the MRZ	- Compliance status - Validity control - Compliance control - Validity check

Setting up the API

The synchronous API model extracts data from ID cards 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/driver-license \
     --header 'accept: application/json' \
     --header 'content-type: application/json'

npm install api --save

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

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

require 'uri'
require 'net/http'

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

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/driver-license', [
  '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/driver-license"

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/driver-license");

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/driver-license");
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/driver-license");

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/driver-license" {:content-type :json
                                                       :accept :json})

package main

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

func main() {

	url := "https://api.datakeen.co/api/v1/reco/driver-license"

	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/driver-license 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/id")
  .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/driver-license', 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/driver-license")
  .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/id"]
                                                       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/id" 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/id' -Method POST -Headers $headers

library(httr)

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

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/id")! 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. Front and back the same document cannot be sent in the same file. 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": {
        "matchExpiry": {
            "value": true
        },
        "matchLicense": {
            "value": true
        },
        "matchName": {
            "value": true
        },
        "mrzConformity": {
            "confidence": 1,
            "value": true
        },
        "mrzValidity": {
            "confidence": 0.5,
            "value": false
        }
    },
    "extractedInformation": {
        "AlicenseIssueDate": {
            "confidence": null,
            "value": ""
        },
        "BlicenseIssueDate": {
            "confidence": null,
            "value": ""
        },
        "birthDate": {
            "confidence": 1.0,
            "value": "14/07/1981"
        },
        "birthPlace": {
            "confidence": 1.0,
            "value": "Utopia city"
        },
        "expiryDate": {
            "confidence": 0.75,
            "value": "31/12/2018"
        },
        "firstName": {
            "confidence": 1.0,
            "value": "Paul"
        },
        "issueDate": {
            "confidence": 1.0,
            "value": "01/01/2013"
        },
        "issuePlace": {
            "confidence": 0.75,
            "value": "99999"
        },
        "lastName": {
            "confidence": 1.0,
            "value": "MARTIN"
        },
        "licenseCategories": {
            "confidence": 1.0,
            "value": "AM/A/A1/B1/B/BE/DE/D"
        },
        "licenseNumber": {
            "confidence": 1.0,
            "value": "13AA00002"
        },
        "mrz": {
            "confidence": 1,
            "value": "D1FRA13AA000026181231MARTIN<<9"
        }
    },
    "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 card.

Name

The lastName (key) of the card holder is returned as a string (value).

lastName	Value
value	string
confidence	number

"lastName": {
  "confidence": 1.0,
  "value": "MARTIN"
}

Surnames

The firstName (key) of the card holder is returned as a string (value) separated by commas ",".

firstName	Value
value	string
confidence	number

"firstName": {
  "confidence": 1.0,
  "value": "Paul"
}

Date of birth

The birthDate (key) of the card holder is returned as a string (value).

birthDate	Value
value	string
confidence	number

"birthDate": {
  "confidence": 1.0,
  "value": "14/07/1981"
}

Place of birth

The birthPlace (key) of the card holder is returned as a string (value).

birthPlace	Value
value	string
confidence	number

"birthPlace": {
  "confidence": 1.0,
  "value": "Utopia city"
}

issueDate

The issueDate (key) of the card holder is returned as a string (value).

issueDate	Value
value	string
confidence	number

"issueDate": {
  "confidence": 1.0,
  "value": "01/01/2013"
},

issuePlace

The issuePlace (key) of the card holder is returned as a string (value).

issuePlace	Value
value	string
confidence	number

"issuePlace": {
  "confidence": 0.75,
  "value": "99999"
}

mrz

The mrz (key) of the card holder is returned as a string (value).

mrz	Value
value	string
confidence	number

"mrz": {
  "confidence": 1,
  "value": "D1FRA13AA000026181231MARTIN<<9"
}

licenseCategories

The licenseCategories (key) of the card holder is returned as a string (value).

licenseCategories	Value
value	string
confidence	number

"licenseCategories": {
  "confidence": 1.0,
  "value": "AM/A/A1/B1/B/BE/DE/D"
}

AlicenseIssueDate

The AlicenseIssueDate (key) of the card holder is returned as a string (value).

AlicenseIssueDate	Value
value	string
confidence	number

"AlicenseIssueDate": {
  "confidence": null,
  "value": ""
}

Expiry date

The expiryDate (key) of the card holder is returned as a string (value).

expiryDate	Value
value	string
confidence	number

"expiryDate": {
  "confidence": 0.75,
  "value": "31/12/2018"
}

Card number

The licenseNumber (key) of the card holder is returned as a string (value).

licenseNumber	Value
value	string
confidence	number

"licenseNumber": {
  "confidence": 1.0,
  "value": "13AA00002"
}

BlicenseIssueDate

The BlicenseIssueDate (key) of the card holder is returned as a string (value).

BlicenseIssueDate	Value
value	string
confidence	number

"BlicenseIssueDate": {
  "confidence": null,
  "value": ""
}

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.

matchExpiry

The matchExpiry returns, as a boolean (value), whether the the expiry date matches with the value in the MRZ (only for 2013 driver licenses).

matchExpiry	Value
value	boolean
confidence	number

"matchExpiry": {
  "value": true
}

MRZ control

The mrzValidity controls the MRZ information with regard to the previously extracted fields. It is returned as a boolean (value) (only for 2013 driver licenses).

mrzValidity	Value
value	boolean
confidence	number

"mrzValidity": {
  "confidence": 0.5,
  "value": false
}

MRZ conformity

The mrzConformity controls the conformity of the MRZ. It is returned as a boolean (value).

mrzConformity	Value
value	boolean
confidence	number

"mrzConformity": {
  "confidence": 1,
  "value": true
}

matchName

The matchName controls if the name matches between the MRZ and the extracted last name. It is returned as a boolean (value).

matchName	Value
value	boolean
confidence	number


"matchName": {
  "value": true
},

matchLicense

The matchLicense controls if the license number matches between the MRZ and the extracted license number. It is returned as a boolean (value).

matchLicense	Value
value	boolean
confidence	number

"matchLicense": {
  "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

Driver's licence

Introduction

1989 Model

2013 Model

Setting up the API

📘
API token is required

🚧
Sending multiple documents

API Response

Extracted information format

Name

Surnames

Date of birth

Place of birth

issueDate

issuePlace

mrz

licenseCategories

AlicenseIssueDate

Expiry date

Card number

BlicenseIssueDate

Control results format

matchExpiry

MRZ control

MRZ conformity

matchName

matchLicense

Additional information

🚧
Loaded scans must pass prerequisites

❗️
API limitations

Introduction

1989 Model

2013 Model

Setting up the API

📘API token is required

🚧Sending multiple documents

API Response

Extracted information format

Name

Surnames

Date of birth

Place of birth

issueDate

issuePlace

mrz

licenseCategories

AlicenseIssueDate

Expiry date

Card number

BlicenseIssueDate

Control results format

matchExpiry

MRZ control

MRZ conformity

matchName

matchLicense

Additional information

🚧Loaded scans must pass prerequisites

❗️API limitations

📘
API token is required

🚧
Sending multiple documents

🚧
Loaded scans must pass prerequisites

❗️
API limitations