---
Source: https://docs.microblink.com/blinkid/v8000/quickstart
Title: Quickstart
Description: Integrate BlinkID and get your first successful identity document scan on web, Android, or iOS in about five minutes
---

# Quickstart

This guide takes you from zero to a working document scan in about five minutes.
It uses the [UX package](how-the-sdk-works.md), which gives you a complete camera scanning experience with the least code.

The steps are the same on every platform:

1. Get a license key.
2. Add the SDK to your project.
3. Launch the scanner and read the result.

## Get a license key

1. Go to the [Microblink Developer Hub](https://developer.microblink.com/license/new).
2. Select **BlinkID** as the product.
3. Select your platform.
4. For web, set the domain to `localhost` while testing, or the domain where your app is hosted.

Keep the key somewhere your app can read it, such as an environment variable.
Never commit a production key to source control.

## Add the SDK

Install the SDK and complete the platform-specific setup.
The READMEs cover everything beyond the snippet below: required versions, repository configuration, and camera permissions.

<Tabs queryString="platform">
  <TabItem value="web" label="Web (TS)" default>

  Install the UX package:

  ```bash
  npm install @microblink/blinkid
  ```

  The scanning engine runs as a WASM module that must be served from your app, by default under `/resources`.
  See [Host resources](sdk/web/resources.md) for the copy step and the bundler setup, and the [web README](https://github.com/BlinkID/blinkid-web) for the full integration.

  </TabItem>
  <TabItem value="android" label="Android (Kotlin)">

  The SDK is published on Maven Central.
  Add the dependency to your module's `build.gradle.kts`:

  ```kotlin
  dependencies {
      implementation("com.microblink:blinkid-ux:8000.0.0")
  }
  ```

  See the [Android README](https://github.com/BlinkID/blinkid-android) for repository configuration and the camera permission.

  </TabItem>
  <TabItem value="ios" label="iOS (Swift)">

  Add the SDK with Swift Package Manager, either through Xcode or in your `Package.swift`, and depend on the `BlinkIDUX` product:

  ```swift
  dependencies: [
      .package(
          url: "https://github.com/BlinkID/blinkid-ios.git",
          .upToNextMajor(from: "8000.0.0")
      )
  ]
  ```

  See the [iOS README](https://github.com/BlinkID/blinkid-ios) for the camera usage description requirement.

  </TabItem>
  <TabItem value="flutter" label="Flutter (Dart)">

  Add the dependency to your `pubspec.yaml`:

  ```yaml
  dependencies:
    blinkid_flutter: ^8000.0.0
  ```

  Then fetch the package:

  ```bash
  flutter pub get
  ```

  The plugin requires Flutter 3.44 or later, iOS 16.0 or later (enable Swift Package Manager with `flutter config --enable-swift-package-manager`), and Android `minSdk` 24 with Kotlin 2.1.20 or later.

  </TabItem>
  <TabItem value="react-native" label="React Native (TS)">

  Install the package:

  ```bash
  npm install --save @microblink/blinkid-react-native
  ```

  The package requires React Native 0.82.x, iOS 16.0 or later, and Android API level 24 or later.

  </TabItem>
</Tabs>

## Scan a document

Initialize the SDK with your license key and launch the scanner.
When scanning finishes, you receive the extracted data in a callback.

<Tabs queryString="platform">
  <TabItem value="web" label="Web (TS)" default>

  ```typescript
  import { createBlinkId } from "@microblink/blinkid";

  const blinkId = await createBlinkId({
    licenseKey: import.meta.env.VITE_LICENSE_KEY,
  });

  blinkId.addOnResultCallback((result) => {
    console.log("First name:", result.firstName?.latin?.value);
    console.log("Document number:", result.documentNumber?.latin?.value);
    void blinkId.destroy();
  });
  ```

  `createBlinkId` loads the engine, opens the camera, and mounts the scanning UI in one call.
  Call `destroy` when you're done to release the camera and engine.

  </TabItem>
  <TabItem value="android" label="Android (Kotlin)">

  ```kotlin
  val sdk = BlinkIdSdk.initializeSdk(
      context,
      BlinkIdSdkSettings(licenseKey = "your-license-key")
  ).getOrThrow()

  BlinkIdCameraScanningScreen(
      blinkIdSdk = sdk,
      onScanningSuccess = { result ->
          println("First name: ${result.firstName?.value}")
          println("Document number: ${result.documentNumber?.value}")
      },
      onScanningCanceled = { }
  )
  ```

  `BlinkIdCameraScanningScreen` is a composable that owns its own camera lifecycle, so no explicit cleanup is needed.

  </TabItem>
  <TabItem value="ios" label="iOS (Swift)">

  ```swift
  let sdk = try await BlinkIDSdk.createBlinkIDSdk(
      withSettings: BlinkIDSdkSettings(licenseKey: "your-license-key")
  )
  let analyzer = try await BlinkIDAnalyzer(sdk: sdk)

  BlinkIDUXView(
      analyzer: analyzer,
      onScanCompleted: { resultState in
          guard let result = resultState.scanningResult else { return }
          print("First name:", result.firstName?.value ?? "")
          print("Document number:", result.documentNumber?.value ?? "")
      }
  )
  ```

  `BlinkIDUXView` is a SwiftUI view that releases camera resources when it's dismissed, so no explicit cleanup is needed.

  </TabItem>
  <TabItem value="flutter" label="Flutter (Dart)">

  ```dart
  import 'dart:io';
  import 'package:blinkid_flutter/blinkid_flutter.dart';
  import 'package:flutter/services.dart';

  final blinkIdPlugin = BlinkIdFlutter();

  var sdkLicenseKey = '';
  if (Platform.isAndroid) {
    sdkLicenseKey = 'android-license-key';
  } else if (Platform.isIOS) {
    sdkLicenseKey = 'ios-license-key';
  }

  final sdkSettings = BlinkIdSdkSettings(licenseKey: sdkLicenseKey);
  sdkSettings.downloadResources = true;

  final sessionSettings = BlinkIdSessionSettings(
    scanningMode: ScanningMode.automatic,
    scanningSettings: BlinkIdScanningSettings(
      documentCaptureModule: DocumentCaptureModuleSettings(),
      mrzModule: MrzModuleSettings(),
      barcodeModule: BarcodeModuleSettings(),
      vizModule: VizModuleSettings(),
    ),
  );

  try {
    final result = await blinkIdPlugin.performScan(
      blinkIdSdkSettings: sdkSettings,
      blinkIdSessionSettings: sessionSettings,
    );
    if (result != null) {
      print(result.firstName?.value);
    }
  } on PlatformException catch (e) {
    print('BlinkID scanning error: ${e.message}');
  }
  ```

  `performScan` launches the camera scanning experience and returns the result once scanning finishes.

  </TabItem>
  <TabItem value="react-native" label="React Native (TS)">

  ```typescript
  import { Platform } from 'react-native';
  import { performScan } from '@microblink/blinkid-react-native';

  const licenseKey = Platform.select({ ios: 'your-ios-key', android: 'your-android-key' })!;

  try {
    const result = await performScan({
      sdkSettings: { licenseKey, downloadResources: true },
      sessionSettings: {
        scanningMode: 'automatic',
        scanningSettings: { documentCaptureModule: {}, mrzModule: {}, barcodeModule: {}, vizModule: {} },
      },
    });
    console.log(result.firstName?.value);
  } catch (error) {
    console.log(`Error during scan: ${error}`);
  }
  ```

  `performScan` launches the camera scanning experience and returns the result once scanning finishes.

  </TabItem>
</Tabs>

That's a complete, runnable integration.
Point the camera at an identity document and the extracted fields print to your console.

## Read the result

The result is a structured object with a field for every piece of data BlinkID extracts: name, date of birth, document number, expiry date, address, and more.
Each field also carries the location it was read from and the raw image.

For the full list of fields and their types, see the [result reference](result-reference.md).

:::note

On web, text fields expose values per script, so you read them as `result.firstName?.latin?.value`.
On Android and iOS, the same field is `result.firstName?.value`.

:::

## Next steps

- [How the SDK works](how-the-sdk-works.md): the difference between the UX package and the core session.
- [Scan from a static image](scan-image.md): scan an uploaded or gallery image instead of the live camera.
- [Extract specific fields](extract-fields.md): read only the fields you need.
- [Customize the scanning UI](ui-ux-best-practices.md): branding, instructions, and overlay.
- [Restrict documents](restrict-documents.md): limit scanning to specific document types or countries.


Last updated on Jul 24, 2026