Flutter

dependencies:
  flutter:
    sdk: flutter
  blink_kyc:
    hosted: https://blink-pay.net/pub
    version: ^2.1.0
  http: ^1.2.0   # to call your own backend

flutter pub get

import 'package:blink_kyc/blink_kyc.dart';

android {
    defaultConfig {
        minSdk = 24   // required by the Blink Android SDK
    }

    // The chip reader's Bouncy Castle jars ship signature files that collide when merged.
    packaging.resources.excludes += setOf(
        "META-INF/*.SF", "META-INF/*.DSA", "META-INF/*.RSA",
        "META-INF/versions/9/OSGI-INF/MANIFEST.MF",
    )

    // Keep the on-device MRZ models uncompressed.
    androidResources { noCompress += listOf("tflite", "rtfm") }
}

<key>NSCameraUsageDescription</key>
<string>We use the camera to photograph your document and confirm your identity.</string>

<!-- Only if you enable passport chip reading with .nfc() -->
<key>NFCReaderUsageDescription</key>
<string>We read your passport chip to confirm your document is genuine.</string>
<key>com.apple.developer.nfc.readersession.iso7816.select-identifiers</key>
<array>
  <string>A0000002471001</string>
  <string>A0000002472001</string>
  <string>00000000000000</string>
</array>

curl -sX POST https://kyc-api.blink-pay.net/api/blink/session/create \
  -H 'content-type: application/json' \
  -d '{
        "clientKey":    "bkyc_live_…",
        "clientSecret": "bksec_…",
        "purpose":      "FULL_CAPTURE",
        "userRef":      "customer-8841"
      }'

→ 200
{
  "sessionId":    "[SESSION_ID]",
  "sessionToken": "bkyc_sess_…",
  "expiresAt":    "2026-09-15T18:42:10Z",
  "purpose":      "FULL_CAPTURE"
}

import express from 'express';

const app = express();
const BLINK = 'https://kyc-api.blink-pay.net';

// Called by your Flutter app. requireUser = your own auth middleware.
app.post('/kyc/sessions', requireUser, async (req, res) => {
  const r = await fetch(`${BLINK}/api/blink/session/create`, {
    method: 'POST',
    headers: { 'content-type': 'application/json' },
    body: JSON.stringify({
      clientKey: process.env.BLINK_CLIENT_KEY,
      clientSecret: process.env.BLINK_CLIENT_SECRET,
      purpose: 'FULL_CAPTURE',
      userRef: req.user.id,
    }),
  });
  if (!r.ok) return res.status(502).json({ error: 'kyc_unavailable' });

  const { sessionId, sessionToken, expiresAt } = await r.json();
  await db.kycSessions.insert({ userId: req.user.id, sessionId, status: 'CREATED' });

  // Only the token and id go to the phone. Never the key or secret.
  res.json({ sessionId, sessionToken, expiresAt });
});

import 'dart:convert';
import 'dart:io';

import 'package:http/http.dart' as http;
import 'package:shelf/shelf.dart';

const blink = 'https://kyc-api.blink-pay.net';

Future<Response> createKycSession(Request request, String userId) async {
  final r = await http.post(
    Uri.parse('$blink/api/blink/session/create'),
    headers: {'content-type': 'application/json'},
    body: jsonEncode({
      'clientKey': Platform.environment['BLINK_CLIENT_KEY'],
      'clientSecret': Platform.environment['BLINK_CLIENT_SECRET'],
      'purpose': 'FULL_CAPTURE',
      'userRef': userId,
    }),
  );
  if (r.statusCode != 200) return Response(502);

  final body = jsonDecode(r.body) as Map<String, dynamic>;
  // Save body['sessionId'] against userId before replying.
  return Response.ok(
    jsonEncode({'sessionId': body['sessionId'], 'sessionToken': body['sessionToken']}),
    headers: {'content-type': 'application/json'},
  );
}

import 'dart:convert';

import 'package:blink_kyc/blink_kyc.dart';
import 'package:flutter/material.dart';
import 'package:http/http.dart' as http;

const blinkApi = 'https://kyc-api.blink-pay.net';

Future<void> startVerification(BuildContext context, String userJwt) async {
  // 1. Your backend creates the Blink session (section 03).
  final res = await http.post(
    Uri.parse('https://api.yourbank.com/kyc/sessions'),
    headers: {'authorization': 'Bearer $userJwt'},
  );
  final session = jsonDecode(res.body) as Map<String, dynamic>;
  if (!context.mounted) return;

  try {
    // 2. The SDK runs document + liveness capture and uploads to Blink.
    final outcome = await BlinkKyc(blinkApi, session['sessionToken'] as String)
        .document(type: DocumentType.nationalId) // or omit type: the customer chooses
        .face()                                  // liveness + face match
        .present(context)                        // the SDK owns the camera UI
        .onProgress((p) => debugPrint('kyc ${p.step}'))
        .run();

    // 3. Show progress to the user, but decide nothing here —
    //    ask your backend, which reads the authoritative result (section 05).
    debugPrint('device copy: ${outcome.result.wireValue}');
    await http.post(
      Uri.parse('https://api.yourbank.com/kyc/sessions/${session['sessionId']}/complete'),
      headers: {'authorization': 'Bearer $userJwt'},
    );
  } on BlinkStepError catch (e) {
    // A step ran and failed, e.g. DOCUMENT_UNREADABLE or LIVENESS_FAILED.
    debugPrint('${e.step.wireValue}: ${e.code}');
  } on BlinkError catch (e) {
    // Network, session or capture problem. Switch on e.code, not the message.
    if (e.code == 'BLINK_CAPTURE_CANCELLED') return; // user closed the camera
    debugPrint('${e.code} (HTTP ${e.httpStatus})');
  }
}

