パッケージの詳細

@microblink/blinkid-in-browser-sdk

BlinkID62.5k6.13.3

A simple ID scanning library for WebAssembly-enabled browsers.

webassembly, ocr, identity-documents, identity-document

readme

BlinkID In-browser SDK

How to run this repo?

Test this repo quickly on your machine (assuming you have Node and Git installed) by doing the following steps:

clone this repo by running git clone https://github.com/BlinkID/blinkid-in-browser in your Terminal
run cd blinkid-in-browser/examples/getting-started && npm install && npm run dev
get the license at Microblink DevHub and add it to the LICENSE variable in the main.js file in the examples/getting-started folder
open http://localhost:5173/
- port may be different in your case, check the output of the npm run dev command noted above
point your ID towards the camera

If you prefer a short, 3 minute, video for running this project, feel free to check it out here.

If you want to recreate this project from scratch, step by step, please check out this tutorial: Integrating ID Scanning and Extraction In Web Apps With BlinkID SDK.

BlinkID In-browser SDK enables scanning of various identity documents, including driving licenses, national identity cards, passports and others. The SDK provides real-time in-browser data extraction, without any need for sending images to servers for processing.

For more information on how to integrate BlinkID SDK into your web app, read the instructions below. Make sure you read the latest CHANGELOG.md file to see the most recent changes and improvements.

Check out the official demo app or live examples of BlinkID SDK in action:

To see the source code of the above examples, check out the examples directory. If you'd like to run examples of the UI component, either through the browser or locally, see the ui/examples directory.

Please keep in mind that BlinkID In-browser SDK is meant to be used natively in a web browser. It will not work correctly within a iOS/Android WebView or NodeJS backend service. If you are looking for Cordova/PhoneGap version, please go here. If you want to use BlinkID as a backend service, check out BlinkID Cloud API or BlinkID Self-hosted API.

BlinkID In-browser SDK

Components of SDK

BlinkID In-browser SDK consists of:

WASM library that recognizes a document a user is holding and extracts an image of the most suitable frame from the camera feed.
Web component with a prebuilt and customizable UI, which acts as a wrapper for the WASM library to provide a straightforward integration.

You can add it to your website or web app in two ways:

For the simplest form of integration, use a web component with a prebuilt and customizable UI.
- Follow the integration instructions in the ui/README.md file.
- You can find the source code of example applications in the ui/examples directory.
For an advanced form of integration where UI has to be built from scratch, use a WASM library instead.
- See the integration instructions here.
- Find the source code of example applications in the examples directory.

Integration instructions

This repository contains WebAssembly files and supporting JS files which contain the core implementation of BlinkID functionalities.

In order to make integration of the WebAssembly easier and more developer friendly, a JavaScript/TypeScript support code is also provided, giving you an easy-to-use integration API.

This repository also contains a sample JS/TS integration app which demonstrates how you can integrate the BlinkID into your web app.

BlinkID will work in any browser that supports WebAssembly, but works best with the latest versions of Firefox, Chrome, Safari and Microsoft Edge. It's worth noting that scan performance depends on the device processing capabilities.

Obtaining a license key

Using BlinkID in your web app requires a valid license key.

A valid license key is required to initialize scanning. You can request a free trial license key, after you register, at Microblink Developer Hub.

Make sure you enter a fully qualified domain name of your web app when filling out the form — the license key will be bound to it. Also, if you plan to serve your web app from different domains, you'll need a license key for each one.

Keep in mind: Versions BlinkID 5.8.0 and above require an internet connection to work under our new License Management Program.

This means your web app has to be connected to the Internet in order for us to validate your trial license key. Scanning or data extraction of documents still happens offline, in the browser itself.

Once the validation is complete, you can continue using the SDK in an offline mode (or over a private network) until the next check.

We've added error callback to Microblink SDK to inform you about the status of your license key.

Installation

We recommend you install a stable version via NPM or Yarn:

# NPM
npm install @microblink/blinkid-in-browser-sdk

# Yarn
yarn add @microblink/blinkid-in-browser-sdk

Which can then be used with a module bundler in Node environment:

import * as BlinkIDSDK from "@microblink/blinkid-in-browser-sdk";

Source code of BlinkIDSDK is written in TypeScript and types are exposed in the public NPM package, so it's possible to use the SDK in both JavaScript and TypeScript projects.

Alternatively, it's possible to use UMD builds which can be loaded from public CDN services.

However, we strongly advise that you host the JavaScript bundles on your infrastructure since there is no guarantee that the public CDN service has satisfactory uptime and availability throughout the world.

For example, it's possible to use UMD builds from the dist folder on the jsDelivr CDN. The UMD builds make BlinkIDSDK available as a window.BlinkIDSDK global variable:

<!-- IMPORTANT: change "X.Y.Z" to the version number you wish to use! -->
<script src="https://cdn.jsdelivr.net/npm/@microblink/blinkid-in-browser-sdk@X.Y.Z/dist/blinkid-sdk.min.js"></script>

Finally, it's possible to use ES builds, which can be downloaded from the es folder on jsDelivr. ES modules are used in a similar manner as NPM package:

import * as BlinkIDSDK from "./es/blinkid-sdk.js";

Important: the jsDelivr CDN is used here due to simplicity of usage. It's not intended to be used in production!

WASM Resources

After adding BlinkID SDK to your project, make sure to include all files from its resources folder in your distribution. Those files contain compiled WebAssembly modules and support JS code.

Do not add those files to the main app bundle, but rather place them on a publicly available location so that the SDK can load them at an appropriate time. For example, place the resources in my-angular-app/src/assets/ folder if using ng new or in my-react-app/public/ folder if using create-react-app.

For more information on how to setup aforementioned resources, check out the Configuration of SDK section.

Versions and backward compatibility

Even though the API is not going to change between minor versions, the structure of results for various recognizers might change between minor versions.

This is due to the improvements we make to our recognizers with every minor release. We suggest you familiarize yourself with what Recognizer, RecognizerRunner and VideoRecognizer are before moving on.

It's a good practice to always lock your minor version and check the CHANGELOG.md file before upgrading to a new minor version.

For example, in package.json you should have something like "@microblink/blinkid-in-browser-sdk": "~4.1.1" instead of the default "@microblink/blinkid-in-browser-sdk": "^4.1.1".

Performing your first scan

Note: the following code snippets are written in TypeScript, but it's possible to use them in plain JavaScript.

Make sure you have a valid license key. See Obtaining a license key.
Add the SDK to your web app by using one of the options provided in the Installation section.

Initialize the SDK using the following code snippet:

import * as BlinkIDSDK from "@microblink/blinkid-in-browser-sdk";

// Check if browser is supported
if ( BlinkIDSDK.isBrowserSupported() )
{
    const loadSettings = new BlinkIDSDK.WasmSDKLoadSettings( "your-base64-license-key" );

    BlinkIDSDK.loadWasmModule( loadSettings ).then
    (
        ( wasmSDK: BlinkIDSDK.WasmSDK ) =>
        {
            // The SDK was initialized successfully, save the wasmSDK for future use
        },
        ( error: any ) =>
        {
            // Error happened during the initialization of the SDK
            console.log( "Error during the initialization of the SDK!", error );
        }
    )
}
else
{
    console.log( "This browser is not supported by the SDK!" );
}

Create recognizer objects that will perform image recognition, configure them to your needs (to scan specific types of documents, for example) and use them to create a RecognizerRunner object:

   import * as BlinkIDSDK from "@microblink/blinkid-in-browser-sdk";

   const recognizer = await BlinkIDSDK.createBlinkIdSingleSideRecognizer( wasmSDK );
   const recognizerRunner = await BlinkIDSDK.createRecognizerRunner(
       wasmSDK,
       [ recognizer ],
       true
   );

Obtain a reference to your HTML video element and create a VideoRecognizer using the element and your instance of RecognizerRunner which then can be used to process input video stream:

const cameraFeed = document.getElementById( "myCameraVideoElement" ) as HTMLVideoElement;
try
{
    const videoRecognizer = await BlinkIDSDK.VideoRecognizer.createVideoRecognizerFromCameraStream(
        cameraFeed,
        recognizerRunner
    );

    // There is more than one way to handle recognition

    // Using the recognize() method will provide you with the default behavior,
    // such as built-in error handling, timeout and video feed pausing.
    const processResult = await videoRecognizer.recognize();

    // Using the startRecognition() method allows you to pass your own onScanningDone callback,
    // giving you the option to create custom behavior.
    const processResult = await videoRecognizer.startRecognition(
        async ( recognitionState ) =>
        {
            videoRecognizer.pauseRecognition();
            return recognitionState;
        }
    );

    // To obtain recognition results see next step
}
catch ( error )
{
    console.error(error);
}

If processResult returned from VideoRecognizer's method recognize or startRecognition is not BlinkIDSDK.RecognizerResultState.Empty, then at least one recognizer given to the RecognizerRunner above contains a recognition result. You can extract the result from each recognizer using its getResult method:
```
if ( processResult !== BlinkIDSDK.RecognizerResultState.Empty )
{
    const recognitionResult = await recognizer.getResult();
    console.log( recognitionResult );
}
else
{
    console.log( "Recognition was not successful!" );
}
```
Finally, release the memory on the WebAssembly heap by calling delete method on both RecognizerRunner and each of your recognizers. Also, release the camera stream by calling releaseVideoFeed on instance of VideoRecognizer:
```
videoRecognizer.releaseVideoFeed();
recognizerRunner.delete();
recognizer.delete();
```
Note that after releasing those objects it is not valid to call any methods on them, as they are literally destroyed. This is required to release memory resources on WebAssembly heap which are not automatically released with JavaScript's garbage collector. Also, note that results returned from getResult method are placed on JavaScript's heap and will be cleaned by its garbage collector, just like any other normal JavaScript object.

Recognizing still images

If you just want to perform recognition of still images and do not need live camera recognition, you can do that as well.

Initialize recognizers and RecognizerRunner as described in the steps 1-4 above.
Make sure you have the image set to a HTMLImageElement. If you only have the URL of the image that needs recognizing, you can attach it to the image element with following code snippet:
```
const imageElement = document.getElementById(
  "imageToProcess"
) as HTMLImageElement;
imageElement.src = URL.createObjectURL(imageURL);
await imageElement.decode();
```

Obtain the CapturedFrame object using function captureFrame and give it to the processImage method of the RecognizerRunner:

const imageFrame = BlinkIDSDK.captureFrame( imageElement );
const processResult = await recognizerRunner.processImage( imageFrame );

Proceed as in steps 6-7 above. Note that you don't have to release any resources of VideoRecognizer here as we were only recognizing a single image, but RecognizerRunner and recognizers must be deleted using the delete method.

Configuration of SDK

You can modify the default behaviour of the SDK before a WASM module is loaded.

Check out the following code snippet to learn how to configure the SDK and which non-development options are available:

// Create instance of WASM SDK load settings
const loadSettings = new BlinkIDSDK.WasmSDKLoadSettings( "your-base64-license-key" );

/**
 * Write a hello message to the browser console when license check is successfully performed.
 *
 * Hello message will contain the name and version of the SDK, which are required information for all support
 * tickets.
 *
 * The default value is true.
 */
loadSettings.allowHelloMessage = true;

/**
 * Absolute location of WASM and related JS/data files. Useful when resource files should be loaded over CDN, or
 * when web frameworks/libraries are used which store resources in specific locations, e.g. inside "assets" folder.
 *
 * Important: if the engine is hosted on another origin, CORS must be enabled between two hosts. That is, server
 * where engine is hosted must have 'Access-Control-Allow-Origin' header for the location of the web app.
 *
 * Important: SDK and WASM resources must be from the same version of a package.
 *
 * Default value is empty string, i.e. "". In case of empty string, value of "window.location.origin" property is
 * going to be used.
 */
loadSettings.engineLocation = "";

/**
 * The absolute location of the Web Worker script file that loads the WebAssembly module.
 *
 * Important: the worker script must be served via HTTPS and must be of the same origin as the initiator.
 * See https://github.com/w3c/ServiceWorker/issues/940 (same applies for Web Workers).
 *
 * Important: SDK, worker script and WebAssembly resources must be from the same version of the package.
 *
 * The default value is an empty string, i.e. "", and in that case, the worker script is loaded from the default location in resources folder.
 */
loadSettings.workerLocation = "";

/**
 * Type of the WASM that will be loaded. By default, if not set, the SDK will automatically determine the best WASM
 * to load.
 */
loadSettings.wasmType: WasmType | null = null;

/**
 * Optional callback function that will report the SDK loading progress.
 *
 * This can be useful for displaying progress bar to users with slow connections.
 *
 * The default value is "null".
 *
 * @example
 * loadSettings.loadProgressCallback = (percentage: number) => console.log(`${ percentage }% loaded!`);
 */
loadSettings.loadProgressCallback = null;

// After load settings are configured, proceed with the loading
BlinkIDSDK.loadWasmModule( loadSettings ).then( ... );

There are some additional options which can be seen in the configuration class WasmLoadSettings.

Deployment guidelines

This section contains information on how to deploy a web app which uses BlinkID In-browser SDK.

HTTPS

Make sure to serve the web app over a HTTPS connection.

Otherwise, the browser will block access to a web camera and remote scripts due to security policies.

Deployment of WASM files

The SDK contains multiple builds tailored for different devices' capabilities.

Basic
- The WASM that will be loaded will be most compatible with all browsers that support the WASM, but will lack features that could be used to improve performance.
Advanced
- The WASM that will be loaded will be built with advanced WASM features, such as bulk memory, SIMD, non-trapping floating point and sign extension. Such WASM can only be executed in browsers that support those features. Attempting to run this WASM in a non-compatible browser will crash your app.
AdvancedWithThreads
- The WASM that will be loaded will be build with advanced WASM features, just like above. Additionally, it will be also built with support for multi-threaded processing. This feature requires a browser with support for both advanced WASM features and SharedArrayBuffer.
- For multi-threaded processing there are some things that needs to be set up additionally, like COOP and COEP headers, more info about web server setup can be found here.
- Keep in mind that this WASM bundle requires that all resources are on the same origin. So, for example, it's not possible to load WASM files from some CDN. This limitation exists due to browser security rules.

Additionally, there's two different BlinkID variants:

Full
- Regular build that has barcode deblurring models. This build is loaded automatically on desktop devices.
Lightweight
- Build without deblurring models. This build is loaded automatically on mobile devices. Deblurring models are usually not necessary due to better quality cameras compared to front-facing laptop cameras.

These builds each contain previous build variants present so far: basic, advanced with SIMD and advanced with multithreading making a total of 6 possible builds.

These builds can be overridden by using a new property on the settings objects WasmSDKLoadSettings.blinkIdVariant:

export type BlinkIDVariant = "full" | "lightweight";

Server Configuration

If you know how WebAssembly works, then you'll know a browser will load the .wasm file it needs to compile it to the native code. This is unlike JavaScript code, which is interpreted and compiled to native code only if needed (JIT, a.k.a. Just-in-time compilation). Therefore, before BlinkID is loaded, the browser must download and compile the provided .wasm file.

In order to make this faster, you should configure your web server to serve .wasm files with Content-Type: application/wasm. This will instruct the browser that this is a WebAssembly file, which most modern browsers will utilize to perform streaming compilation, i.e. they will start compiling the WebAssembly code as soon as first bytes arrive from the server, instead of waiting for the entire file to download.

For more information about streaming compilation, check this article from MDN.

If your server supports serving compressed files, you should utilize that to minimize the download size of your web app. It's easy to notice that .wasm file is not a small file, but it is very compressible. This is also true for all other files that you need to serve for your web app.

