---
Source: https://docs.microblink.com/blinkid/v8000/detect-supported
Title: Detect whether a document is supported
Description: Check whether BlinkID supports a document at all, and inspect what the SDK classified
---

# Detect whether a document is supported

There are two distinct questions you might ask:

- Is this document type supported by BlinkID at all?
- Did the SDK classify the document it just processed, and as what?

## Is the document type supported by BlinkID

BlinkID supports a large, continuously growing catalog of identity documents.
The authoritative answer to "can BlinkID read this document" is the published list of supported documents.
See [Supported documents](./supported-documents.mdx) for the full catalog.

At runtime, you find out that a document is not supported through the per-frame processing status.
After processing an image, read `inputImageAnalysisResult.processingStatus`.
A value of `unsupported-document` means the recognizer does not support the document in the frame.

The same status also appears when a document is supported by BlinkID but excluded by a document class filter you configured.
From the SDK's perspective these are indistinguishable: in both cases the document is "unsupported" relative to what the current session will accept.
See [How to restrict documents](restrict-documents.md) for that case.

<Tabs queryString="platform">

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

  ```typescript
  const processResult = await session.process(imageData);
  const status = processResult.inputImageAnalysisResult.processingStatus;

  if (status === "unsupported-document") {
    console.log("This document is not supported.");
  }
  ```

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

  ```kotlin
  val processResult = session.process(inputImage).getOrThrow()
  val status = processResult.inputImageAnalysisResult.processingStatus

  if (status == ProcessingStatus.UnsupportedDocument) {
      println("This document is not supported.")
  }
  ```

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

  ```swift
  let frameResult = try await session.process(inputImage: inputImage)
  let status = frameResult.processResult?.inputImageAnalysisResult.processingStatus

  if status == .unsupportedDocument {
      print("This document is not supported.")
  }
  ```

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

  The Flutter wrapper doesn't expose the per-frame processing status.
  Instead, control whether the SDK processes documents it classifies as unsupported with `documentCaptureModule.unsupportedDocumentsAllowed`, then inspect `documentClassInfo` on the result (see below) to find out what was recognized.

  ```dart
  final scanningSettings = BlinkIdScanningSettings(
    documentCaptureModule: DocumentCaptureModuleSettings(
      unsupportedDocumentsAllowed: false, // reject unsupported documents (default)
    ),
  );
  ```

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

  The React Native wrapper doesn't expose the per-frame processing status.
  Instead, control whether the SDK processes documents it classifies as unsupported with `documentCaptureModule.unsupportedDocumentsAllowed`, then inspect `documentClassInfo` on the result (see below) to find out what was recognized.

  ```typescript
  const scanningSettings = {
    documentCaptureModule: {
      unsupportedDocumentsAllowed: false, // reject unsupported documents (default)
    },
  };
  ```

  </TabItem>
</Tabs>

## Inspect what the SDK classified

When BlinkID does support and recognize a document, the final result carries a `documentClassInfo` describing what was classified.
Retrieve the result after processing, then inspect `documentClassInfo`.

The most useful fields are:

- `country`: a country enum
- `region`: a region enum
- `type`: a document type enum
- `countryName`: the human-readable country name
- `isoNumericCountryCode`, `isoAlpha2CountryCode`, `isoAlpha3CountryCode`: ISO country codes

<Tabs queryString="platform">

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

  ```typescript
  const result = await session.getResult();
  const classInfo = result.documentClassInfo;

  if (classInfo?.country !== undefined && classInfo?.type !== undefined) {
    console.log("Recognized document.");
    console.log("Country:", classInfo.countryName);
    console.log("Country code:", classInfo.isoAlpha3CountryCode);
    console.log("Country enum:", classInfo.country);
    console.log("Region enum:", classInfo.region);
    console.log("Type enum:", classInfo.type);
  } else {
    console.log("Document was not classified.");
  }
  ```

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

  ```kotlin
  val result = session.getResult().getOrNull()
  val classInfo = result?.documentClassInfo

  if (classInfo?.country != null && classInfo.type != null) {
      println("Recognized document.")
      println("Country: ${classInfo.countryName}")
      println("Country code: ${classInfo.isoAlpha3CountryCode}")
      println("Country enum: ${classInfo.country}")
      println("Region enum: ${classInfo.region}")
      println("Type enum: ${classInfo.type}")
  } else {
      println("Document was not classified.")
  }
  ```

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

  ```swift
  let result = session.getResult()
  let classInfo = result?.documentClassInfo

  if classInfo?.country != nil && classInfo?.type != nil {
      print("Recognized document.")
      print("Country:", classInfo?.countryName ?? "")
      print("Country code:", classInfo?.isoAlpha3CountryCode ?? "")
      print("Country enum:", String(describing: classInfo?.country))
      print("Region enum:", String(describing: classInfo?.region))
      print("Type enum:", String(describing: classInfo?.type))
  } else {
      print("Document was not classified.")
  }
  ```

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

  ```dart
  final classInfo = result?.documentClassInfo;

  if (classInfo?.country != null && classInfo?.documentType != null) {
    print("Recognized document.");
    print("Country: ${classInfo?.countryName}");
    print("Country enum: ${classInfo?.country?.name}");
    print("Region enum: ${classInfo?.region?.name}");
    print("Type enum: ${classInfo?.documentType?.name}");
  } else {
    print("Document was not classified.");
  }
  ```

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

  ```typescript
  const classInfo = result.documentClassInfo;

  if (classInfo?.country !== undefined && classInfo?.documentType !== undefined) {
    console.log("Recognized document.");
    console.log("Country:", classInfo.countryName);
    console.log("Country enum:", classInfo.country);
    console.log("Region enum:", classInfo.region);
    console.log("Type enum:", classInfo.documentType);
  } else {
    console.log("Document was not classified.");
  }
  ```

  </TabItem>
</Tabs>

## Restricting to your own accepted set

Detecting whether BlinkID supports a document is different from deciding which documents your integration accepts.
If you want to accept only a narrower set, for example only passports from a specific country, configure a document class filter.
Documents your filter rejects also surface at runtime as `unsupported-document`.
See [How to restrict documents](restrict-documents.md).

## Related articles

- [Supported documents](./supported-documents.mdx)
- [How to restrict documents](restrict-documents.md)


Last updated on Jul 24, 2026