NFC Verification with Didit's Flutter SDK: A Comprehensive Guide

Seamless IntegrationDidit's Flutter SDK provides a straightforward path to integrate advanced NFC verification capabilities into your mobile applications, supporting both iOS (15+) and Android (API 23+) platforms.

Enhanced SecurityLeverage NFC Verification to perform cryptographic validation of ePassports and eIDs, ensuring the highest level of trust by verifying data directly from the document's secure chip.

Robust Data HandlingThe SDK allows for efficient extraction and processing of critical chip data, including personal details and document information, which can be compared against OCR data for comprehensive fraud detection.

Didit's AdvantageDidit offers a modular, AI-native identity platform with Free Core KYC, enabling developers to easily compose advanced verification workflows without setup fees, ensuring secure and scalable solutions.

The Power of NFC Verification in Identity Management

In an increasingly digital world, robust identity verification is paramount. Traditional methods, while useful, can be susceptible to sophisticated fraud. This is where Near Field Communication (NFC) verification steps in, offering a gold standard for authenticating identity documents. By reading the secure chip embedded in modern passports and IDs, NFC verification provides cryptographic assurance that the document is genuine and has not been tampered with. This process is far more secure than relying solely on visual inspection or OCR, as it validates the digital signature of the chip itself.

Integrating NFC verification into your applications not only elevates security but also builds greater trust with your users. For businesses operating in regulated industries or those requiring high assurance of identity, NFC is quickly becoming a non-negotiable feature. Didit's NFC Verification product offers this cutting-edge capability, ensuring that you can verify identities with the highest degree of confidence.

Getting Started: Integrating Didit's Flutter SDK for NFC

Didit's Flutter SDK simplifies the integration of powerful identity verification features, including NFC verification, into your cross-platform applications. To begin, you'll need to add the SDK to your Flutter project. Ensure your environment meets the requirements: Flutter 3.3+, Dart 3.11+, iOS 13.0+ (iOS 15+ for NFC), and Android API 23+ (Android 6.0).

Installation Steps:

1. Add to pubspec.yaml:

   flutter pub add didit_sdk

2. iOS Specifics: Add the following to your Podfile inside the target block:

   pod 'DiditSDK', :podspec => 'https://raw.githubusercontent.com/didit-protocol/sdk-ios/main/DiditSDK.podspec'

   Then, navigate to your ios directory and run pod install.
3. Android Specifics: Add this to android/app/build.gradle.kts within the android block:

   packaging {
       resources {
           pickFirsts += "META-INF/versions/9/OSGI-INF/MANIFEST.MF"
       }
   }

Once installed, your Flutter application is ready to communicate with Didit's robust backend for secure NFC verification. Didit's developer-first approach means you get instant sandbox access and clean APIs, making integration smooth and efficient.

Implementing NFC Verification Workflow

The core of NFC verification involves reading data from the embedded chip and validating its authenticity. Didit's SDK orchestrates this complex process, abstracting away the intricacies of cryptographic checks and certificate validation. The general flow involves initiating a session, prompting the user to scan their document, and then processing the results.

Backend Session Creation:

Before initiating an NFC scan from the client, your backend needs to create a verification session with Didit. This is done via a POST request to Didit's API:

POST https://verification.didit.me/v3/session/
Headers: { "x-api-key": DIDIT_API_KEY, "Content-Type": "application/json" }
Body: { "workflow_id": DIDIT_WORKFLOW_ID, "vendor_data": "user-id" }
Response: { "session_id": "uuid", "session_token": "jwt-token", "verification_url": "...", "status": "Not Started" }

Your backend then sends the session_token to your Flutter app.

Flutter App Integration:

In your Flutter application, you'll use the didit_sdk to start the verification process:

import 'package:didit_sdk/sdk_flutter.dart';

// ... in your widget or service
String sessionToken = 'YOUR_SESSION_TOKEN_FROM_BACKEND';
DiditSDK.instance.startVerification(sessionToken: sessionToken);
// Handle the result, which will be a DiditResult object
DiditResult result = await DiditSDK.instance.startVerification(sessionToken: sessionToken);

if (result.isSuccess) {
  // Verification successful. You can now retrieve details from your backend using session_id
  print('Verification successful for session: ${result.sessionId}');
} else {
  // Handle verification failure or user cancellation
  print('Verification failed: ${result.error}');
}

Upon successful completion, Didit's backend processes the NFC data, performing checks like SOD (Security Object Data) and DG (Data Group) integrity validation. This ensures the data read from the chip is authentic and matches the document's digital signature. The Flutter SDK facilitates the user experience of holding their document to the phone for scanning, guiding them through the process.

Understanding NFC Verification Reports and Warnings

Once the NFC verification is complete, Didit provides a detailed report. This report is a JSON object containing crucial information about the verification outcome. Key sections include the overall nfc status, chip_data (personal and document information extracted directly from the secure chip), authenticity results (e.g., sod_integrity, dg_integrity), and certificate_summary detailing the document's digital certificates.

Didit's NFC Verification Warnings are particularly useful for identifying potential issues. Warnings like SKIPPED_NFC_VALIDATION, NFC_CHIP_NOT_VERIFIED, and critically, NFC_AND_OCR_DATA_NOT_SAME, provide insights into the verification process. The last warning, indicating a mismatch between OCR data and chip data, is a strong indicator of potential document tampering or forgery and will automatically result in a decline condition by default, offering robust fraud prevention. Didit's modular architecture allows you to configure how your application handles different risk categories, enabling you to set actions like 'Decline', 'Review', or 'Approve' based on your risk tolerance.

How Didit Helps

Didit stands out as the premier AI-native, developer-first identity platform, making NFC verification accessible and highly effective. Our modular architecture allows you to plug-and-play identity checks like NFC Verification, ID Verification, and Passive & Active Liveness detection into your existing workflows. With Didit's Free Core KYC, you can start verifying identities without upfront costs or setup fees, paying only for successful checks. Our platform is built for global scale, ensuring your identity verification processes are robust and compliant worldwide.

Didit's NFC Verification product offers the highest level of security by reading and validating the cryptographic data stored in ePassports and eIDs. This capability, combined with our AI-powered orchestration engine, allows you to automate trust and manage risk with unparalleled efficiency. The detailed JSON reports provide rich, structured identity data, giving you the insights needed to make informed decisions and detect sophisticated fraud attempts.

Ready to Get Started?

Ready to see Didit in action? Get a free demo today.

Start verifying identities for free with Didit's free tier.