For more information about configuring your web server to compress and optimally deliver BlinkID SDK in your web app, see the official Emscripten documentation.

Location of WASM and related support files

You can host WASM and related support files in a location different from the one where your web app is located.

For example, your WASM and related support files can be located in https://cdn.example.com, while the web app is hosted on https://example.com.

In that case it's important to set CORS headers in response from https://cdn.example.com. i.e. set header Access-Control-Allow-Origin with proper value so that the web page knows it’s okay to take on the request.

If WASM engine folders are not placed in the same folder as web app, don't forget to configure instance of WasmSDKLoadSettings with proper location:

...
const loadSettings = new BlinkIDSDK.WasmSDKLoadSettings( licenseKey );

loadSettings.engineLocation = "https://cdn.example.com/wasm";
...

The location should point to folder containing folders basic, advanced and advanced-threads that contain the WebAssembly and its support files.

The difference between basic, advanced and advanced-threads folders are in the way the WebAssembly file was built:

WebAssembly files in basic folder were built to be most compatible, but less performant.
WebAssembly files in advanced folder can yield better scanning performance, but requires more modern browser
WebAssembly files in the advanced-threads folder uses advanced WASM features as the WASM in the advanced folder but will additionally use WebWorkers for multi-threaded processing which will yield best performance.

Depending on what features the browser actually supports, the correct WASM file will be loaded automatically.

Note that in order to be able to use WASM from the advanced-threads folder, you need to configure website to be "cross-origin isolated" using COOP and COEP headers, as described in this article. This is required for browser to allow using the SharedArrayBuffer feature which is required for multi-threaded processing to work. Without doing so, the browser will load only the single-threaded WASM binary from the advanced folder.

# NGINX web server COEP and COOP header example

...

server {
    location / {
        add_header Cross-Origin-Embedder-Policy: require-corp;
        add_header Cross-Origin-Opener-Policy: same-origin;
    }
}

...

Setting up multiple licenses

As mentioned, the license key of BlinkID SDK is tied to your domain name, so it's required to initialize the SDK with different license keys based on the location of your web app.

A common scenario is to have different license keys for development on the local machine, staging environment and production environment. Our team will be happy to issue multiple trial licenses if needs be. See Obtaining a license key.

There are two most common approaches regarding setup of your license key(s):

Multiple apps: build different versions of your web app for different environments
Single app: build a single version of your web app which has logic to determine which license key to use

Multiple apps

Common approach when working with modern frameworks/libraries.

Single app

Simple approach, where handling of license key is done inside the web app.

Here is one possible solution:

let licenseKey = "..."; // Place your development license key here

if ( window.location.hostname === "staging.example.com" ) // Place your staging domain here
{
    licenseKey = "..."; // Place your staging license key here
}

if ( window.location.hostname === "example.com" ) // Place your production domain here
{
    licenseKey = "..."; // Place your production license key here
}
...

The `Recognizer` concept, `RecognizerRunner` and `VideoRecognizer`

This section will first describe what a Recognizer is and how it should be used to perform recognition of images, videos and camera stream. We'll also describe what RecognizerRunner is and how it can be used to tweak the recognition procedure. Finally, we'll describe what VideoRecognizer is and explain how it builds on top of RecognizerRunner in order to provide support for recognizing a video or a camera stream.

The `Recognizer` concept

The Recognizer is the basic unit tasked with reading documents within the domain of BlinkID SDK. Its main purpose is to process the image and extract meaningful information from it. As you will see later, BlinkID SDK has lots of different Recognizer objects you can set up to recognize various documents.

The Recognizer is the object on the WebAssembly heap, which means that it will not be automatically cleaned up by the garbage collector once it's not required anymore. Once you are done using it, you must call the delete method on it to release the memory on the WebAssembly heap. Failing to do so will result in memory leak on the WebAssembly heap which may result in a crash of the browser tab running your web app.

Each Recognizer has a Result object, which contains the data that was extracted from the image. The Result for each specific Recognizer can be obtained by calling its getResult method, which will return a Result object placed on the JS heap, i.e. managed by the garbage collector. Therefore, you don't need to call any delete-like methods on the Result object.

Every Recognizer is a stateful object that can be in two possible states: idle state and working state.

While in idle state, you are allowed to call method updateSettings which will update its properties according to the given settings object. At any time, you can call its currentSettings method to obtain its currently applied settings object.

After you create a RecognizerRunner with an array containing your recognizer, the state of the Recognizer will change to working state, in which Recognizer object will be used for processing. While being in working state, it is not possible to call method updateSettings (calling it will crash your web app).

If you need to change configuration of your recognizer while it's being used, you need to:

Call its currentSettings method to obtain its current configuration
Update it as you need it
Create a new Recogizer of the same type
Call updateSettings on it with your modified configuration
Replace the original Recognizer within the RecognizerRunner by calling its reconfigureRecognizers method

When written as a pseudocode, this would look like:

import * as BlinkIDSDK from "@microblink/blinkid-in-browser-sdk";

// Assume myRecognizerInUse is used by the recognizerRunner
const currentSettings = await myRecognizerInUse.currentSettings();

// Modify currentSettings as you need
const newRecognizer = await BlinkIDSDK.createRecognizer(); // use appropriate recognizer creation function
await newRecognizer.updateSettings( currentSettings );

// Reconfigure recognizerRunner
await recognizerRunner.reconfigureRecognizers( [ newRecognizer ], true ); // use `true` or `false` depending of what you want to achieve (see below for the description)

// newRecognizer is now in use and myRecognizerInUse is no longer in use -
// you can delete it if you don't need it anymore
await myRecognizerInUse.delete();

While Recognizer object works, it changes its internal state and its result. The Recognizer object's Result always starts in Empty state. When corresponding Recognizer object performs the recognition of a given image, its Result can either stay in Empty state (in case Recognizer failed to perform recognition), move to Uncertain state (in case Recognizer performed the recognition, but not all mandatory information was extracted) or move to Valid state (in case Recognizer performed recognition and all mandatory information was successfully extracted from the image).

`RecognizerRunner`

The RecognizerRunner is the object that manages the chain of individual Recognizer objects within the recognition process.

It must be created by createRecognizerRunner method of the WasmModuleProxy interface, which is a member of WasmSDK interface which is resolved in a promise returned by the loadWasmModule function you've seen above. The function requires two parameters: an array of Recognizer objects that will be used for processing and a boolean indicating whether multiple Recognizer objects are allowed to have their Results enter the Valid state.

To explain the boolean parameter further, we first need to understand how RecognizerRunner performs image processing.

When the processImage method is called, it processes the image with the first Recognizer in the chain. If Recognizer's Result object changes its state to Valid, and if the above boolean parameter is false, the recognition chain will be stopped and Promise returned by the method will be immediately resolved. If the above parameter is true, then the image will also be processed with other Recognizer objects in chain, regardless of the state of their Result objects.

That means if after processing the image with the first Recognizer in the chain, its Result object's state is not changed to Valid, the RecognizerRunner will use the next Recognizer object in chain for processing the image and so on - until the end of the chain (if no results become valid or always if above parameter is true) or until it finds the recognizer that has successfully processed the image and changed its Result's state to Valid (if above parameter is false).

You cannot change the order of the Recognizer objects within the chain - regardless of the order in which you give Recognizer objects to RecognizerRunner (either to its creation function createRecognizerRunner or to its reconfigureRecognizers method), they are internally ordered in a way that ensures the best performance and accuracy possible.

Also, in order for BlinkID SDK to be able to sort Recognizer objects in the recognition chain the best way, it is not allowed to have multiple instances of Recognizer objects of the same type within the chain. Attempting to do so will crash your application.

Performing recognition of video streams using `VideoRecognizer`

Using RecognizerRunner directly could be difficult in cases when you want to perform recognition of the video or the live camera stream. Additionally, handling camera management from the web browser can be sometimes challenging. In order to make this much easier, we provided a VideoRecognizer class.

To perform live camera recognition using the VideoRecognizer, you will need an already configured RecognizerRunner object and a reference to HTMLVideoElement to which camera stream will be attached.

To perform the recognition, you should simply write:

const cameraFeed = <HTMLVideoElement> document.getElementById( "cameraFeed" );
try
{
    const videoRecognizer = await BlinkIDSDK.VideoRecognizer.createVideoRecognizerFromCameraStream(
        cameraFeed,
        recognizerRunner
    );
    const processResult = await videoRecognizer.recognize();
}
catch ( error )
{
    // Handle camera error
}

The recognize method of the VideoRecognizer will start the video capture and recognition loop from the camera and will return a Promise that will be resolved when either processImage of the given RecognizerRunner returns Valid for some frame or the timeout given to recognize method is reached (if no timeout is given, a default one is used).

Recognizing a video file

If, instead of performing recognition of live video stream, you want to perform recognition of a pre-recorded video, you should simply construct VideoRecognizer using a different function, as shown below:

const videoRecognizer = await BlinkIDSDK.createVideoRecognizerFromVideoPath(
    videoPath,
    htmlVideoElement,
    recognizerRunner
);
const processResult = await videoRecognizer.recognize();

Custom UX with `VideoRecognizer`

The procedure for using VideoRecognizer described above is quite simple, but has some limits. For example, you can only perform one shot scan with it. As soon as the promise returned by recognize method resolves, the camera feed is paused and you need to start new recognition.

However, if you need to perform multiple recognitions in single camera session, without pausing the camera preview, you can use the startRecognition method, as described in the example below:

videoRecognizer.startRecognition
(
    ( recognitionState: BlinkIDSDK.RecognizerResultState ) =>
    {
        // Pause recognition before performing any async operation - this will make sure that
        // recognition will not continue while returning the control flow back from this function.
        videoRecognizer.pauseRecognition();

        // Obtain recognition results directly from recognizers associated with the RecognizerRunner
        // that is associated with the VideoRecognizer

        if ( shouldContinueScanning )
        {
            // Resume recognition
            videoRecognizer.resumeRecognition( true );
        }
        else
        {
            // Pause the camera feed
            videoRecognizer.pauseVideoFeed();
            // After this line, the VideoRecognizer is in the same state as if promise returned from
            // recognizer was resolved
        }
        // If videoRecognizer is not paused or terminated, after this line the recognition will
        // continue and recognition state will be retained
    }
);

Handling processing events with `MetadataCallbacks`

Processing events, also known as Metadata callbacks are purely intended to provide users with on-screen scanning guidance or to capture some debug information during development of your web app using BlinkID SDK.

Callbacks for all events are bundled into the MetadataCallbacks object. We suggest that you have a look at the available callbacks and events which you can handle in the source code of the MetadataCallbacks interface.

You can link the MetadataCallbacks interface with RecognizerRunner either during creation or by invoking its method setMetadataCallbacks. Please note that both those methods need to pass information about available callbacks to the native code. For efficiency reasons this happens at the time setMetadataCallbacks is called, not every time a change occurs within the MetadataCallbacks object.

This means that if you, for example, set onQuadDetection to MetadataCallbacks after you already called setMetadataCallbacks method, the onQuadDetection will not be registered with the native code and therefore it will not be called.

Similarly, if you remove the onQuadDetection from MetadataCallbacks object after you already called setMetadataCallbacks method, your app will crash in attempt to invoke a non-existing function when our processing code attempts to invoke it. We deliberately do not perform null check here because of two reasons:

It is inefficient
Having no callback, while still being registered to native code is illegal state of your program and it should therefore crash

Remember that whenever you make some changes to the MetadataCallbacks object, you need to apply those changes to your RecognizerRunner by calling its setMetadataCallbacks method.

List of available recognizers

This section will give a list of all Recognizer objects that are available within BlinkID SDK, their purpose and recommendations on how they should be used to achieve best performance and user experience.

ID barcode recognizer

The IdBarcodeRecognizer is a recognizer specialized for scanning barcodes from various ID cards.

BlinkID Single-side recognizer

The BlinkIdSingleSideRecognizer scans and extracts data from the single side of the supported document.

You can find the list of the currently supported documents here. For detailed information about which fields can be extracted from each document, check this link.

We will continue expanding this recognizer by adding support for new document types in the future. Star this repo to stay updated.

BlinkID Multi-side recognizer

Use BlinkIdMultiSideRecognizer for scanning both sides of the supported document. First, it scans and extracts data from the front, then scans and extracts data from the back, and finally, combines results from both sides.

The BlinkIdMultiSideRecognizer also performs data matching and returns a flag if the extracted data captured from the front side matches the data from the back.

You can find the list of the currently supported documents here. For detailed information about which fields can be extracted from each document, check this link.

We will continue expanding this recognizer by adding support for new document types in the future. Star this repo to stay updated.

Recognizer settings

It's possible to enable various recognizer settings before recognition process to modify default behaviour of the recognizer.

List of all recognizer options is available in the source code of each recognizer, while list of all recognizers is available in the List of available recognizers section.

Recognizer settings should be enabled right after the recognizer has been created in the following manner:

// Create instance of recognizer
const BlinkIdSingleSideRecognizer = await BlinkIDSDK.createBlinkIdSingleSideRecognizer( sdk );

// Retrieve current settings
const settings = await BlinkIdSingleSideRecognizer.currentSettings();

// Update desired settings
settings[ " <recognizer_available_setting> " ] = true;

// Apply settings
await BlinkIdSingleSideRecognizer.updateSettings( settings );

...

Technical requirements

This document provides information about technical requirements of end-user devices to run BlinkID.

Requirements:

The browser is supported.
The browser has access to camera device.
The device has enough computing power to extract data from an image.

Important: BlinkID may not work correctly in WebView/WKWebView/SFSafariViewController. See this section.

Supported browsers

Minimal browser versions with support for all features required by BlinkID.

Chrome	Safari	Edge	Firefox	Opera	iOS Safari	Android Browser	Chrome for Android	Firefox for Android
96	15	93	79	82	15	81	96	79

Internet Explorer is not supported.

Sources: caniuse and WebAssembly Roadmap

Camera devices

Keep in mind that camera device is optional, since BlinkID can extract data from still images.

SDK cannot access camera on iOS 14.2 and older versions when the end-user is using a web browser other than Safari. Apple does not allow access to camera via WebRTC specification for other browsers.

Notes & Guidelines

For optimal data extraction use high-quality camera device in well-lit space and don't move the camera too much.
It's recommended to use camera devices with autofocus functionality for fastest data extraction.
Camera devices on MacBook laptops don't work well with low ambient light, i.e. scanning will take longer than usual.

Device support

It's hard to pinpoint exact hardware specifications for successful data extraction, but based on our testing mid-end and high-end smartphone devices released in 2018 and later should be able to extract data from an image in a relatively short time frame.

Notes & Guidelines

Browsers supported by BlinkID can run on older devices, where extraction can take much longer to execute, e.g. around 30 or even 40 seconds.

SDK and WebView/WKWebView/SFSafariViewController

Android and WebView

WebView is not supported for a couple of reasons:

There is no guarantee that developers of mobile apps are using WebView with all necessary features enabled.
It's up to developers of mobile apps to provide support for camera access from WebView (which is integral part of our experience), which requires additional work compared to classic camera permission in mobile apps.

Also, it's possible for mobile app developers to use WebView alternatives like GeckoView and similar, which have their own constraints.

iOS, WKWebView and SFSafariViewController

As for now, it's not possible to access the camera from WKWebView and SFSafariViewController.

Camera access on iOS, i.e. WebRTC, is only supported in Safari browser. Other browsers like Chrome and Firefox won't work as expected.

Conclusion