final outcome = await BlinkKyc.fromHostedLink(scannedLink)
    .present(context)
    .run();

curl -s https://kyc-api.blink-pay.net/api/blink/session/[SESSION_ID]/result \
  -H 'X-Blink-Client-Key: bkyc_live_…' \
  -H 'X-Blink-Client-Secret: bksec_…'

→ 200
{
  "sessionId":  "[SESSION_ID]",
  "status":     "COMPLETED",
  "result":     "VERIFIED",
  "resultJson": "{\"sessionId\":\"[SESSION_ID]\",\"purpose\":\"FULL_CAPTURE\",\"result\":\"VERIFIED\",\"faceScore\":0.91,\"detail\":\"…\"}"
}

// Called by the app after run() returns. Also poll it from a job for users who close the app.
app.post('/kyc/sessions/:sessionId/complete', requireUser, async (req, res) => {
  const row = await db.kycSessions.find({ sessionId: req.params.sessionId, userId: req.user.id });
  if (!row) return res.sendStatus(404);

  const r = await fetch(`${BLINK}/api/blink/session/${row.sessionId}/result`, {
    headers: {
      'X-Blink-Client-Key': process.env.BLINK_CLIENT_KEY,
      'X-Blink-Client-Secret': process.env.BLINK_CLIENT_SECRET,
    },
  });
  if (!r.ok) return res.status(502).json({ error: 'kyc_unavailable' });

  const { status, result, resultJson } = await r.json();
  const record = resultJson ? JSON.parse(resultJson) : null;   // for logs / support
  await db.kycSessions.update(row.id, { status, result, detail: record?.detail });

  if (status !== 'COMPLETED') return res.json({ state: 'pending' });
  if (result === 'VERIFIED') await db.users.markVerified(req.user.id);
  res.json({ state: result.toLowerCase() });   // verified | rejected | review
});

Future<Map<String, dynamic>> fetchBlinkResult(String sessionId) async {
  final r = await http.get(
    Uri.parse('$blink/api/blink/session/$sessionId/result'),
    headers: {
      'X-Blink-Client-Key': Platform.environment['BLINK_CLIENT_KEY']!,
      'X-Blink-Client-Secret': Platform.environment['BLINK_CLIENT_SECRET']!,
    },
  );
  if (r.statusCode == 404) throw StateError('Unknown session or wrong credentials');
  if (r.statusCode != 200) throw StateError('Blink returned ${r.statusCode}');

  final body = jsonDecode(r.body) as Map<String, dynamic>;
  final raw = body['resultJson'] as String?;
  return {
    'status': body['status'],                         // COMPLETED when done
    'result': body['result'],                         // VERIFIED | REJECTED | REVIEW | null
    'record': raw == null ? null : jsonDecode(raw),   // detail, faceScore, purpose
  };
}

final controller = BlinkCaptureController();

final run = BlinkKyc(blinkApi, sessionToken)
    .document(type: DocumentType.nationalId)
    .face()
    .capture(controller)   // instead of present(context)
    .run();

// Build a screen for whatever the SDK asks for next.
ValueListenableBuilder<BlinkCaptureRequest?>(
  valueListenable: controller.request,
  builder: (context, request, _) => switch (request) {
    BlinkDocumentCaptureRequest() => MyDocumentCamera(
        onPhoto: (Uint8List jpeg) async {
          await myBackend.storeDocumentCopy(jpeg);   // your copy, your retention rules
          controller.submitDocument(jpeg);          // Blink's copy
        },
        onCancel: controller.cancel,
      ),
    BlinkLivenessCaptureRequest(:final actions) =>
        MyLivenessCamera(actions: actions, onFrames: controller.submitLiveness),
    null => const SizedBox.shrink(),
  },
);

final outcome = await run;

BlinkKyc(
  blinkApi,
  sessionToken,
  theme: const BlinkTheme(
    accent: Color(0xFF15803D),
    background: Color(0xFF0E1E4D),
    text: Color(0xFFFFFFFF),
    buttonCornerRadius: 12,
    instructionPosition: BlinkInstructionPosition.bottom,
    brandName: 'Your Bank',
    privacyPolicyUrl: 'https://yourbank.com/privacy',
  ),
  strings: const BlinkStrings(
    documentTitle: 'Verify your identity',
    captureButton: 'Take photo',
  ),
)
    .setLocale('ar')
    .document()
    .face()
    .present(context);