---
Source: https://docs.microblink.com/blinkid/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:8001.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: "8001.0.0")
      )
  ]
  ```

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

  </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>
</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