There is a general technical constraint when using BlinkID from in-app browser - it's not possible to know for sure if the SDK has or hasn't got camera access. That is, it's not possible to notify the user if the camera is not available during the initialization.

However, majority of widely used apps with in-app browsers, e.g. Facebook and Snapchat, are using standard WebView or embedded Safari with all the features. For example, WASM and modern JS are supported.

But the major problem still remains, how to get an image from the camera? Currently, we can advise two approaches:

Detect via UA string if in-app browser is used and prompt the user to use the native browser.
Detect via UA string if in-app browser is used and enable classic image upload via <input type="file" accept="image/*" capture="environment" /> element.
- Based on the operating system and software version, users will be able to select an image from the gallery, or to capture an image from the camera.

Troubleshooting

Integration problems

In case you're having issues integrating our SDK, the first thing you should do is revisit our integration instructions and make sure to closely follow each step.

If you have followed the instructions to the letter and you still have problems, please contact us at help.microblink.com.

When contacting us, please make sure you include the following information:

Log from the web console.
High resolution scan/photo of the document that you are trying to scan.
Information about the device and browser that you are using — we need the exact version of the browser and operating system it runs on. Also, if it runs on a mobile device, we also need the model of the device in question (camera management is specific to browser, OS and device).
Please stress out that you are reporting a problem related to the WebAssembly version of the BlinkID SDK.

SDK problems

In case of problems with using the SDK, you should do as follows:

Licensing problems

If you are getting an "invalid license key" error or having other license-related problems (e.g. some feature is not enabled that should be), first check the browser console. All license-related problems are logged to the web console so that it's easier to determine what went wrong.

When you can't determine the license-related problem or you simply do not understand the log information, you should contact us at help.microblink.com. When contacting us, please make sure you provide following information:

Exact fully qualified domain name of your app, i.e. where the app is hosted.
License that is causing problems.
Please stress out that you are reporting a problem related to the WebAssembly version of the BlinkID SDK.
If unsure about the problem, you should also provide an excerpt from the web console containing the license error.

FAQ and known issues

After switching from trial to production license I get error This entity is not allowed by currently active license! when I create a specific Recognizer object.

Each license key contains information about which features are allowed to use and which are not. This error indicates that your production license does not allow the use of a specific Recognizer object. You should contact support to check if the provided license is OK and that it really contains the features you've requested.

Why am I getting No internet connection error if I'm on a private network?

Versions BlinkID 5.8.0 and above require an internet connection to work under our new License Management Program.

This means your web app has to be connected to the Internet in order for us to validate your trial license key. Scanning or data extraction of documents still happens offline, in the browser itself.

Once the validation is complete, you can continue using the SDK in an offline mode (or over a private network) until the next check.

We've added error callback to Microblink SDK to inform you about the status of your license key.

Additional info

Complete source code of the TypeScript wrapper can be found here.

For any other questions, feel free to contact us at help.microblink.com.

更新履歴

Release notes

v6.13.3

Bug fixes

Fixed issue with missing AdditionalProcessingInfo export.

v6.13.2

Bug fixes

Fixed an issue in the SDKError constructor where the details property could be set but undefined, causing a TypeError when using the in operator. This issue has been resolved by adding a check to ensure details is defined before accessing it. #161

v6.13.1

Bug fixes

Fixed a bug that prevented user feedback for blur and glare from appearing in the UI component.

v6.13.0

What's New

New Documents Support

Benin - Identity Card
Costa Rica - Polycarbonate Passport
Gambia - Identity Card
Guinea - Identity Card
Nicaragua - Paper Passport
Pakistan - Polycarbonate Passport
Saudi Arabia - Polycarbonate Passport
Senegal - Paper Passport
Suriname - Identity Card
Uruguay - Paper Passport
Zimbabwe - Polycarbonate Passport

New Document Versions for Supported Documents

Australia, Northern Territory - Proof Of Age Card
Ecuador - Driver's License
Ecuador - Paper Passport
El Salvador - Identity Card
Finland - Identity Card
Germany - eID
Greece - Driver's License
Guatemala - Driver's License
Kenya - Identity Card
Luxembourg - Residence Permit
Mexico, Hidalgo - Driver's License
Mexico, Quintana Roo-Solidaridad - Driver's License
Mexico, Tamaulipas - Driver's License
Mozambique - Identity Card
New Zealand - Driver's License
Nicaragua - Identity Card
Tunisia - Driver's License
Uganda - Driver's License
UK - Asylum Request
UK - Proof Of Age Card
USA - Passport Card
USA, Michigan - Identity Card
USA, Tennessee - Driver's License
USA, Tennessee - Identity Card

New Beta Documents Support

Brazil, Alagoas - Identity Card
Grenada - Paper Passport
Honduras - Resident ID
Paraguay - Paper Passport
Saint Kitts and Nevis - Paper Passport
UAE - Esaad Card

New Document Versions for Beta-Supported Documents

El Salvador - Driver's License
Honduras - Driver's License
Hong Kong - Polycarbonate Passport
India, Gujarat - Driver's License
Liechtenstein - Driver's License
Mexico, Quintana Roo-Cozumel - Driver's License
Mozambique - Driver's License
Saint Lucia - Paper Passport

Out of beta

UK - Asylum Request
USA, North Dakota - Identity Card

Minor API changes

added new items to enums:
- Type: ESAAD_CARD
- FieldType: VehicleOwner
added vehicleOwner result to BlinkIdMultiSideRecognizer.Result, BlinkIdSingleSideRecognizer.Result, and VizResult

Bug Fixes

NY ID/DL: Added logic to expose the Enhanced document subtype, allowing customers to distinguish between regular and enhanced versions.
Bolivia & Namibia ID: Resolved data match inconsistencies that were causing data match failures.
Romanian ID: Multi side scan no longer expects blank back card of old IDs, even with skipUnsupportedBack set to false.
Fixed backImageAnalysisResult.cardRotation not being correctly populated when scanning the wrong side of a document.

6.12.0

What's New

Beta Feature: Second Page Passport Scanning
- We've launched support for scanning and extracting data from the second page of passports for select countries - Slovenia, Ireland, and New Zealand.
- When BlinkID detects one of these passports, a UI message will guide the user to the second page. By default, this feature is disabled but can be enabled via the scanPassportDataPageOnly setting on the BlinkIdMultiSideRecognizer. If set to false, it will be required to scan the second page of certain passports. This feature is in beta, and your feedback is appreciated.
USA Green Card - Enabled Data Match for the Document Number field, matching values from the VIZ (Visual Inspection Zone) and MRZ to further enhance extraction reliability.

Bug Fixes

Spain ID: Fixed an issue with indefinite expiry dates, ensuring consistent values between the MRZ and Visual Inspection Zone (VIZ).
Bulgaria ID: Improved parsing for indefinite expiry dates in the MRZ for better accuracy.
Netherlands ID & Norway Passport: Resolved issues with the Personal ID number field that were causing the data match feature to fail.
Chinese Passport: Enhanced reliability of extracted data with additional logic for the Document Number field.
German ID & Luxembourg ID: Adjusted name extraction logic to resolve issues with name separation, ensuring more consistent results.

6.11.2

Bug fixes

NYC Municipal ID & USA Border Crossing Card - Resolved an issue where the scanning process could get stuck on the back side during multi-side scanning.
Multithreaded builds are no longer loaded on Safari by default due to a memory leak in the browser.

6.11.1

Bug fixes

Fixed memory leak in Safari
Fixed incorrect positioning of the close button introduced in 6.11.0

6.11.0

Expanded Document Coverage

New Documents Support

Armenia - Paper Passport
Bahamas - Temporary Residence Permit
Bahamas - Work Permit
Bangladesh - Polycarbonate Passport
Comoros - Paper Passport
Dominican Republic - Non Voter ID
Greece - Polycarbonate Passport
Jamaica - Voter ID
Kazakhstan - Paper Passport
Kyrgyzstan - Paper Passport
Kyrgyzstan - Polycarbonate Passport
Lebanon - Driver's License
Tajikistan - Identity Card
Turkmenistan - Polycarbonate Passport
Uzbekistan - Identity Card

New Document Versions for Supported Documents

Argentina - Alien ID
Bulgaria - Identity Card
Canada, British Columbia - Identity Card
Canada, British Columbia - Minors Public Services Card
Croatia - Driver's License
Jamaica - Paper Passport
Malaysia - i-Kad
Mexico, Coahuila - Driver's License
Montenegro - Driver's License
Namibia - Identity Card
Norway - Driver's License
Pakistan - Proof of Registration
Panama - Identity Card
Panama - Residence Permit
Peru - Minors ID
Portugal - Identity Card
Romania - Identity Card
Trinidad and Tobago - Driver's License
Turkey - Identity Card
USA, Arizona - Identity Card
USA, Colorado - Identity Card
USA, Michigan - Identity Card
USA, Mississippi - Driver's License
USA, Mississippi - Identity Card
USA, Montana - Identity Card
USA, North Carolina - Identity Card
USA, North Carolina - Driver's License
USA, North Dakota - Driver's License
USA, Vermont - Identity Card
USA, Virginia - Identity Card
USA, Wyoming - Driver's License
USA, Wyoming - Identity Card
Uzbekistan - Paper Passport

New Beta Documents Support

Andorra - Paper Passport
Andorra - Polycarbonate Passport
Philippines - Driver's License
Armenia - Work Permit
Australia - Asic Card
Azerbaijan - Driver's License
Bahamas - Paper Passport
Bahamas - Polycarbonate Passport
Cayman Islands - Paper Passport
Cayman Islands - Polycarbonate Passport
Cayman Islands - Voter ID
Gibraltar - Driver's License
Gibraltar - Identity Card
Gibraltar - Paper Passport
Gibraltar - Polycarbonate Passport
Guyana - Paper Passport
Kuwait - Bidoon Card
Kyrgyzstan - Driver's License
Monaco - Paper Passport
Pakistan - Afghan Citizen Card
Philippines, Bangsamoro - Driver's License
Saint Lucia - Driver's License
Saint Lucia - Paper Passport
San Marino - Polycarbonate Passport
Turks and Caicos Islands - Driver's License
Turks and Caicos Islands - Identity Card
Turks and Caicos Islands - Paper Passport
Australia - Interim Health Insurance Card
Australia - Reciprocal Health Insurance Card
UAE - Vehicle Registration

New Document Versions for Beta-Supported Documents

Barbados - Identity Card
Brazil - Paper Passport
Dominican Republic - Driver's License
India, Gujarat - Driver's License
Mexico, Puebla - Driver's License
Philippines - Tax ID
Philippines - Health Insurance Card
Australia - Health Insurance Card

New Segments Supported on Documents

USA - Green Card - eligibilityCategory
USA - Work Permit - eligibilityCategory
Greece - Driver's License - placeOfBirth (greek and latin)
Saudi Arabia - Resident ID - nationality (arabic)
Bahrain - dateOfExpiry
USA - Driver's license & ID card - specificDocumentValidity
Pakistan - Proof of Registration - DependentDateOfBirth, DependentSex, DependentDocumentNumber & DependentFullName

Renamed segments

Barbados - Identity Card - personalIdNumber -> documentNumber
Panama - Identity Card - personalIdNumber -> documentNumber
Panama - Residence Permit - personalIdNumber -> documentNumber

New Features

Greek Alphabet Support
- We’ve added support for extracting Place of Birth in both Greek and Latin scripts.
API changes in BlinkIdSingleSideRecognizer and BlinkIdMultiSideRecognizer:
- new fields in result: manufacturingYear, vehicleType, eligibilityCategory, specificDocumentValidity, dependentsInfo
- new values in ClassInfo enums:
  - Region: BANGSAMORO
  - Type: ASIC_CARD, BIDOON_CARD, INTERIM_HEALTH_INSURANCE_CARD, NON_VOTER_ID, RECIPROCAL_HEALTH_INSURANCE_CARD, VEHICLE_REGISTRATION
- new values in FieldType enum: ManufacturingYear, VehicleType, DependentDateOfBirth, DependentSex, DependentDocumentNumber, DependentFullName, EligibilityCategory, SpecificDocumentValidity

6.10.1

Barcode scanning is now optional for Paraguay ID documents.

6.10.0

New features

Improved reliability and first-time successful scanning experience
- Avoiding Double Scans of the Front Side: For a more reliable scanning process, BlinkID now prompts users to flip the document when they scan the front side twice. This improves the overall experience and reduces the chance of mistakes.
- Starting with the Right Side: If users attempt to scan the back side of a document first, BlinkID will prompt them to begin with the front side. This feature ensures that users follow the correct order, leading to a more reliable and user-friendly experience.

Expanded document coverage

New document versions for supported documents

Sweden - Social Security Card - Back side
Bolivia - Driver's License - Back side
Brazil, Distrito Federal - Identity Card - Back side

Out of beta

Colombia - Temporary Protection Permit

New beta documents support

France - Professional ID
Mexico - Tax ID

New document versions for beta-supported documents

Brazil, Parana - Identity Card - Back side
Brazil, Santa Catarina - Identity Card - Back side

New segments supported on documents

Peru - Alien ID - MRZ

Other changes

Added imageExtractionFailures to AdditionalProcessingInfo - this allows clients to actively track if any ImageExtractionType (FullDocument, Face, Signature) is not visible on the presented document.
Added a new result member, barcodeStepUsed, to both BlinkIdSingleSideRecognizer and BlinkIdMultiSideRecognizer. This member indicates whether the barcode scanning step was utilized during the process.
Added two new settings for BlinkIdSingleSideRecognizer and BlinkIdMultiSideRecognizer:
- allowBarcodeScanOnly - allows barcode recognition to proceed even if the initial extraction fails - set to false by default
- combineFrameResults - enables the aggregation of data from multiple frames - set to true by default

6.9.2

added new member barcodeStepUsed to BlinkIDSingleSideRecognizer and BlinkIDMultiSideRecognizer results
improved barcode scanning

6.9.1

Fixes iOS camera selection logic when the system locale is set to Spanish

6.9.0

New features

Custom mandatory fields

We’re introducing the option for customers to define their own set of mandatory fields. This feature allows greater flexibility in the scanning process by enabling the extraction of only the necessary information from identity documents. Now you can customize the process and focus on only those fields that are relevant to your use case.
Custom mandatory fields can be set at the document level or applied universally to all document types.

Expanded Document Coverage

New Documents Support

Austria - Polycarbonate Passport
Canada - Polycarbonate Passport
Ecuador - Paper Passport
Germany - eID
Guatemala - Alien ID
Iraq - Polycarbonate Passport
Namibia - Identity Card
Nepal - Polycarbonate Passport
Sweden - SIS ID
USA, Delaware - Identity Card
USA, Louisiana - Identity Card
USA, Vermont - Identity Card

New Document Versions for Supported Documents

Bolivia - Identity Card
Canada, British Columbia - Public Services Card
Finland - Identity Card
Greece - Identity Card
Malaysia - iKAD
Mexico, Nuevo Leon - Driver's License
Mexico, Tlaxcala - Driver's License
Morocco - Driver's License
Thailand - Polycarbonate Passport
USA - Alaska - Driver's License
USA - Alaska - Identity Card
USA - Connecticut - Identity Card
USA - Delaware - Driver's License
USA - District of Columbia - Driver's License
USA - Hawaii - Identity Card
USA - Idaho - Driver's License
USA - Indiana - Driver's License
USA - Indiana - Identity Card
USA - Iowa - Identity Card
USA - Kansas - Identity Card
USA - Kentucky - Identity Card
USA - Kentucky - Driver's License
USA - Maine - Identity Card
USA - Maine - Driver's License
USA - Michigan - Driver's License
USA - Minnesota - Driver's License
USA - Minnesota - Identity Card
USA - Montana - Identity Card
USA - Montana - Driver's License
USA - New Hampshire - Identity Card
USA - New Mexico - Driver's License
USA - New Mexico - Identity Card
USA - New York - Identity Card
USA - North Dakota - Identity Card
USA - Oregon - Identity Card
USA - Pennsylvania - Driver's License
USA - Rhode Island - Identity Card
USA - South Carolina - Identity Card
USA - Vermont - Driver's License
USA - Washington - Identity Card
USA - Wyoming - Driver's License
USA - Wyoming - Identity Card

