Flutter

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

flutter pub get

import 'package:blink_kyc/blink_kyc.dart';

allprojects {
    repositories {
        google()
        mavenCentral()
        maven { url = uri("https://blink-pay.net/maven/releases") }   // Blink SDK repository
    }
}

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

platform :ios, '15.5'

target 'Runner' do
  use_frameworks! :linkage => :static
  # … the rest of Flutter's generated Podfile
end

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

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/foundation.dart';
import 'package:http/http.dart' as http;

Future<void> startVerification(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>;

  try {
    // 2. The native SDK runs document + liveness capture and uploads to Blink.
    final outcome = await BlinkKyc.present(BlinkConfig(
      sessionToken: session['sessionToken'] as String,
      issuingCountry: 'SDN',                        // SDN | ARE; omit to let the session decide
      documentType: BlinkDocumentType.nationalId,   // passport | nationalId; omit to let the session decide
      locale: 'ar',                                 // Blink's built-in Arabic; omit for the device locale
    ));

    // 3. Show progress to the user, but decide nothing here —
    //    ask your backend, which reads the authoritative result (section 05).
    debugPrint('device copy: ${outcome.verdict.name}');   // verified | rejected | review
    await http.post(
      Uri.parse('https://api.yourbank.com/kyc/sessions/${session['sessionId']}/complete'),
      headers: {'authorization': 'Bearer $userJwt'},
    );
  } on BlinkKycException catch (e) {
    // A cancelled journey, a failed step or a session problem. Switch on e.code, not the message.
    if (e.code == 'BLINK_CAPTURE_CANCELLED') return;   // user closed the camera
    debugPrint('${e.code}: ${e.message}');
  }
}

final link = Uri.parse(scannedLink);
if (link.scheme != 'https' || link.host != 'kyc-api.blink-pay.net') throw const FormatException('Not a Blink link');
final token = link.queryParameters['t'];
if (token == null) throw const FormatException('No session token in the link');

final outcome = await BlinkKyc.present(BlinkConfig(
  sessionToken: token,
  locale: link.queryParameters['lang'] == 'en' ? 'en' : 'ar',   // hosted links default to Arabic
));

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 BlinkKyc.present 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 result = await BlinkKyc.present(BlinkConfig(
  sessionToken: sessionToken,
  theme: const BlinkTheme(
    accent: Color(0xFF15803D),
    brandName: 'Your Bank',
    logo: BlinkImage.asset('assets/bank_logo.png'),
    scrimColor: Color(0xFF0E1E4D),   // the dimmed area outside the document frame
    scrimOpacity: 0.35,              // 0 clear … 1 opaque; 0.6 unless set
    guideSuccessColor: Color(0xFF22C55E),
  ),
));