Driver’s license barcode scanner: Extract data from PDF417

What data do American and Canadian driver’s licenses contain?

Driver’s licenses are widely used as proof of identity in the United States and Canada. The American Association of Motor Vehicle Administrators (AAMVA) and Department of Motor Vehicles (DMV) offices have standardized the design of these documents and the information they contain, ensuring reliable identification regardless of the issuing jurisdiction. 

This data is encoded in a PDF417 barcode on the back, which can be read using a barcode scanner. However, a parser (built-in or separate API) is required to decode the raw data into a human-readable format.

But what information can you actually extract? Here are the mandatory driver’s license data elements on AAMVA documents. The three letters in front are the data item’s corresponding element ID:

1. DCA: Vehicle class(es) the cardholder is allowed to drive
2. DCB: Restrictions on driving privileges (e.g., only automatic transmission)
3. DCD: Additional privileges granted to the cardholder (e.g., transportation of hazardous material)
4. DBA: Expiration date of the document
5. DCS: Last name / family name
6. DAC: First name
7. DAD: Middle name(s)
8. DBD: Issue date of the document
9. DBB: Date of birth
10. DBC: Gender
11. DAY: Eye color
12. DAU: Height
13. DAG: Address: Street name
14. DAI: Address: City name
15. DAJ: Address: State name
16. DAK: Address: Postal code
17. DAQ: ID number of the cardholder
18. DCF: ID number of the document
19. DCG: Country in which the document was issued
20. DDE: Indicator that the last name is truncated
21. DDF: Indicator that the first name is truncated
22. DDG: Indicator that the middle name(s) are truncated

What is PDF417?

All information above, including the license number and other ID card details, is encoded by a single PDF417 barcode on the back of a driver’s license. This 2D barcode, similar to a QR code in principle, is actually composed of multiple linear barcodes stacked on top of each other. It has a start pattern (left) and an end pattern (right), with the information itself encoded in the middle section.

A barcode scanner linked to a data parser can decode the information encoded by a PDF417 barcode to be easily readable by humans. This makes it easy to quickly find relevant fields such as a customer’s date of birth or credit card information. If the data is fed into a backend API, it can be used to automatically populate text fields, e.g., on an application form. 

This is not only much faster than manual data entry, it also prevents mistakes. 

Without parsing, the barcode scanner would simply show a long string containing the entirety of the information – unusable for backend systems and hard to read for humans.

Challenges in PDF417 scanning

Not all barcode readers can handle the unique structure of a PDF417 code. Only specialized 2D barcode scanners can scan the multi-row structure and properly interpret its start/stop patterns, the row indicators, and the error correction codewords present in each row.

As a stacked symbology, PDF417 is also very sensitive to the scanning angle. A good barcode scanner solution will scan it reliably even when it is tilted. 

Further challenges arise from the setting in which AAMVA PDF417 codes are usually scanned, as well as the licenses themselves. Driver’s licenses are often scratched and dirty from everyday use, and their shiny material reflects light. 

To scan them rapidly and accurately regardless of these hurdles, a robust scanning solution is needed. Modern software leverages machine-learning algorithms and advanced image processing to achieve this. 

The future of AAMVA PDF417: mobile driver’s licenses

The latest technological advances have only added to the requirements that a driver’s license barcode scanner must meet. 

Today, a mobile driver’s license (mDL) can be stored on a smartphone or other mobile device. As a digital version of the traditional driver’s license, they replace the physical cards.

The mDL contains the same information as the physical driver’s license, and so serves as a reliable proof of identity. Additionally, however, mDLs can be updated in real time, and at the same time eliminate the problems of stolen or lost driver’s license cards and damaged PDF417 codes. 

While mDLs eliminate many of the physical challenges for a PDF417 scanner, some remain. Bright ambient light can make scanning off dark smartphone screens impossible for scanners that don’t perform well outside ideal conditions.

Mobile driver’s license implementations are currently being tested in the US, Canada, and Europe.

Use a Driver’s License Scanner to automate your workflows

With the US Driver’s License Scanner by Scanbot SDK, you can easily and reliably decode information from PDF417 barcodes on ID cards and driver’s licenses. The data is transformed into key-value pairs to improve readability and facilitate backend processing.

Whether you need to verify the age of your customer or record their name and address, a quick scan of their driver’s license saves time and prevents mistakes.

Security is another consideration: While the text on the document can be tampered with, it is much harder to change the information encoded in the AAMVA PDF417 code – however legit it may look on the outside. This means that using a Driver’s License scanning functionality for ID verification not only increases efficiency, but also security. It can be integrated into workflows across various industries and make processes like customer onboarding and fleet management seamless and accurate.

The Scanbot SDK uses on-device processing, which means its software runs 100% offline, without connection to third-party servers. This ensures the high data protection standards that the processing of sensitive personal data requires. Additionally, it performs reliably regardless of network availability.

With the Scanbot SDK’s Ready-to-Use UI Components, you can set up a fully functional driver’s license scanner app with just a few lines of code – even in a single, self-contained HTML file, thanks to the Scanbot Web Barcode Scanner SDK. Take a look:

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=0" />
    <title>AAMVA Barcode Parser</title>
</head>

<body style="margin: 0">
    <button id="start-scanning">Start scanning</button>
    <p id="result"></p>
    <script type="module">
        import "https://cdn.jsdelivr.net/npm/scanbot-web-sdk@7.0.0/bundle/ScanbotSDK.ui2.min.js";

        const resultBox = document.getElementById("result");

        const wasm_path = "https://cdn.jsdelivr.net/npm/scanbot-web-sdk@7.0.0/bundle/bin";
        const sdk = await ScanbotSDK.initialize({ enginePath: `${wasm_path}/barcode-scanner/` });

        document.getElementById("start-scanning").onclick = async () => {
            const config = new ScanbotSDK.UI.Config.BarcodeScannerScreenConfiguration();
            config.scannerConfiguration.barcodeFormats = ["PDF_417"];
            config.viewFinder.aspectRatio.height = 1;
            config.viewFinder.aspectRatio.width = 3;

            const scanResult = await ScanbotSDK.UI.createBarcodeScanner(config);
            if (scanResult?.items === undefined || scanResult.items.length == 0) {
                resultBox.innerText = "Scanning aborted by the user";
                return;
            }

            const barcode = scanResult?.items[0].barcode;
            const extractedDocument = barcode.extractedDocument;

            const extractDocumentFields = (document) => {
                const fields = [];

                const processFields = (input) => {
                    if (!Array.isArray(input))
                        return;

                    input.forEach((field) => {
                        if (field.type?.name && field.value?.text) {
                            fields.push(field);
                        }
                    });
                };

                processFields(document.fields);

                if (Array.isArray(document.children)) {
                    document.children.forEach((child) => {
                        processFields(child.fields);
                    });
                }

                return fields;
            }

            const documentResult = extractDocumentFields(extractedDocument);
            resultBox.innerText = documentResult.map((field) => `${field.type.name}: ${field.value.text}`).join("\n");
        };
    </script>
</body>

</html>

Feel free to copy the code into an HTML file and run it in your browser. When moving to production, we recommend you download the SDK and host it on your server instead of using a CDN.

Get started scanning and parsing driver’s licenses today

You can run the Scanbot SDK from your project for 60 seconds per session without a license. For more in-depth testing, just generate a free trial license.

Our example apps on GitHub include implementations for various app development frameworks to help you with the integration process. We also offer free integration support via Slack and MS Teams to help with any remaining questions.

Already convinced? Then make the most of our fixed pricing model and request a quote today!

FAQ