Out of Beta

European Union - Health Insurance Card

New Beta Documents Support

Democratic Republic of the Congo - Voter ID
Philippines - Alien ID
Philippines - Postal ID
Philippines - Work Permit
Philippines - Health Insurance Card

New Document Versions for Beta-Supported Documents

Honduras - Paper Passport
Mexico, Sonora - Driver's License
Peru - Alien ID
Philippines - Alien ID

New Segments Supported on Documents

China Exit Entry Permit - MRZ
China Mainland Travel Permit Taiwan - MRZ
France Residence permit - Remarks & ResidencePermitType
Philippines Alien ID - visaType

Bug Fixes

German ID - Fixed issues in cases when documents contain multiple surnames.
Paraguay ID - Added support for parsing the smaller barcode found on the back side of the ID.
Bulgaria Driver’s License - The Address field is set to optional, improving the extraction process.
Improved MRZ parsing for the back side of the following identity documents:
- Brazil Alien ID
- Kenya ID
- Bosnia and Herzegovina ID
- Ivory Coast ID
- Paraguay ID

API changes

ClassAnonymizationSettings type now uses classFilter property of type ClassFilter instead of country, region and type properties
New result members: remarks, residencePermitType and visaType added to BlinkIdMultiSideRecognizerResult, BlinkIdSingleSideRecognizerResult and VIZResult
New field types: Remarks, ResidencePermitType and VisaType to FieldType enum
Added new enum AlphabetType
Added new type DetailedFieldType
Added new type ClassFilter
Added new type CustomClassRules
Added new settings customClassRules as an array of CustomClassRules types for defining custom mandatory fields
Added new region: ALAGOAS to Region enum
Added new document types: AFGHAN_CITIZEN_CARD, EID, PASS, SIS_ID to DocumentType enum

6.8.0

New Features

BlinkID now extracts precise information about subtypes of driver’s licenses and ID cards (e.g., conditional driver’s license, learner’s permit, provision, enhanced, etc.). This information is included in the scanning results as a documentSubtype field allowing you to tailor workflows or processes based on document limitations.

Bugfixes

Fixed data match for Paraguay ID 2023 to cover inconsistencies between the MRZ and Visual Inspection Zone (VIZ)

6.7.2

Bugfix

Fixes an issue introduced in 6.7.1 where the UI component overlay would not hide after finishing a scanning session.

6.7.1

New Features

Improved blur and glare detection

enableBlurFilter and enableGlareFilter properties have been added on BlinkID recognizer settings. These are enabled by default, but users can turn them off if they want to allow blur and glare on captured frames.
blurStrictnessLevel and glareStrictnessLevel properties have been added on BlinkID recognizer settings. These can be configured using the StrictnessLevel enum, which can be Strict, Normal (default) or Relaxed.
New properties ImageAnalysisResult:
- blurDetected and glareDetected

Bug fixes

A bug that caused memory leaks when reconfiguring the recognizer runner has been fixed
The barcode scanning step feedback is now properly displayed in the UI component
Improved camera selection algorithm

Breaking changes ⚠️

allowBlurFilter has been renamed to enableBlurFilter
The blurred property on ImageAnalysisResult has been renamed to blurDetected

6.7.0

New Features

Real ID symbol detection on US driver's license
- BlinkID can now identify Real ID symbols from US driver’s licenses, providing feedback on their presence or absence. This ensures customers can quickly determine if a Real ID symbol is available on a scanned US driver’s license to be compliant with Real ID regulations.
UX Improvements
- Extended duration for UI messages
- UI messages now remain visible for a longer time after scanning, improving user experience. Users can now review post-scanning messages at a comfortable pace, leading to a smoother process.
- Success indicator for front side capture
  - BlinkID now displays a clear success indicator after scanning the front side of a document. This visual cue enhances user confidence by providing immediate feedback during the scanning process.
Partial anonymization of the "Document Number"
- To ensure user privacy and security, BlinkID now offers the option of partially anonymizing the document number from the scanned document.
Mandatory Barcode Presence on US documents
- To minimize the cases of capturing the front side of the document as the back frame in the results, BlinkID now requires the presence of a barcode before saving the back frame on US documents. Processing status BarcodeDetectionFailed is returned when the mandatory barcode is not present on the back of US documents.

Minor API changes

Added BarcodeDetectionFailed as a new ProcessingStatus
- This status is triggered once the barcode was not found on the image. This processing status can only occur if the document has the mandatory barcode.
Added new boolean member realIdDetectionStatus to the ImageAnalysisResult. If true, Real ID symbol is present, false otherwise.
Added new member documentNumberAnonymizationSettings to the ClassAnonymizationSettings for seamless integration with the document number anonymization feature.

Bug Fixes

Updated internal mapping for Myanmar Passports to display nationality as "Myanmarese" instead of "Burmese" on Myanmar passports.
On Peru ID "Date of Issue" is marked optional, offering customers more flexibility in capturing ID information.
Improved "Date of Expiry" handling logic for MRZ in cases where documents with a date of expiry year 1969 were not correctly sanitized.

6.6.0

Document Updates

New Documents Support:

Australia - Polycarbonate Passport
Indonesia - Polycarbonate Passport
Mexico - Consular Voter ID
Moldova - Polycarbonate Passport
Pakistan - Proof Of Registration
Panama - Polycarbonate Passport
USA - West Virginia - ID Card

New Beta Documents Support:

Brazil - Ceara - ID Card
Brazil - Goias - ID Card
Brazil - Sergipe - ID Card
China - Exit Entry Permit
China - Mainland Travel Permit Taiwan
Colombia - Temporary Protection Permit
India - DL
India - Andhra Pradesh - DL
India - Haryana - DL
European Union - Health Insurance Card

New Document Versions for Supported Documents:

Australia - Queensland - DL
Australia - Victoria - DL
Australia - Western Australia - DL
Bolivia - Minor's ID
Brazil - Alien ID
Estonia - DL
Finland - Alien ID
Guatemala - Paper Passport
India - Paper Passport - New side type
Malta - DL
Mexico - Guanajuato - DL
Mexico - San Luis Potosi - DL
New Zealand - Polycarbonate Passport
Paraguay - ID Card
Slovenia - Residence Permit
USA - Green Card
USA - Work Permit
USA - Arizona - ID Card
USA - Colorado - DL
USA - Colorado - ID Card
USA - District of Columbia - DL
USA - District of Columbia - ID Card
USA - Idaho - DL
USA - Idaho - ID Card
USA - Missouri - ID Card
USA - Nebraska - ID Card
USA - Nevada - ID Card
USA - New York - ID Card
USA - North Dakota - DL
USA - Oklahoma - ID Card
USA - Pennsylvania - ID Card
USA - Utah - ID Card
USA - Virginia - DL
USA - Virginia - ID Card
USA - West Virginia - DL
USA - Wisconsin - DL
USA - Wisconsin - ID Card

New Document Versions for Beta Supported Documents:

Australia - Queensland - Proof of Age Card
Brazil - ID Card
Ireland - Residence Permit
Mexico - Consular ID
Mexico - Residence Permit
Mexico - Nayarit - DL
USA - North Dakota - ID Card

Out of Beta:

Croatia - Residence Permit
Moldova - Paper Passport

Platform Updates

Expanded geographic support with new Region enum values:
- ANDHRA_PRADESH
- CEARA
- GOIAS
- GUERRERO_ACAPULCO_DE_JUAREZ
- HARYANA
- SERGIPE
Document recognition enhanced with new Type enum values:
- EXIT_ENTRY_PERMIT
- MAINLAND_TRAVEL_PERMIT_TAIWAN
- NBI_CLEARANCE
- PROOF_OF_REGISTRATION
- TEMPORARY_PROTECTION_PERMIT
Data extraction improvements:
- Added Sponsor and BloodType result fields to BlinkIdMultiSideRecognizer.Result, BlinkIdSingleSideRecognizer.Result and VizResult

6.5.2

Fixed issue with improper packaging.

v6.5.1

Lightweight builds

This release contains multiple builds tailored for different devices' capabilities.

These builds are:

Full

Regular build that has barcode deblurring models. This build is loaded automatically on desktop devices.

Lightweight

Build without deblurring models. This build is loaded automatically on mobile devices. Deblurring models are usually not necessary due to better quality cameras compared to front-facing laptop cameras.

These builds each contain previous build variants present so far: basic, advanced with SIMD and advanced with multithreading making a total of 6 possible builds.

These builds can be overridden by using a new property on the settings objects WasmSDKLoadSettings.blinkIdVariant:

export type BlinkIDVariant = "full" | "lightweight";

These can also be set on the UI component via the blinkIdVariant prop.

Dynamic webassembly memory management

Depending on the device used, the SDK will allocate different amounts of memory on startup. This is primarily used as a mitigation mechanism for iOS's memory management, which often blocks webassembly memory growth.

Although it's not recommended, this can be overridden using WasmSDKLoadSettings.initialMemory.

Other fixes:

Fixed an issue where certain iOS devices would display a zoomed in preview.
Improved scanning of Bolivia IDs by addressing cases where the expiration date is covered by a signature, allowing the completion of the scanning process.

6.5.0

New features

Improved the document side detection for US driver's licenses which reduces the possibility of capturing the wrong side of the document

Breaking changes

It's now mandatory to scan the barcode when scanning the back side of US driver's licences using the BlinkID Multi Side Recognizer

Bugfixes

Fixed a bug where settings weren't updated correctly when set via the UI component
Fixed data matching issue in Guatamala Passport

v6.4.0

New features

Added new result member cardRotation to ImageAnalysisResult structure
New CardOrientation status - NotAvailable
New Region enum values:
- DISTRITO_FEDERAL
- MARANHAO
- MATO_GROSSO
- MINAS_GERAIS
- PARA
- PARANA
- PERNAMBUCO
- SANTA_CATARINA
New Type enum values:
- CONSULAR_VOTER_ID
- TWIC_CARD

Added support for 8 new documents

Bolivia - Paper Passport
Brazil - Alien ID
Brazil - Distrito Federal - Identity Card
Brazil - Minas Gerais - Identity Card
Cameroon - Polycarbonate Passport
Costa Rica - Paper Passport
UK - Proof of Age Card
USA - Twic Card

Added support for 17 new documents in BETA

Australia - Australian Capital Territory - Identity Card
Australia - Queensland - Proof of Age Card
Australia - Tasmania - Identity Card
Australia - Western Australia - Identity Card
Bahrain - Driver’s License
Bahrain - Paper Passport
Brazil - Maranhao - Identity Card
Brazil - Mato Grosso - Identity Card
Brazil - Para - Identity Card
Brazil - Parana - Identity Card
Brazil - Pernambuco - Identity Card
Brazil - Santa Catarina - Identity Card
Cameroon - Paper Passport
Mexico - Quintana Roo, Benito Juarez - Driver’s License
Mexico - Quintana Roo -Driver’s License
Switzerland - Polycarbonate Passport
UAE - Polycarbonate Passport

Added support for 14 new versions of already supported documents

Brazil - Driver’s License
Luxembourg - Identity Card
North Macedonia - Identity Card
Portugal - Driver’s License
Slovakia - Identity Card
Switzerland - Identity Card
Switzerland - Driver’s License
Turkey - Polycarbonate Passport
Ukraine - Driver’s License
USA - Arizona - Driver’s License
USA - Arizona - Identity Card
USA - Nebraska - Driver’s License
USA - Pennsylvania - Identity Card
USA - Virginia - Driver’s License

Added support for 2 new versions of already supported documents in BETA

Iceland - Paper Passport
Mexico - Consular ID

6.3.2

Export missing DocumentSide

6.3.1

Reintroduce missing lightweight build

6.3.0

New features

Changes to the BlinkIdSingleSideRecognizer and BlinkIdMultiSideRecognizer:
- add new fields inside StringResult:
  - arabicLocation - location coordinates of the arabic text or undefined if arabic text is empty
  - cyrillicLocation - location coordinates of the cyrillic text or undefined if cyrillic text is empty
  - latinLocation - location coordinates of the latin text or undefined if latin text is empty
  - arabicSide - document side of the arabic text or undefined if arabic text is empty
  - cyrillicSide - document side of the cyrillic text or undefined if cyrillic text is empty
  - latinSide - document side of the latin text or undefined if latin text is empty
- new results in Recognizer.Result:
  - faceImageLocation
  - faceImageSide
Add new Country enum value - SCHENGEN_AREA
And new Type enum value - IMMIGRANT_VISA

Bugfixes

Improved scanning success rate and stability when using BlinkIdMultiSideRecognizer

Minor breaking changes

renamed and reordeded elements in the DetectionStatus enum

6.2.1

fixed "payload corrupted" error when using online license key
fixed integer overflow in BlinkID class filter implementation

6.2.0

New features

new and improved machine learning models for data extraction
expanded support for arabic documents
added isFilledByDomainKnowledge flag to Date and DateResult
- indicates that date is not extracted from image but filled based on our internal document knowledge
added new setting additionalAnonymization
- enables custom anonymization for any field per country, region and type of document
added new items to enums:
- Region:
  - NORTHWEST_TERRITORIES (added item to enum, no document support for NORTHWEST_TERRITORIES yet)
  - NUNAVUT (added item to enum, no document support for NUNAVUT yet)
  - PRINCE_EDWARD_ISLAND
- Type:
  - ASYLUM_REQUEST
  - DRIVER_QUALIFICATION_CARD
  - PROVISIONAL_DL
  - REFUGEE_PASSPORT
  - SPECIAL_ID
  - UNIFORMED_SERVICES_ID
- FieldType:
  - BloodType
  - Sponsor

Added support for 9 new documents

Belarus - ID Card
Guyana - ID Card
Jamaica - Paper Passport
Myanmar - Paper Passport
Palestine - Paper Passport
Saint Kitts and Nevis - Driving License
Syria - ID Card
Trinidad and Tobago - Paper Passport
USA - Uniformed Services ID Card

Added support for 23 new documents in BETA

Barbados - Driving License
Belarus - Polycarbonate Passport
Belarus - Residence Permit
Belgium - Provisional Driving License
Belgium - Special ID Card
Bulgaria - Alien ID Card
Bulgaria - Residence Permit
Canada - New Brunswick - ID Card
Canada - Prince Edward Island - Driving License
Estonia - Polycarbonate Passport
Germany - Driver Qualification Card
Guyana - Driving License
Kuwait - Paper Passport
Lebanon - Paper Passport
Liechtenstein - Driving License
Malta - Paper Passport
Malta - Polycarbonate Passport
Moldova - Driving License
Netherlands - Alien ID Card
Oman - Paper Passport
Peru - Alien ID Card
Romania - Residence Permit
UK - Asylum Request

Added support for 28 new versions of already supported documents

Canada - British Columbia - Public Services Card
Canada - British Columbia - Driving License
Cyprus - Residence Permit
Denmark - Polycarbonate Passport
Germany - ID Card
Italy - ID Card
Ireland - Passport Card
Malta - ID Card
Montenegro - ID Card
Montenegro - Polycarbonate Passport
North Macedonia - ID Card
North Macedonia - Polycarbonate Passport
Norway - Driving License
Norway - Residence Permit
Norway - Polycarbonate Passport
Philippines - Driving License
Sweden - Polycarbonate Refugee Passport
Sweden - Social Security Card
UAE - Resident ID Card
UK - Proof of Age Card
USA - Arkansas - ID Card
USA - Colorado - ID Card
USA - Idaho - ID Card
USA - Illinois - ID Card
USA - New York - Driving License
USA - New York - ID card
USA - Pennsylvania - Driving License
USA - Washington - Driving License

Added support for 3 new versions of already supported documents in BETA

Denmark - Residence Permit
Estonia - Residence Permit
Latvia - Residence Permit

Bugfixes

We've fixed the issue with reading the information on the back side of USA/Washington and USA/Vermont driver's license documents.

Platform-related SDK changes

We've fixed a bug within our UI component when using RTL direction on Safari and Firefox browsers.

6.1.0

New features

New and improved machine learning models for data extraction
Further improved barcode scanning (parsing for non-standard US DLs)
Added anonymization for QR code on Dutch ID card
Anonymization of religion field on Malaysian documents
Device-to-device (D2D) feature - BETA (see more in UI improvements section below)

Added support for 9 new documents:

Australia - Victoria - Proof of Age Card
Brazil - Rio de Janeiro - ID Card
Liechtenstein - ID Card
Luxembourg - Passport
Mozambique - ID Card
Norway - ID Card
Togo - ID Card
USA - Wyoming - ID Card
Zimbabwe - ID Card

Added support for 9 new documents in BETA:

Barbados - ID Card
Belgium - Passport
Brazil - Rio Grande do Sul - ID Card
Ireland - Residence Permit
Japan - Residence Permit
Lithuania - Residence Permit
Saint Lucia - ID Card
USA - New Hampshire - ID Card
USA - South Dakota - ID Card

Added support for 34 new versions of already supported documents:

Belgium - Resident ID Card
Canada - Residence Permit
Estonia - ID Card
Finland - Alien ID Card
Finland - ID Card
Latvia - Alien ID Card
Lithuania - ID Card
Luxembourg - ID Card
Malta - Residence Permit
Netherlands - ID Card
Netherlands - Residence Permit
Poland - ID Card
Sweden Residence Permit
USA - Alabama - ID Card
USA - Alaska - ID Card
USA - Colorado - Driving License
USA - Connecticut - ID Card
USA - District of Colombia - Driving License
USA - District of Colombia - ID Card
USA - Iowa - ID Card
USA - Kansas - ID Card
USA - Louisiana - Driving License
USA - Maine - Driving License
USA - Maine - ID Card
USA - Minnesota - ID Card
USA - Mississippi - ID Card
USA - Nevada - Driving License
USA - New York - Driving License
USA - South Carolina - ID Card
USA - South Dakota - Driving License
USA - Texas - ID Card
USA - Vermont - Driving License
USA - Washington - ID Card
USA - Wisconsin - Driving License

Added support for 2 new versions of already supported documents in BETA:

Poland - Residence Permit
Portugal - Residence Permit

Changes to BlinkID VideoRecognizer

VideoRecognizer has been refactored.

This refactor has fixed some memory leak issues present in the previous implementation.
Now uses requestVideoFrameCallback for queuing video frames in browsers which support it.
Errors are no longer treated as rejected promises, but are instead thrown.
this.videoElement can no longer be changed or removed on the instance.
Implemented iOS browser security rules for video playback.
Added a helper this.getVideoElement method for getting the reference to the video.

Breaking changes:

NotSupportedReason has been removed and videoRecognizerErrors are used directly instead.
onScanningDone will no longer trigger on user cancellation.
setClearTimeoutCallback has been removed from the RecognizerRunner as it's effectively the same thing as onFirstSideDone — it triggers once any recognizer has anything recognized for multi-side recognizers, which is the same as RecognizerResultState.StageValid.

Environmental changes

TypeScript has been upgraded to 5.x .
Packages are now built without regenerator runtime. TSconfig compile target is now ES2020.

UI improvements

Device-to-device (D2D) feature - BETA

The idea behind the device-to-device (D2D) feature is to provide extraction functionality when the initial device has technical limitations like no camera or no support for WebAssembly. Also, it can be used to direct users to use mobile instead of web cameras for a better scanning experience. Being optimized for conference calls, web cameras often struggle with a focus which causes the image of a document to have a high level of blur thus making it hard to read.
D2D can achieve these goals without the need to restart the existing process, such as form filling. When D2D is used, the scanning process is moved from a problematic device to another auxiliary device that has the necessary requirements or better camera quality. There, the scanning will take place, and the extracted results will be sent directly between the initial and auxiliary device browsers without sending images or result data to a Microblink server.
Please check out our D2D documentation to learn more about this fantastic feature.

BlinkID MultiSide image upload

The UI component now supports image upload on both front and back sides, meaning that through our UI component, it is now possible to use the MultiSide recognizer as well.

New user instructions, help screens, that lead to successful scans

Detailed instructions on how to scan identity documents, via an intro tutorial (onboarding) or floating-action-button (FAB) during scanning, leading to improved success rates in ID scanning and data extraction.
- New properties introduced: allowHelpScreensFab, allowHelpScreensOnboarding, allowHelpScreensOnboardingPerpetuity and helpScreensTooltipPauseTimeout.

Camera selection toolbar

We've introduced the default option of camera selection through a dropdown menu of all available device cameras.
- If only one camera is available, the camera selection dropdown will not be displayed.
We've introduced icon/button for the option of mirroring the camera video feed.
Camera device names are now reported as "[Front/Back] facing camera [n]" on Android devices.

General

We've improved the responsiveness of our user interface accross different browsers for users on mobile devices.

Other platform-related SDK changes

We've improved error exposure to console.
We've fixed minor internal reporting logic issue.

6.0.1

Platform-related SDK changes

The SDK can now be used with the wasm-unsafe-eval content security policy.

Bugfixes

We've fixed a regression in the recognizer runner that could cause subsequent scans to fail.

6.0.0

New features:

Extracting ID data from Arabic and Cyrillic IDs

When we say you can scan IDs across the globe, we really mean it. Our list of supported documents got richer now that we can scan IDs including Arabic and Cyrillic scripts. This fantastic new feature also covers multiscript IDs meaning that we extract data written in both Latin and Arabic data fields.

Better barcode scanning and data extraction

We’ve improved scanning accuracy for all IDs that hold a PDF417 or other barcode types. This means that the error rate is now 20% lower, which brings even cleaner and more reliable data with every scan of an identity document.

What's new in the BlinkId(Combined) Recognizer?

Renamed BlinkIdRecognizer to BlinkIdSingleSideRecognizer
Renamed BlinkIdCombinedRecognizer to BlinkIdMultiSideRecognizer
We introduced new classes: StringResult, DateResult, and Date in order to support multiple alphabets. If a recognizer supports multiple alphabets, its result class (e.g., BlinkIdMultiSideRecognizer.Result) will return StringResult for results that previously returned String.
Added new result property of an AdditionalProcessingInfo type that provides information about missingMandatoryFields, invalidCharacterFields, and extraPresentFields
Unified DataMatchResult and DataMatchDetailedInfo into a single structure DataMatchResult (removed dataMatchDetailedInfo result member)
Added new result member cardOrientation to ImageAnalysisResult structure
More info about transitioning to BlinkID v6.0.0 can be found in Transition Guide

Added support for 50 new versions of already supported documents:

Mexico - Aguascalientes - Driving license
Mexico - Baja California - Driving license
Mexico - Hidalgo - Driving license
USA - Delaware - Driving license
USA - Florida - ID card
USA - Hawaii - Driving license
USA - Kentucky - ID card
USA - Maryland - ID card
USA - Michigan - ID card
USA - Mississippi - Driving license
USA - Mississippi - ID card
USA - Missouri - ID card
USA - Ohio - ID card
USA - Oklahoma - ID card
USA - Rhode Island - Driving license

These documents are no longer BETA:

Australia - New South Wales - ID card
Australia - South Australia - Proof of Age Card
Belgium - Minors ID card
Belgium - Passport
Canada - Tribal ID card
Canada - Weapon Permit
Canada - British Columbia - Minors Public Services Card
Ireland - Public Services Card
Israel - ID card
Ivory Coast - Driving License
Lebanon - ID card
Libya - Polycarbonate Passport
Mexico - Colima - Driving license
Mexico - Michoacan - Driving license
Mexico - Tamaulipas - Driving license
Mexico - Zacatecas - Driving license
Myanmar - Driving license
Panama - Temporary Residence Permit
Slovenia - Residence Permit
Trinidad and Tobago - Driving license
USA - Passport
USA - Maine - ID card

Added support for 2 new ID types in BETA:

Latin America and the Caribbean

Cuba - ID card
Cayman Islands - Drivers License

Already supported documents but now with option to enable extraction for new scripts

Arabic - 5 ID types

Egypt - ID card
Jordan - ID card
UAE - ID card
UAE - Passport
UAE - Resident ID

Cyrillic - 10 ID types

Bosnia and Herzegovina - ID card
Bulgaria - Drivers License
Bulgaria - ID card
North Macedonia - Drivers License
North Macedonia - ID card
Serbia - ID card
Ukraine - Drivers License
Ukraine - ID card
Ukraine - Residence Permit
Ukraine - Temporary Residence Permit

Bugfixes

We've fixed a problem with camera focus on iPhone devices that use iOS 16 or newer, most notably iPhone 14.

5.20.1

We've fixed a target endpoint for internal reporting logic.

5.20.0

New feature:

ML models with new architecture that result in further 8% decrease in error rate

Support for 8 new document types:

Northern America

USA - Polycarbonate Passport
USA - Nebraska - ID Card
USA - New York - ID Card
USA - Utah - ID Card

Latin America and the Caribbean

Mexico - Polycarbonate Passport
Brazil - Sao Paolo - ID Card

Europe

Austria - Residence Permit

Asia

Philippines - ID Card

Back side support added:

Australia - South Australia - Driving license

Added support for 29 new versions of already supported documents:

Australia - Northern Territory - Proof of Age Card
Belgium - Minors ID Card
Belgium - Residence Permit
Bolivia - ID Card
Croatia - Residence Permit
Cyprus - ID Card
Czechia - ID card
Czechia - Residence Permit
Dominican Republic - Paper Passport
Greece - Residence Permit
Italy - Residence Permit
Ivory Coast - Driving license
Kuwait - Driving license
Mexico - Jalisco - Driving license
Mexico - Nuevo Leon - Driving license
Peru - ID Card
Poland - Driving license
Slovenia - ID Card
Sweden - ID Card
Sweden - Polycarbonate Passport
USA - Georgia - ID Card
USA - Iowa - ID Card
USA - Kansas - Driving license
USA - Maryland - ID Card
USA - Nebraska - ID Card
USA - New York - Driving license
USA - New York - ID Card
USA - Oklahoma - Driving license
Vietnam - ID Card

These documents are no longer BETA:

Finland - Residence Permit
Guatemala - Driving license

Added support for 2 new ID types in BETA:

Antigua and Barbuda - Driving license
Mexico - Professional ID Card

Changes to BlinkID(Combined) Recognizer

ClassInfo:
- Added to JSON serialization:
  - isoNumericCountryCode
  - isoAlpha2CountryCode
  - isoAlpha3CountryCode
BarcodeData:
- JSON serialization update: stringData member is now in base64 format
Added new item to enums:
- Region:
  - Sao Paulo, when scanning Brazilian Driving licenses
Fixed scanning for Argentina ID - there were confusions for Veteran ID, now we enabled successful extraction on Veteran ID as well

Environment changes

We've updated environment to Node v16.3.0.

5.19.2

We've fixed a target endpoint for internal reporting logic.

5.19.1

We've fixed a major problem with internal reporting logic.

5.19.0

What's new in the BlinkID(Combined) Recognizer?

Support for atypical Vietnam passports

Extract data from Vietnam Passports that have non-ICAO compliant MRZ fields. For example, when the filler arrow is facing the other way (>) instead of the standard way (<)

Data anonymization

We've added the option to not extract the religion field on all supported Malaysian documents (MyKad, MyKas, MyKid, MyPR, MyTentera)

Bugfixes

Resolved issues with RGB color overlay when extracting document image, which was present on some devices
We've fixed a bug with CSS ::part() pseudo-selector to enable safe CSS customization of nested elements like mb-camera-toolbar.

Optimizing camera usage

We are now preventing aborting the scanning process when using the UI component until the camera is not being fully initialized due to potential issues with reusing the camera's resources.

5.18.0

New feature:

Updated machine learning models resulting in a 41% reduced error rate.

Support for 16 new document types:

Northern America

USA - Passport Card
Usa - District of Columbia - ID Card
USA - Iowa - ID Card
USA - Tennessee - ID Card

Latin America and the Caribbean

Cuba - Paper Passport
Dominican Republic - Paper Passport
Panama - Residence Permit (front onyl)
Peru - Paper Passport

Europe

Cyprus - Paper Passport
Germany - Minors Passport
UK - Proof of Age Card (front onyl)
Ukraine - Residence Permit
Ukraine - Temporrary Residence Permit

Middle East and Africa

Qatar - Paper Passport
UAE - Paper Passport

Oceania

Australia - Northern Territory - Proof of Age Card

Back side support added:

Austria - ID Card
Australia - South Australia - Driving license
Australia - Tasmania - Driving license
Canada - Quebec - Driving license
Mexico - Quintana Roo Solidaridad - Driving license
USA - Washington - Driving license

Added support for 26 new versions of already supported documents:

Afghanistan - ID Card
Bahrain - ID Card
Hungary - Residence Permit
India - ID Card
Mexico - Tabasco - Driving license
New Zealand - Driving license (front only)
The Philippines - Professional ID (front only)
Slovakia - Residence Permit
South Africa - ID Card
Switzerland - Residence Permit
UK - Driving license
USA - Colorado - Driving license
USA - Idaho - Driving license
USA - Kansas - ID Card
USA - Kentucky - Driving license
USA - Maine - Driving license
USA - Massachusetts - ID Card
USA - Nebraska - Driving license
USA - New Hampshire - Driving license
USA - New Jersey - ID Card
USA - New Mexico - ID Card
USA - North Carolina - ID Card
USA - Utah - Driving license
USA - Vermont Driving license
USA - West Virginia - Driving license

These documents are no longer BETA:

Algeria - Paper Passport
Slovakia - Residence Permit
USA - Mississippi - ID Card

Added support for 8 new ID types in BETA:

Iceland - Paper Passport
South Africa - ID Card (front only)
Brazil - Consular Passport (beta)
Quintana Roo Cozumel - Driving license
Canada - Social Security Card (front only)
Canada - British Columbia - Minor Public Services Card
USA - Maine - ID Card
USA - North Dakota - ID Card

Changes to BlinkID(Combined) Recognizer

Added new enums:
- Region: QUINTANA_ROO_COZUMEL
- Type: CONSULAR_PASSPORT, MINORS_PASSPORT, and MINORS_PUBLIC_SERVICES_CARD

Platform-related SDK changes

We've added a support for two different WebAssembly build versions.
- Standard and default build that has all the optimisations, but has considerably larger file size compared to lightweight version.
- Lighter version of the WebAssembly bundle that doesn’t have all optimizations for reading of dense barcodes with low quality cameras.

5.17.1

We've fixed a problem that has caused the enormous size of WebAssembly bundles.

5.17.0

Changes to BlinkID(Combined) Recognizer

We've introduced the expanded DataMatch functionality for the BlinkID with the new result member called dataMatchDetailedInfo
- This result member will enable you to see for which field has been performed, or it did not, the DataMatch functionality. This is enabled for dateOfBirth, documentNumber and dateOfExpiry.
- For example, if the date of expiry is scanned from the front and back side of the document and values do not match, this method will return DataMatchResult: Failed.
  - Result will be DataMatchResult: Success only if scanned values for all fields that are compared are the same. If data matching has not been performed, the result will be DataMatchResult: NotPerformed. This information is available for every of the three mentioned field values above.
We've fixed issues with scanning Argentina AlienID, where there were confusions with the regular ID. ClassInfo now correctly returns which ID type is present based on the barcode data.

Platform-related SDK changes

[BREAKING CHANGE] Due to security reasons, we've added a mechanism to load worker script from an external location.
- New property WasmSDKLoadSettings.workerLocation was added for this purpose and represents a path to the external worker script file.
- If omitted, SDK will look for the worker script in the resources directory.

UI Improvements

We've added property recognitionPauseTimeout to the UI component that defines scanning pause after the first side of a document has been scanned.
- The purpose of this property is to give the end-user enough time to flip the document before scanning is resumed.
- Default value is 3800 and represents time in milliseconds.
We've exposed property cameraExperienceStateDurations on the UI component that can be used to change the default durations of UI animations.

5.16.0

We've added new documents to our list of supported documents:

Europe

Austria - ID Card (front only)
Germany - ID Card

Latin America and the Caribbean

Brazil - ID Card (beta)
Colombia - ID Card (front only)
Ecuador - ID Card

Mexico

Baja California Sur - Driving Licence (beta)
Ciudad De Mexico - Driving Licence (front only)
Colima - Driving Licence (front only, beta)
Michoacan - Driving Licence (beta)
Nayarit - Driving Licence (beta)
Quintana Roo Solidaridad - Driving Licence (front only)
Tlaxcala - Driving Licence
Veracruz - Driving Licence (beta)

Oceania

Australia - Northern Territory (beta)

Asia

Japan - My Number Card (front only)
Singapore - Resident ID

Northern America

USA - Missouri - ID Card
USA - Nevada - Driving Licence
USA - New York City - ID Card
USA - Oklahoma - ID Card

Back side support added:

Mexico - Chiapas - Driving License

No longer BETA:

Mexico - Baja California - Driving Licence
Mexico - Chihuahua - Driving Licence
Mexico - Coahuila - Driving Licence
Mexico - Guanajuato - Driving Licence
Mexico - Mexico - Driving Licence

Changes to BlinkID(Combined) Recognizer

Added the setting saveCameraFrames for saving camera frames with the default value being false.
- New result members are also available here: frontCameraFrame, backCameraFrame, barcodeCameraFrame.
- Memory consumption significantly increases if set to true.
We've added new result members when scanning Australian Driving Licences: vehicleClass, licenceType, effectiveDate and expiryDate.
- Result member are displayed under the VehicleClassInfo field; we can also extract data from multiple rows when this vehicle class info data is present on the document (e.g. multiple expiry dates for different vehicle classes).
We've added new enum values:
- Region: QUINTANA_ROO, QUINTANA_ROO_SOLIDARIDAD, TLAXCALA which are available when scanning Mexican Driving Licences.
- Type: MY_NUMBER_CARD which is available when scanning Japanese My Number Card documents.
We've added new result member additionalOptionalAddressInformation which gives additional address information about the document owner.
- This result member can be present when scanning the Pakistani ID Card for the field Country of Stay.

Changes to IDBarcodeRecognizer

For barcodes in countries: Argentina, Colombia, Nigeria, Panama, and South Africa, we now also extract data from the field Sex when it's populated with the character "X".

Improvements

We've added support for Brazil ID Card when the cardholder's face image is rotated for 90 degrees on the document.
- We will return face image and document image + data from VIZ part present on the back side.
BlinkIdCombinedRecognizer can return the full frame from the front side if saveCameraFrames is set to true, whereas before it returned the full frame only for the back side.

5.15.2

We removed digitalSignature property and related recognizer options

5.15.1

We've updated Microblink logo and colors

5.15.0

We support the latest versions of these documents:

Europe

Belgium - Driving License (front only)
Croatia - ID Card
France - ID Card
France - Residence Permit (beta)
Spain - ID Card
Switzerland - Residence Permit
UK - Residence Permit

Oceania

Australia - Northern Territory - Driving License (front only, beta)

Middle East and Africa

UAE - ID Card
UAE - Resident ID

Northern America

Honduras - ID Card (beta)
USA - Colorado - ID Card
USA - Minnesota - Driving License
USA - Nevada - Driving License
USA - Oklahoma - Driving License
USA - Wyoming - Driving License

Changes to BlinkID(Combined) Recognizer

No API changes

Improvements

We now support DataMatch functionality on single side documents (Passports)
- We added a special case to support DataMatch for UAE ID Card and Resident ID Card documents for the field personal_id_number
We can now extract additional_personal_id_number on Ecuador ID Card
We've made improvements for reading NRIC number on Malaysian documents that have an asterisk (*) character present
We've improved document detection and cropping of the document image

Changes to IDBarcodeRecognizer

We've added document type ArgentinaAlienID and parser for ArgentinaAlienID2012BarcodeParser

Platform-related SDK changes

We've added methods for programmatically starting camera and image scan when using the UI component.
- It's possible to call startCameraScan() and startImageScan(File) methods on the custom web element.
We've standardized error structures returned from the WebAssembly library and the UI component.
- See SDKError.ts and ErrorTypes.ts for a complete list of possible error codes.
We've completed support for part:: selector and added an example.
We've simplified integration of the UI component with Angular and React frameworks.
- Integration guide for Angular
- Integration guide for React

Bug fixes

We've ensured that all SDK errors can be visible from fatalError and scanError events in the UI component.

5.14.2

We've expanded support for part:: selector by exposing all nested web components.
We've fixed styles regarding width and height for camera scanning UI to provide more flexibility to developers.

5.14.1

We've added support for part:: selector to provide more flexibility when customizing built-in UI. #35

UI bug fixes

We've fixed a bug where a user couldn't upload an image after the camera scan failed to start.
We've fixed a bug where the video feed wasn't released in the scenario where the UI component was removed from the DOM.
We've reverted style changes regarding width and height for camera scanning UI to provide more flexibility to developers.
We've improved memory management during the initialization of the UI component to avoid the creation of unnecessary web workers.

5.14.0

Back side support added:

Thailand - ID Card

Improvements

Extraction of father’s and mother’s names from Mexico Voter ID Card
The driver license unique card number is extracted as document_additional_number for Australian Driving Licenses, regions New South Wales, Northern Territory, Queensland, Victoria and Western Australia
We've improved the accuracy of barcode scanning on identity documents

Changes to BlinkID(Combined) Recognizer

We've added two new result fields - fathersName and mothersName both in BlinkID and BlinkIDCombined Recognizers, as well as in VIZ result

Changes to BarcodeRecognizer

We’ve removed support for aztec and dataMatrix barcode formats

Changes to MRTDRecognizer

We've added MRTD_TYPE_BORDER_CROSSING_CARD type to MRTD enum

Platform-related SDK changes

We've added a camera management UI module for the selection of connected cameras
- We've added VideoRecognizer.changeCameraDevice method that can be used to change the active camera device during the scanning session
We've improved accessibility of the UI component by changing background contrasts and increasing default font sizes

Bug fixes

We've optimised memory usage of the SDK by fixing a problem where every refresh of the UI component would result in a new instance of web worker

5.13.0

New additions to our supported document list

We’ve added 61 new documents:

Europe

Austria - Paper Passport
Belarus - Paper Passport
Belgium - Paper Passport (beta)
Bulgaria - Paper Passport
Estonia - Paper Passport
France - Paper Passport (beta)
Georgia - Paper Passport (beta)
Germany - Paper Passport
Greece - Paper Passport
Hungary- Paper Passport
Italy - Paper Passport (beta)
Kosovo - Paper Passport
Moldova - Paper Passport (beta)
Poland - Paper Passport
Portugal - Paper Passport
Spain - Paper Passport
Switzerland - Paper Passport
UK - Paper Passport

Middle East and Africa

Algeria - Paper Passport (beta)
Egypt - Paper Passport (beta)
Eswatini - Paper Passport
Ghana - Paper Passport
Iran - Paper Passport (beta)
Iraq - Paper Passport (beta)
Israel - Paper Passport (beta)
Jordan - Paper Passport (beta)
Kenya - Polycarbonate Passport
Libya - Polycarbonate Passport (beta)
Morocco - Paper Passport (beta)
Nigeria - Paper Passport
Nigeria - Polycarbonate Passport (beta)
Qatar - ID Card (front only, beta)
Saudi Arabia - Paper Passport
Syria - Paper Passport
Tanzania - ID Card (beta)
Tanzania - Voter ID (front only, beta)
Tunisia - Paper Passport
Turkey - Paper Passport
Zimbabwe - Paper Passport

Latin America and the Caribbean

Argentina - Paper Passport
Brazil - Paper Passport (beta)
Guatemala - Paper Passport
Haiti - Paper Passport
Honduras - Paper Passport (beta)
Mexico - Paper Passport (beta)
Mexico - Nayarit - Driving Licence (beta)

Asia

Bangladesh - Paper Passport
China - Paper Passport (beta)
India - Paper Passport
Indonesia - Paper Passport
Japan - Paper Passport
Nepal - Paper Passport
Pakistan - Paper Passport
Philippines - Paper Passport
South Korea - Paper Passport (beta)
Sri Lanka - Paper Passport
Uzbekistan - Paper Passport

Oceania

Australia - Paper Passport

Northern America

Canada - Paper Passport
Canada - Weapon Permit (front only, beta)
USA - Paper Passport (beta)

Back side support added:

Greece - ID Card
Burkina Faso - ID Card
Democratic Republic of the Congo - Driving Licence
Mexico - Veracruz - Driving Licence
Canada - Citizenship Certificate

No longer BETA:

Belarus - Driving Licence
UK - Polycarbonate Passport
Argentina - Alien ID
Bahamas - Driving Licence
Mexico - Durango - Driving Licence
Venezuela - ID Card
USA - Kansas - ID Card

Changes to BlinkID(Combined) Recognizer

We’ve renamed the Swaziland country to Eswatini in results and ClassInfo structure
Improved result validation
- FieldIdentificationFailed processing status is used to indicate if unexpected fields are present on the document. Those fields are then deleted from the result
We are filling out COUNTRY and REGION fields in ClassInfo, without the field TYPE of document, when using BarcodeID mode for scanning documents where the Front side is not supported, and back side results are extracted from AAMVA compliant barcodes
- This applies only if ClassInfo isn’t already prepopulated in some other way and when you’re not in FullRecognition mode

Improvements

We can now extract the date of birth from the document number on the South Korean identity card and from the personal identification number on the driving licence

Anonymization

We’ve added anonymization support for new documents:
- Document number on Germany paper bio-data page Passport
- Document number on South Korea Identity Card
- Personal identification number on South Korea driving licence
- Personal identification number on South Korea paper bio-data page Passport

Platform-related SDK changes

We've improved the performance of the SDK by adding support for WebAssembly SIMD.
- This increases the scanning performance on compatible browsers up to 77% and up to 94% in cases when WebAssembly threads are also supported.
- Keep in mind that this feature requires a compatible browser (Chrome 91 and Firefox 90 or newer versions). Only advanced and advanced-threads binaries are using SIMD. In case that the browser doesn't support this feature, basic binary will be used.
We've reduced the memory fragmentation during video processing, resulting in a smaller memory footprint.

5.12.0

New additions to our supported documents list

We've added 15 new documents:

Europe

North Macedonia - Polycarbonate Passport

Middle East and Africa

Botswana - ID Card
Sudan - Polycarbonate Passport

Latin America & the Caribbean

Mexico - Baja California Sur - Driving Licence (beta)
Mexico - Campeche - Driving Licence (beta)
Mexico - Colima - Driving Licence (beta)

Oceania

Australia - Health Insurance Card (front only, beta)

Asia

Azerbaijan - Polycarbonate Passport (beta)
Tajikistan - Polycarbonate Passport (beta)

Northern America

Canada - Citizenship Certificate (front only, beta)
Canada - Ontario - Health Insurance Card (front only)
Canada - Quebec - Health Insurance Card (front only, beta)
USA - Military ID Card
USA - Rhode Island - ID Card
USA - South Carolina - ID Card

Back side support added:

Ireland - Passport Card
Mexico - Puebla - Driving Licence
Singapore - S PASS

No longer BETA:

Finland - Polycarbonate Passport
Ireland - Passport Card
Ireland - Polycarbonate Passport
Kosovo - Driving Licence
Latvia - Polycarbonate Alien Passport
Latvia - Polycarbonate Passport
Poland - Polycarbonate Passport
Cameroon - ID Card
Ghana - ID Card
Iraq - ID Card
Tanzania - Driving Licence
Turkey - Polycarbonate Passport
Uganda - Driving Licence
Bolivia - Minors ID
Chile - Driving Licence
Ecuador - Driving Licence
Haiti - Driving Licence
India - Karnataka - Driving Licence
India - Maharashtra - Driving Licence
Pakistan - Punjab - Driving Licence
USA - Global Entry Card
USA - New Mexico - ID Card
USA - Wisconsin - ID Card

Changes to BlinkID(Combined) Recognizer

We've added the parameter maxAllowedMismatchesPerField to settings. When this is set to a non-zero value, DataMatch will pass as long as the number of mismatched characters doesn't exceed the specified value.
We've enabled the return of image and back-side data results, even when the State is Uncertain. Keep in mind that returned images, in this case, might be blurry or low quality.
- This applies to all images: face image, full document image, and signature image.

Improvements

We can now extract information from NRIC numbers on Malaysian documents that have the asterisk (*) character in it.
While using FullRecognitionMode for scanning unsupported Passports, we are now taking ClassInfo from MRZ
We are now correctly handling fully cropped vertical images
Fix for correct parsing of Bermuda Driving Licence AAMVA-compliant barcode dates
Fix for correct calculation of check digit for Saudi Arabia ID Card MRZ

Postprocess improvement

We are splitting names and descriptors into two different results (e.g., Nom d’ usage, Epouse, Geb. etc.), where descriptors are in their separate field name_additional_info, for these documents:
- France
  - ID Card
  - Residence Permit
- Germany
  - ID Card
- Luxembourg
  - ID Card
- Netherlands
  - Driving Licence
  - Polycarbonate Passport

Sanitization of names

We are removing title prefixes (e.g., Mrs., Mr., Ing., etc.) from full_name, first_name and last_name for these documents:
- Austria
  - Driving Licence
  - ID Card
- Czechia
  - Driving Licence
- Germany
  - ID Card
- Thailand
  - ID Card
- UK
  - Driving Licence

Anonymization

We've added anonymization support for new documents:
- Document number on Germany Polycarbonate Passport
- Document number on Hong Kong Polycarbonate Passport
- Document number, personal ID number on Singapore Polycarbonate Passport

SDK changes

We've added a mechanism to automatically delete an instance of worker script in case of unsuccessful SDK initialization.
- New method WasmSDK.delete() was added for this purpose and is available on every instance of the SDK.
We've changed improper error handling in the VideoRecognizer class.
- From now on, it's possible to catch all errors that happen during the video recognition.

5.11.4

Generated missing assets when UI component is used as NPM package

5.11.3

We’ve fixed a bug that would cause recognizerOptions to work incorrectly on still images

5.11.2

SDK changes

We've exposed a couple of functions that are used by the SDK to determine which WebAssembly bundle to load and from which location
- Function detectWasmType() returns the best possible WebAssembly bundle based on the features a browser supports.
- Function wasmFolder( WasmType ) returns the name of the resources subfolder of the provided WebAssembly bundle type.
- For more information on how to implement these functions, see WasmLoadUtils.ts file.

UI Improvements

You can now set a camera feedback message to the user when BlinkID IDBarcode recognizer is used
- Set showCameraFeedbackBarcodeMessage property to display a custom message.
- Use translations property to translate a custom message.
Camera rectangle cursor is more responsive now when BlinkID IDBarcode recognizer is used.

Bugfixes

Container width size on UI component for action label (Scan or choose from gallery) and action buttons (Device camera and From gallery) are now responsive on Safari.

5.11.1

We've fixed a broken rollup.config.js which resulted in unusable UMD development bundle

5.11.0

Breaking changes

We've changed the way how recognizer options are set up when using the UI component
- You can now specify how a recognizer should behave by using the new recognizerOptions property.
- To see the full list of available recognizer options, as well as examples on how to use them, check out the relevant source code.
We've removed property and attribute anonymization from the UI component since it can now be defined with the new recognizerOptions property

Newly supported identity documents:

We’ve added 98 new documents:

Europe

Albania - Driver Card (front only)
Albania - Professional Driver License (front only)
Belarus - Driver License (front only, beta)
Belgium - Minors ID (beta)
Czechia - Residence Permit
Finland - Alien ID
Finland - Residence Permit (beta)
Georgia - Driver License (front only)
Greece - Residence Permit
Ireland - Passport Card (beta)
Ireland - Public Services Card (beta)
Kosovo - Driver License (front only, beta)
Latvia - Alien ID
Luxembourg - ID Card
Moldova - ID Card (beta)
North Macedonia - Driver License (front only)
North Macedonia - ID Card
Poland - Passport (beta)
Slovenia - Residence Permit (beta)
Spain - Alien ID
UK - Passport (beta)

Middle East and Africa

Algeria - Driver License
Burkina Faso - ID Card (front only)
Cameroon - ID Card (beta)
Democratic Republic Of The Congo - Driver License (front only, beta)
Egypt - Driver License (beta)
Ghana - ID Card (beta)
Iraq - ID Card (beta)
Ivory Coast - Driver License (front only, beta)
Ivory Coast - ID Card
Lebanon - ID Card (beta)
Morocco - Driver License
Mozambique - Driver License (front only, beta)
Oman - Driver License (beta)
Rwanda - ID Card (front only)
Senegal - ID Card
Tanzania - Driver License (front only, beta)
Tunisia - Driver License (front only)
Uganda - Driver License (front only, beta)

Latin America & the Caribbean

Argentina - Alien ID (beta)
Bahamas - ID Card (front only, beta)
Bolivia - Minors ID (beta)
Jamaica - Driver License
Mexico - Residence Permit (beta)
Mexico - Chiapas - Driver License (front only)
Mexico - Coahuila - Driver License (beta)
Mexico - Durango - Driver License(front only, beta)
Mexico - Guerrero-cocula - Driver License (beta)
Mexico - Guerrero-juchitan - Driver License (beta)
Mexico - Guerrero-tepecoacuilco - Driver License (front only, beta)
Mexico - Guerrero-tlacoapa - Driver License (front only, beta)
Mexico - Hidalgo - Driver License
Mexico - Mexico - Driver License (beta)
Mexico - Morelos - Driver License (front only)
Mexico - Oaxaca - Driver License
Mexico - Puebla - Driver License (front only, beta)
Mexico - San Luis Potosi - Driver License (front only)
Mexico - Sinaloa - Driver License (front only, beta)
Mexico - Sonora - Driver License (beta)
Mexico - Tabasco - Driver License (beta)
Mexico - Yucatan - Driver License (beta)
Mexico - Zacatecas - Driver License (beta)
Panama - Temporary Residence Permit (beta)
Peru - Minors ID (beta)
Trinidad And Tobago - Driver License (front only, beta)
Trinidad And Tobago - ID Card

Oceania

Australia - South Australia - Proof Of Age Card (front only, beta)

Asia

Armenia - ID Card
Bangladesh - Driver License (beta)
Cambodia - Driver License (front only, beta)
India - Gujarat - Driving Licence (front only, beta)
India - Karnataka - Driving Licence (front only, beta)
India - Kerala - Driving Licence (beta)
India - Madhya Pradesh - Driving Licence (front only, beta)
India - Maharashtra - Driving Licence (front only, beta)
India - Punjab - Driving Licence (front only, beta)
India - Tamil Nadu - Driving Licence (beta)
Kyrgyzstan - ID Card
Malaysia - Mypolis (beta)
Malaysia - Refugee ID (front only)
Myanmar - Driver License (beta)
Pakistan - Punjab - Driving Licence (front only, beta)
Sri Lanka - Driving Licence (front only)
Thailand - Alien ID (front only)
Thailand - Driver License (beta)
Uzbekistan - Driver License (front only, beta)

Northern America

Canada - Tribal ID (beta)
Canada - Nova Scotia - ID Card (beta)
Canada - Saskatchewan - ID Card (beta)
USA - Border Crossing Card (front only)
USA - Global Entry Card (beta)
USA - Nexus Card (beta)
USA - Veteran ID (front only)
USA - Work Permit
USA - Mississippi - ID Card (beta)
USA - Montana - ID Card
USA - New Mexico - ID Card (beta)
USA - Wisconsin - ID Card (beta)

Back side support added:

Hungary - Residence Permit
Luxembourg - Residence Permit (no longer beta)
Mauritius - ID Card
Colombia - Alien ID (no longer beta)
Mexico - Baja California - Driver License
Mexico - Chihuahua - Driver License
Mexico - Guanajuato - Driver License
Mexico - Michoacan - Driver License
Malaysia - MyKid
Malaysia - MyPR

No longer beta:

Albania - Passport
Malta - Residence Permit
Switzerland - Residence Permit
Bolivia - Driver License
Chile - Passport
El Salvador - ID Card
Peru - ID Card
Singapore - S Pass (front only)

Changes to the BlinkId(Combined)Recognizer

You can now retrieve an image of the document owner along with cropped images of the document itself whenever you’re scanning an AAMVA-compliant ID:
- Using BarcodeId as a RecognitionMode lets you scan US driver licenses and IDs that BlinkID can’t read from the Visual Inspection Zone (VIZ) alone. Use it to extract:
  - A face image from the front side
  - Barcode data from the back side
  - Cropped document images of both sides
- You can disable this RecognitionMode by setting enableBarcodeId to false in the RecognitionModeFilter.
We've improved data extraction through the MRZ:
- We now allow standard M/F values for gender on Mexican documents (along with localized H/M values)
We're now converting dates to the Gregorian calendar for:
- Taiwan documents with Republic of China (ROC) calendar dates
- Saudi documents with Islamic calendar dates
We're now auto-filling all ‘partial’ dates found on identity documents (showing year or month-year only):
- Date of issue will be converted to the first day of the (first) month
  - E.g. '1999' will be converted to '01.01.1999.'
  - E.g. '03.1999.' will be converted to '01.03.1999.'
- Date of expiry will be converted to the last day of the (last) month
  - E.g. '1999' will be converted to '31.12.1999.'
  - E.g. '03.1999.' will be converted to '31.03.1999.'

Changes to the UI component

You can now scan identity documents with barcodes, for example US driver’s licenses, with BlinkId(Combined)Recognizer
- A user will now receive a feedback message whenever barcode scanning is taking place, with instructions to point the camera closer to the barcode, if needs be.
- This change should result in better results when scanning the aforementioned documents.

Performance improvements

We've added three different flavors of WebAssembly builds to the SDK, to provide better performance across all browsers
- Unless defined otherwise, the SDK will load the best possible bundle during initialization:
  - Basic Same as the existing WebAssembly build, most compatible, but least performant.
  - Advanced WebAssembly build that provides better performance but requires a browser with advanced features.
  - AdvancedWithThreads Most performant WebAssembly build which requires a proper setup of COOP and COEP headers on the server-side.
- For more information about different WebAssembly builds and how to use them properly, check out the relevant section in our official documentation

Bugfixes

We fixed the initialization problem that prevented the SDK from loading on iOS 13 and older versions

5.10.2

Constructor of VideoRecognizer class is now public

5.10.1

It's now possible to define anonymization mode when using UI component
- The default value of anonymization mode is AnonymizationMode.FullResults which means certain documents are anonymized by default.
- To change default value set attribute/property anonymization to one of supported values None, ImageOnly, ResultFieldsOnly or FullResult.

5.10.0

Newly supported identity documents

Saudi Arabia - DL (front)
Saudi Arabia - Resident ID (front)

Changes to the BlinkId(Combined)Recognizer:

We're now able to extract the additional address on Hungary Address Cards
We've improved data extraction through the MRZ:
- We now return the document type through ClassInfo, regardless of the RecognitionMode you're using (MrzId, MrzPassport or MrzVisa).
- This means you can now use ClassFilter to filter these documents by their type.
- We now return the document number on Nigeria IDs complete with its check digit.
- We now support Italy Residence Permits with a CR document code.
We've extended the ClassInfo structure with helper methods so you can filter documents by country more easily:
- Use countryName, isoNumericCountryCode, isoAlpha2CountryCode and isoAlpha3CountryCode to get the full country names or their representative codes, as defined by ISO.
We've extended the BarcodeResult structure with extendedElements
- You can find all data from AAMVA-compliant barcodes under their respective BarcodeElementKey in the BarcodeElements structure.
- For a full list of keys please see here.
We've added another ProcessingStatus called AwaitingOtherSide
- This status is triggered once BlinkID has finished with the first side of a document and expects the other side, too.
We're now able to extract the date of birth from the CURP field on Mexico Voter IDs
We've added a new recognition mode for recognizing still images of documents that have already been cropped:
- Set the scanCroppedDocumentImage to true when you're feeding BlinkID images of documents that have already been cropped and don't require detection.
- Keep in mind that this setting won't work on document images that haven't been properly cropped.

Changes to the IdBarcodeRecognizer:

We've extended the results with extendedElements
- You can find all data from AAMVA-compliant barcodes under their respective BarcodeElementKey in the BarcodeElements structure.
- For a full list of keys please see here.

Deprecated recognizers:

We've deprecated UsdlRecognizer. Please use IdBarcodeRecognizer instead

Changes to the UI component:

We’ve added new ways you can configure the UI component to better fit the way your app looks and behaves.
- For a full list of attributes, properties and events you can modify, please see the API documentation.
- For a full list of CSS variables please see _globals.scss file.

Changes to RecognizerRunner class:

Invoking RecognizerRunner.processImage on multiple still images will no longer implicitly reset the recognizer chain.
- This means you can now use BlinkIdCombinedRecognizer to scan both sides of a document by giving it two still images.
- If you still need to reset the recognizers, you can do that manually by invoking the RecognizerRunner.resetRecognizers function.
- A complete example of how to use BlinkIdCombinedRecognizer with still images has been added here.

5.9.1

We've fixed NPM package which had obsolete UI component

5.9.0

New additions to our supported documents list

53 documents added:
- ALBANIA - DL (front)
- BELGIUM - RESIDENCE PERMIT (front, back)
- BOLIVIA - ID (front, back)
- BOSNIA AND HERZEGOVINA - PASSPORT
- CAMBODIA - PASSPORT
- CANADA - RESIDENCE PERMIT (front, back)
- CANADA - MANITOBA - ID (front)
- CANADA - ONTARIO - HEALTH INSURANCE CARD (front)
- CHILE - ALIEN ID (front, back)
- CHINA - ID (front, back)
- COLOMBIA - MINORS ID (front, back)
- CYPRUS - RESIDENCE PERMIT (front, back)
- CZECHIA - PASSPORT
- GREECE - ID (front)
- HAITI - ID (front, back)
- ITALY - RESIDENCE PERMIT (front, back)
- LATVIA - DL (front)
- LATVIA - PASSPORT
- LITHUANIA - PASSPORT
- LUXEMBOURG - DL (front)
- MONTENEGRO - DL (front)
- MONTENEGRO - ID (front, back)
- MONTENEGRO - PASSPORT
- NETHERLANDS - RESIDENCE PERMIT (front, back)
- NICARAGUA - ID (front, back)
- NIGERIA - ID (front, back)
- NORWAY - RESIDENCE PERMIT (front, back)
- OMAN - RESIDENT ID (front, back)
- PARAGUAY - DL (front, back)
- PERU - DL (front, back)
- PHILIPPINES - SOCIAL SECURITY CARD (front)
- ROMANIA - PASSPORT
- RUSSIA - PASSPORT
- SERBIA - PASSPORT
- SLOVAKIA - PASSPORT
- SLOVENIA - PASSPORT
- SOUTH KOREA - DL (front)
- SPAIN - RESIDENCE PERMIT (front, back)
- SWEDEN - RESIDENCE PERMIT (front, back)
- THAILAND - PASSPORT
- UKRAINE - DL (front)
- UKRAINE - PASSPORT
- USA - ARKANSAS - ID (front, back)
- USA - CONNECTICUT - ID (front, back)
- USA - GREEN CARD (front, back)
- USA - MARYLAND - ID (front, back)
- USA - MINNESOTA - ID (front, back)
- USA - NEVADA - ID (front, back)
- USA - NEW YORK CITY - ID (front, back)
- USA - TEXAS - WEAPON PERMIT (front)
- USA - VIRGINIA - ID (front, back)
- VENEZUELA - DL (front)
- VENEZUELA - PASSPORT
Beta support added for 46 documents:
- ALBANIA - PASSPORT
- BAHAMAS - DL (front)
- BERMUDA - DL (front)
- BOLIVIA - DL (front)
- CHILE - DL (front)
- COLOMBIA - ALIEN ID (front)
- DENMARK - RESIDENCE PERMIT (front, back)
- DOMINICAN REPUBLIC - DL (front, back)
- ECUADOR - DL (front)
- EL SALVADOR - DL (front, back)
- ESTONIA - RESIDENCE PERMIT (front, back)
- GUATEMALA - DL (front, back)
- HAITI - DL (front)
- HONDURAS - DL (front, back)
- HONDURAS - ID (front, back)
- HUNGARY - ADDRESS CARD (front, back)
- HUNGARY - RESIDENCE PERMIT (front)
- ICELAND - DL (front)
- ISRAEL - ID (front, back)
- JAPAN - DL (front)
- JORDAN - DL (front)
- LATVIA - ALIEN PASSPORT
- LATVIA - RESIDENCE PERMIT (front, back)
- LUXEMBOURG - RESIDENCE PERMIT (front)
- MALTA - RESIDENCE PERMIT (front, back)
- MEXICO - BAJA CALIFORNIA - DL (front)
- MEXICO - CHIHUAHUA - DL (front)
- MEXICO - CIUDAD DE MEXICO - DL (front)
- MEXICO - PROFESSIONAL DL (front)
- MEXICO - GUANAJUATO - DL (front)
- MEXICO - MICHOACAN - DL (front)
- MEXICO - TAMAULIPAS - DL (front, back)
- MEXICO - VERACRUZ - DL (front, back)
- PHILIPPINES - TAX ID (front)
- PHILIPPINES - VOTER ID (front)
- POLAND - RESIDENCE PERMIT (front, back)
- PORTUGAL - RESIDENCE PERMIT (front, back)
- PUERTO RICO - VOTER ID (front)
- SLOVAKIA - RESIDENCE PERMIT (front, back)
- SOUTH KOREA - ID (front)
- SWITZERLAND - RESIDENCE PERMIT (front, back)
- TAIWAN - TEMPORARY RESIDENCE PERMIT (front)
- TURKEY - RESIDENCE PERMIT (front)
- USA - KANSAS - ID (front, back)
- VENEZUELA - ID (front)
- VIETNAM - DL (front)
Added back side support for 7 documents:
- ARGENTINA - ID
- ECUADOR - ID
- FINLAND - ID
- NIGERIA - DL
- QATAR - RESIDENCE PERMIT
- URUGUAY - ID
- USA - NEW YORK - DL
9 documents are no longer beta:
- BRAZIL - DL
- CANADA - ALBERTA - ID
- MALAYSIA - MyKAS
- MEXICO - NUEVO LEON - DL
- PANAMA - DL
- PORTUGAL - DL
- SAUDI ARABIA - ID
- SRI LANKA - ID
- USA - IDAHO - ID

New features and updates to the BlinkId(Combined)Recognizer

We’re now able to read partial MRZ formats (2.5 lines), like the ones found on Switzerland and Liechtenstein DLs.
We’ve added **documentOptionalAdditionalNumber** to the main part of the result, as well as front and back side VIZ results.
We’ve expanded the set of possible recognizer states with **StageValid**. This state fixes BlinkIDCombinedRecognizer timeout issues, and enables better control of the Combined scanning pipeline. It activates when the first side of a document has been successfully scanned and scanning of the second side is required.

Camera management updates

We've enabled camera image flipping
- Method flipCamera has been added to VideoRecognizer.
- You can now let your users mirror the camera image vertically.
- By default, the UI component will display a flip icon in the top left corner once the camera is live.
We've improved camera management on devices with multiple cameras
- Method createVideoRecognizerFromCameraStream has been extended in VideoRecognizer class.
- Attribute [camera-id] has been added to the UI component so that your users can preselect their desired camera.

Fixes

We’ve fixed an uncommon bug where you’d get incomplete results upon scanning of the MRZ with the allowUnparsed setting enabled.
We've fixed a problem where the UI component would interfere with navigation strategy in SPA frameworks.
- Value of the href attribute in button elements has been changed to javascript:void(0).

5.8.1

Fixed NPM package to include UI component.

5.8.0

New additions to our supported documents list

Plastic page passports

We added support for scanning the visual inspection zone - VIZ includes everything except MRZ or barcode. Keep in mind that BlinkID scans and extracts data only from the VIZ that is on the first plastic page found in the passport list below:

Chile Passport (BETA)
Colombia Passport
Croatia Passport
Denmark Passport
Finland Passport (BETA)
Germany Passport
Hong Kong Passport (BETA)
Ireland Passport (BETA)
Malaysia Passport
Netherlands Passport
New Zealand Passport
Norway Passport
Singapore Passport
South Africa Passport
Sweden Passport
Turkey Passport (BETA)

Vertical US documents

California ID
Illinois ID
New York ID
North Carolina ID
Texas ID

European DLs with a single line MRZ

BlinkID extracts data from driver’s licenses that contain single line MRZ:

Croatia DL
Estonia DL
France DL
Ireland DL
Netherlands DL
Slovakia DL

Back side supported on:

Azerbaijan ID
Singapore DL
Singapore Employment Pass

No longer BETA

Slovakia DL

New features and updates in BlinkID(Combined)Recognizer

We added signatureImage to the result. Extract signature image from the documents below:
- Australia Victoria DL
- Austria ID
- Austria DL
- Brunei Military ID
- Colombia ID
- Croatia ID (on 2013 and 2015 versions)
- Cyprus ID
- Czechia ID (on the 2012 version)
- Germany ID (2010 version)
- Germany DL (2013 version)
- Indonesia ID
- Ireland DL
- Italy DL
- Mexico Voter ID
- New Zealand DL
- Slovenia ID
- Spain DL
- Sweden DL
- Switzerland ID
- UAE ID
- UAE Resident ID
We enabled extraction of the date of birth from the NRIC from Malaysian documents:
- MyKad
- MyKas
- MyKid
- MyPR
- MyTentera
We added anonymization support for:
- MRZ (OPT2 containing the ID number) on China Mainland Travel Permit Hong Kong
- MRZ (Document number) on Germany Alien Passport
- Document number, MRZ (Document number) on Germany ID
- MRZ (Document number) on Germany Minors Passport
- MRZ (Document number) on Germany Passport
- Document number on Hong Kong ID
- MRZ (Document number, OPT1 containing the passport or ID number) on Hong Kong Passport
- Personal ID number on Netherlands DL
- Personal ID number, MRZ (OPT1 containing the BSN) on Netherlands ID
- MRZ (OPT1 containing the BSN) on Netherlands Passport
- Document number on Singapore DL
- Personal ID number on Singapore Employment Pass
- Document number on Singapore FIN Card
- Document number on Singapore ID
- MRZ (Document number, OPT1 containing the NRIC) on Singapore Passport
- Document number on Singapore Resident ID
- Document number on Singapore S Pass
- Personal ID number on Singapore Work Permit
- MRZ (OPT1 containing the resident registration number) on South Korea Diplomatic Passport
- MRZ (OPT1 containing the resident registration number) on South Korea Passport
- MRZ (OPT1 containing the resident registration number) on South Korea Residence Passport
- MRZ (OPT1 containing the resident registration number) on South Korea Service Passport
- MRZ (OPT1 containing the resident registration number) on South Korea Temporary Passport
We improved MRZ data extraction on:
- Russia Passport
Added additional recognizer options:
- BarcodeScanningStartedCallback callback that is invoked when barcode recognition is started.
- ClassifierCallback callback that is invoked when document classification is completed.
- allowedDocumentClasses property which indicates whether the given document is supported or not.
Added support for filtering only specific document classes.

UI component

We added a UI component in the format of a custom web element to use BlinkID on your web in an effortless way.
Check out the README file for instructions on how to use UI component, or check the ui directory for complete source code.

Other features and updates

We added the field middleName to BlinkID(Combined)Recognizer, IDBarcodeRecognizer and USDL(Combined)Recognizer results. This field is extracted from AAMVA standard compliant barcodes, whenever available.

Minor API changes

We removed workerLocation property from WasmSDKLoadSettings.
- Web worker is now inlined into the source code, which simplifies the SDK deployment and usage.
- Property engineLocation in WasmSDKLoadSettings must be an absolute path.
- Removed useWebWorker property from WasmSDKLoadSettings, since web worker is now always used as it provides much better user experience and does not block the UI browser thread.

Fixes

We improved the data match logic for Guatemala Consular ID in BlinkID(Combined)Recognizer.
We fixed the initialization promise chain so that you can handle all initialization errors with a single error handler (Issue #13).

5.7.0

New features:

IDBarcodeRecognizer now returns:
- Street, postal code, city and jurisdiction.
In BlinkIDRecognizer and BlinkIDCombinedRecognizer, we added:
- Support for US driver licenses with vertical orientations:
  - Alabama
  - Arizona
  - California
  - Colorado
  - Connecticut
  - Georgia
  - Illinois
  - Iowa
  - Kansas
  - Kentucky
  - Maryland
  - Massachusetts
  - Minnesota
  - Missouri
  - New Jersey
  - Ohio
  - Pennsylvania
  - South Carolina
  - Tennessee
  - Texas
  - Utah
  - Washington
  - Wisconsin
- Support for new document types:
  - Croatia Health Insurance Card / front side / BETA
  - Ecuador ID / front side
  - El Salvador ID / BETA
  - Sri Lanka ID / BETA
- Driver licenses no longer in BETA:
  - Canada Nova Scotia
  - Canada Yukon
  - Norway
- Back side support:
  - Kenya ID
- We added support for new MRZ formats on:
  - Guatemala ID
  - Kenya ID
  - Mexico consular ID
  - Northern Cyprus ID
  - Chinese Mainland Travel Permits (Hong Kong, Macau and Taiwan)
Added result anonymization. With this option enabled, results are not returned for protected fields on documents listed here. The full document image will also have this data blacked out.
- Protected fields are:
  - Document number on Hong Kong ID
  - MRZ on Hong Kong passports and Chinese mainland travel permits for Hong Kong
  - Personal ID number on Netherlands driver licence
  - Personal ID number and MRZ on Netherlands ID
  - MRZ on Netherlands passports
  - Document number on Singapore driver license, ID, Fin Card, Resident ID
  - Personal ID number on Singapore Employment Pass
  - Document number and personal ID number on Singapore Work Permit
  - MRZ on Singapore passports
- By using setAnonymizationMode method, you can choose the AnonymizationMode: ImageOnly, ResultFieldsOnly, FullResult or None.
- FullResult anonymization (both images and data) is set by default.

Improvements to existing features:

We made changes to the result structure of BlinkIdCombinedRecognizer and BlinkIdRecognizer:
- Barcode data is now encapsulated in its own result structure: BarcodeResult.
- Data from all OCR-ed fields, without MRZ data, is now encapsulated in a VIZResult structure, representing the "Visual Inspection Zone" data. In BlinkIdCombinedRecognizer, front side data is available in its own structure (frontVizResult), back side data in its own (backVizResult), so you can now access data from each side separately.
- The main part of the result, outside these structures, is filled according to these rules:
  - The document number is filled with MRZ data, if present.
  - The remaining data is then filled from the barcode.
  - The remaining data is filled from back side visual inspection zone (OCR data outside of MRZ).
  - The remaining data is filled from the front side visual inspection zone.
  - The remaining data is filled from the MRZ.
Members colorStatus and moireStatus can now be found in the result's imageAnalysisResult (frontImageAnalysisResult and backImageAnalysisResult in BlinkIDCombinedRecognizer).
We added blur detection status to imageAnalysisResult.
- We extended ImageAnalysisResult with information on whether the document contains a photo, MRZ and/or barcode.
  - We renamed DocumentImageMoireStatus to ImageAnalysisDetectionStatus so it can be reused for other status information.
- We added a RecognitionModeFilter setting. This makes it possible to control for which group of documents (MrzId, MrzVisa, MrzPassport, PhotoId, FullRecognition) recognition is enabled or disabled.
- We added a RecognitionMode result member detailing which of the aforementioned recognition modes was used to obtain the result.
- We added a fallback method that extracts ‘sex’ and ‘nationality’ fields from the MRZ in case they aren’t present in the VIZ or the barcode. Previously, only ‘dates’, ‘names’ and ‘document numbers’ had the fallback method.
- Unsuccessfully parsed dates now preserve original string instead of returning empty string.

Bug fixes:

We fixed US driver's license address extraction (Oregon, Mississippi, Rhode Island).
Added ProcessingStatus enumeration detailing why the result state was empty or uncertain.
Improved barcode error detection and correction.
Tweaked document detection feedback thresholds (that let the user know when the document is too close or too far away). This allows for a more natural scanning experience of passports in landscape mode, as the document can now be closer to the camera.

5.5.1

Removed alert() from VideoRecognizer and added allowManualVideoPlayout to constructor of VideoRecognizer class
Added locateFile method to MicroblinkSDK to fix problem when SDK is not using web worker
File package.json
- Added field engines to explicitly specify Node version which was used during development
- Fixed typo in repository field so NPM package can be used with yarn, closes #5
Documentation
- Added more information and renamed section "Optimal deployment of your web app" to "Deployment guidelines"
- Added links to Codepen examples and official demo app

5.5.0

Change of available recognizers
- Removed MRTDRecognizer
- Added BlinkIdGenericRecognizer and BlinkIdCombinedRecoginzer, with list of supported documents available in docs/BlinkIdRecognizer.md
Standardization of NPM package
- NPM package can be used in environments with module bundlers
- Added ES and UMD bundles for the SDK
- Types are now exposed and accessible in standard manner for NPM environment
- Extended package.json with project information and scripts for building and publishing
- Added Rollup build system to provide developers with infrastructure for easier customization of SDK
Extension of examples
- Examples now cover more functionalities of the SDK
- Provided examples for integration in TS, ES and UMD environment
Configuration options for WASM engine and WebWorker locations
- Configurations engineLocation and workerLocation are defined in the WasmSDKLoadSettings class
Improved stability and readability of SDK TypeScript source code
- Added ESLint for automatic check of unsecure language constructs
- Added Babel for safe transpiling to ES6 and better browser support

1.0.0-beta.1

decreased WASM binary size from 3.8 MB to 2.5 MB
fixed vulnerability in license check
added support for disabling hello message after license key gets validated
- by default this is still enabled, to disable it, set allowHelloMessage property in WasmSDKLoadSettings to false
updates to IdBarcodeRecognizer:
- added endorsements, restrictions and vehicleClass fields to its result
  - those fields are available only when scanning barcode from driver license
- added support for returning raw barcode data in case data parsing fails
  - this requires a permission within a license key
- changed the behaviour of firstName field:
  - now it contains both first name, middle name and name suffix

1.0.0-beta.0

initial beta release of the BlinkID In-browser SDK
supported recognizers:
- ID Barcode recognizer for scanning barcodes from various ID documents
- MRTD recognizer for scanning Machine Readable Zone (MRZ) from Machine Readable Travel Documents (MRTDs), such as IDs and passports

パッケージの詳細

readme

BlinkID In-browser SDK

How to run this repo?

Table of contents

Components of SDK

Integration instructions

Obtaining a license key

Installation

WASM Resources

Versions and backward compatibility

Performing your first scan

Recognizing still images

Configuration of SDK

Deployment guidelines

HTTPS

Deployment of WASM files

Server Configuration

Location of WASM and related support files

Setting up multiple licenses

Multiple apps

Single app

The Recognizer concept, RecognizerRunner and VideoRecognizer

The Recognizer concept

RecognizerRunner

Performing recognition of video streams using VideoRecognizer

Recognizing a video file

Custom UX with VideoRecognizer

Handling processing events with MetadataCallbacks

List of available recognizers

ID barcode recognizer

BlinkID Single-side recognizer

BlinkID Multi-side recognizer

Recognizer settings

Technical requirements

Supported browsers

Camera devices

Device support

SDK and WebView/WKWebView/SFSafariViewController

Android and WebView

iOS, WKWebView and SFSafariViewController

Conclusion

Troubleshooting

Integration problems

SDK problems

Licensing problems

Other problems

FAQ and known issues

Additional info

更新履歴

Release notes

v6.13.3

Bug fixes

v6.13.2

Bug fixes

v6.13.1

Bug fixes

v6.13.0

What's New

New Documents Support

New Document Versions for Supported Documents

New Beta Documents Support

New Document Versions for Beta-Supported Documents

Out of beta

Minor API changes

Bug Fixes

6.12.0

What's New

Bug Fixes

6.11.2

Bug fixes

6.11.1

Bug fixes

6.11.0

Expanded Document Coverage

New Documents Support

New Document Versions for Supported Documents

New Beta Documents Support

New Document Versions for Beta-Supported Documents

New Segments Supported on Documents

The `Recognizer` concept, `RecognizerRunner` and `VideoRecognizer`

The `Recognizer` concept

`RecognizerRunner`

Performing recognition of video streams using `VideoRecognizer`

Custom UX with `VideoRecognizer`

Handling processing events with `MetadataCallbacks`