NIST Standard Compliant Enterprise Ready MOSIP Compliant

IDBIO Developer Documentation

Integration reference for the Face Cloud API, IDBIO ABIS, and IDBIO Biometric SDK.

Overview

IDBIO offers three integration surfaces. The Face Cloud API is a managed service for face use cases. IDBIO ABIS and Biometric SDK are on-premise solutions for national-scale identity programs — fingerprint and iris are available exclusively through these on-premise paths.

Face Cloud API

Managed · Face Only

REST API for face matching and passive liveness. No infrastructure to manage.

IDBIO ABIS

1:N MOSIP Compliant

National-scale 1:N biometric deduplication. On-premise, MOSIP-compliant.

Biometric SDK

1:1 MOSIP Compliant

1:1 matching, quality checks, and template extraction. MOSIP-compliant library and service.

Face Cloud API

Face Only HTTPS · REST · TLS 1.3 JSON · Base64 Per-Transaction Billed

Managed cloud service for face matching and active/passive liveness detection. Endpoints are region-specific (api-in.idbio.ai, api-eu.idbio.ai, …) and assigned at onboarding. Also available for on-premise deployment on request — full root access to target hosts is required for installation; contact sales for either path.

API Authentication

All authentication and request correlation travels in HTTP headers. Every request carries two required identifiers: X-IDBIO-API-Key for credentials and X-IDBIO-Txn-Id for transaction correlation. The request body carries only the biometric payload — keys and IDs never appear in the URL, query string, or body.

HeaderValueRequired
X-IDBIO-API-KeyAPI key issued at onboarding · idb_test_… sandbox  ·  idb_live_… productionRequired
X-IDBIO-Txn-IdUnique per request · 16–64 chars · [A-Za-z0-9_-] · UUID v4 recommended. Echoed in the response. Reusing an ID returns 409 DUPLICATE_TXN_ID.Required
Content-Typeapplication/jsonRequired
X-IDBIO-Client-VersionCapture-side SDK identifier, e.g. idbio-capture-android/2.4.1Recommended

Face Match

1:1 comparison of a probe face image against a reference. Returns a similarity score and a match decision against a configurable threshold. Each image carries an independent liveness_check flag — when enabled, single-frame passive liveness is run on that image and its result is included in the response. The lens_focus_distance and min_focus_distance fields (in diopters) are optional but recommended for best accuracy when liveness_check is true; they are ignored otherwise.

POST /v1/face/match

Request Headers

X-IDBIO-API-Key: idb_live_
X-IDBIO-Txn-Id:  a3f1c8b24e6f4a5d9b8c7e0f1d2a3b4c
Content-Type:    application/json

Request Body

{
  "probe": {
    "image_data_b64":      "<base64-encoded image bytes>", // required
    "image_format":        "JPEG",                       // required · JPEG | PNG | BMP | WEBP
    "liveness_check":      true,                         // optional · default false
    "lens_focus_distance": 0.50,                         // recommended when liveness_check=true · diopters
    "min_focus_distance":  0.10                          // recommended when liveness_check=true · diopters
  },
  "reference": {
    "image_data_b64":      "<base64-encoded image bytes>",
    "image_format":        "JPEG",
    "liveness_check":      false                         // e.g. stored ID-document photo — skip liveness
  },
  "match_threshold":    0.75                              // optional · 0.0–1.0 · defaults to tenant-configured value
}
import requests, base64, uuid

def face_match(probe_path, ref_path, api_key, *, check_probe_liveness=True,
               lens_focus_distance=None, min_focus_distance=None):
    def b64(p): return base64.b64encode(open(p,"rb").read()).decode()
    probe = {
        "image_data_b64": b64(probe_path),
        "image_format":   "JPEG",
        "liveness_check": check_probe_liveness,
    }
    if check_probe_liveness:
        probe["lens_focus_distance"] = lens_focus_distance   # diopters, from camera
        probe["min_focus_distance"]  = min_focus_distance
    r = requests.post(
        "https://<endpoint>/v1/face/match",
        headers={
            "X-IDBIO-API-Key": api_key,
            "X-IDBIO-Txn-Id":  uuid.uuid4().hex,    # unique per request
            "Content-Type":    "application/json",
        },
        json={
            "probe":           probe,
            "reference":       {"image_data_b64": b64(ref_path),
                                  "image_format":   "JPEG",
                                  "liveness_check": False},
            "match_threshold": 0.75,
        },
        timeout=15,
    )
    r.raise_for_status()
    return r.json()
import java.net.http.*; import java.net.URI; import java.nio.file.*;
import java.util.UUID;

String b64(String path) throws Exception {
    return java.util.Base64.getEncoder().encodeToString(
        Files.readAllBytes(Path.of(path)));
}
String txnId = UUID.randomUUID().toString().replace("-", "");
String body = """
    {"probe":{"image_data_b64":"%s","image_format":"JPEG",
              "liveness_check":true,
              "lens_focus_distance":0.50,"min_focus_distance":0.10},
     "reference":{"image_data_b64":"%s","image_format":"JPEG",
                  "liveness_check":false},
     "match_threshold":0.75}""".formatted(b64(probePath), b64(refPath));

HttpRequest req = HttpRequest.newBuilder()
    .uri(URI.create("https://<endpoint>/v1/face/match"))
    .header("X-IDBIO-API-Key", apiKey)
    .header("X-IDBIO-Txn-Id",  txnId)
    .header("Content-Type",    "application/json")
    .timeout(java.time.Duration.ofSeconds(15))
    .POST(HttpRequest.BodyPublishers.ofString(body)).build();
var resp = HttpClient.newHttpClient().send(req,
    HttpResponse.BodyHandlers.ofString());
// resp.body() → JSON envelope (see Response Body below)
#include <curl/curl.h>
#include <nlohmann/json.hpp>
using json = nlohmann::json;

json payload = {
    {"probe", {
        {"image_data_b64",      base64_encode(probe_bytes)},
        {"image_format",        "JPEG"},
        {"liveness_check",      true},
        {"lens_focus_distance", 0.50},
        {"min_focus_distance",  0.10}
    }},
    {"reference", {
        {"image_data_b64", base64_encode(ref_bytes)},
        {"image_format",   "JPEG"},
        {"liveness_check", false}
    }},
    {"match_threshold", 0.75}
};
std::string body  = payload.dump();
std::string txnId = make_uuid_hex();   // unique per request
std::string txnHdr = "X-IDBIO-Txn-Id: " + txnId;

CURL* curl = curl_easy_init();
struct curl_slist* h = nullptr;
h = curl_slist_append(h, "Content-Type: application/json");
h = curl_slist_append(h, "X-IDBIO-API-Key: <api-key>");
h = curl_slist_append(h, txnHdr.c_str());
curl_easy_setopt(curl, CURLOPT_URL, "https://<endpoint>/v1/face/match");
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, body.c_str());
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, h);
curl_easy_perform(curl);

Response Body · 200 OK

{
  "txn_id": "a3f1c8b24e6f4a5d9b8c7e0f1d2a3b4c",
  "match": {
    "decision": "MATCHED",                                 // MATCHED | NOT_MATCHED
    "score":    0.924                                       // 0.0–1.0
  },
  "liveness": {                                                // only present if any image had liveness_check=true
    "probe":     { "decision": "GENUINE", "spoof_score": 0.03 } // only the images that were checked appear
  },
  "processed_at":       "2026-05-09T12:34:56.789Z",            // ISO 8601 UTC
  "processing_time_ms": 312                                  // server-side latency, excludes network
}

Request Fields (body)

FieldTypeNotes
probe.image_data_b64stringRequired · base64 image · min 100×100 px · ≤ 4 MB decoded
probe.image_formatstringRequired · JPEG · PNG · BMP · WEBP
probe.liveness_checkbooleanOptional · default false · runs single-frame passive liveness
probe.lens_focus_distancefloatDiopters · optional · recommended when liveness_check = true
probe.min_focus_distancefloatDiopters · recommended when liveness_check = true
reference.*objectSame shape as probe · independent liveness_check
match_thresholdfloatOptional · 0.0–1.0 · tenant default if omitted

Response Fields (body)

FieldTypeNotes
txn_idstringEchoes the X-IDBIO-Txn-Id header
match.decisionstringMATCHED · NOT_MATCHED
match.scorefloat0.0–1.0 — higher = more similar
livenessobjectOmitted when neither image had liveness_check=true
liveness.probe.decisionstringGENUINE · SPOOF
liveness.probe.spoof_scorefloat0.0–1.0 · higher = more likely spoof
liveness.reference.*Same shape as liveness.probe · only present when checked
processed_atstringISO 8601 UTC timestamp
processing_time_msintServer-side latency (excludes network)

Face Liveness

Anti-spoof verification on a face capture. Two modes are supported:

  • ·passive — single-frame texture & reflectance analysis. No user interaction. 1 frame.
  • ·strong — multi-frame analysis with optional camera-optics input. Defeats high-resolution print, replay, mask, and deepfake-on-screen attacks. 2 frames.

Each frame may optionally include camera optics metadata — lens_focus_distance and min_focus_distance (in diopters). These fields are optional — requests succeed without them, but providing them is recommended for best accuracy. For strong mode, capture frame 0 at near focus and frame 1 at far focus.

POST /v1/face/liveness

Request Headers

X-IDBIO-API-Key: idb_live_
X-IDBIO-Txn-Id:  a3f1c8b24e6f4a5d9b8c7e0f1d2a3b4c
Content-Type:    application/json

Request Body — strong mode

{
  "liveness_mode": "strong",                                  // "passive" | "strong"
  "frames": [
    {
      "frame_index":         0,
      "image_data_b64":      "<base64 of frame 0>",
      "lens_focus_distance": 0.50,                          // diopters · recommended · near focus
      "min_focus_distance":  0.10                           // diopters · recommended · device constant
    },
    {
      "frame_index":         1,                              // required only when liveness_mode = "strong"
      "image_data_b64":      "<base64 of frame 1>",
      "lens_focus_distance": 5.00,                          // far focus (Δ ≥ 2.0 from frame 0 when supplied)
      "min_focus_distance":  0.10
    }
  ]
}
import requests, base64, uuid

def b64(p): return base64.b64encode(open(p,"rb").read()).decode()

def _headers(api_key):
    return {
        "X-IDBIO-API-Key": api_key,
        "X-IDBIO-Txn-Id":  uuid.uuid4().hex,    # unique per request
        "Content-Type":    "application/json",
    }

# ── Passive (single frame) ───────────────────────────────────────
def face_liveness_passive(frame_path, api_key, *, lens_focus_d, min_focus_d):
    r = requests.post(
        "https://<endpoint>/v1/face/liveness",
        headers=_headers(api_key),
        json={
            "liveness_mode": "passive",
            "frames": [{
                "frame_index":    0,
                "image_data_b64": b64(frame_path),
                "liveness_metadata": {
                    "lens_focus_distance": lens_focus_d,
                    "min_focus_distance":  min_focus_d,
                },
            }],
        },
        timeout=15,
    )
    return r.json()

# ── Strong (two frames at different focus distances) ────────────
def face_liveness_strong(near_path, far_path, api_key, *,
                         lens_d_near, lens_d_far, min_focus_d):
    def frame(idx, path, lens_d):
        return {
            "frame_index":    idx,
            "image_data_b64": b64(path),
            "liveness_metadata": {
                "lens_focus_distance": lens_d,
                "min_focus_distance":  min_focus_d,
            },
        }
    r = requests.post(
        "https://<endpoint>/v1/face/liveness",
        headers=_headers(api_key),
        json={
            "liveness_mode": "strong",
            "frames": [frame(0, near_path, lens_d_near),
                       frame(1, far_path,  lens_d_far)],
        },
        timeout=15,
    )
    return r.json()
import java.net.http.*; import java.net.URI; import java.nio.file.*;
import java.util.UUID;

String b64(String path) throws Exception {
    return java.util.Base64.getEncoder().encodeToString(
        Files.readAllBytes(Path.of(path)));
}
String txnId = UUID.randomUUID().toString().replace("-", "");

// Strong mode — two frames at different focus distances
String body = """
{
  "liveness_mode": "strong",
  "frames": [
    {"frame_index":0,"image_data_b64":"%s",
     "liveness_metadata":{"lens_focus_distance":0.50,"min_focus_distance":0.10}},
    {"frame_index":1,"image_data_b64":"%s",
     "liveness_metadata":{"lens_focus_distance":5.00,"min_focus_distance":0.10}}
  ]
}""".formatted(b64(nearPath), b64(farPath));

HttpRequest req = HttpRequest.newBuilder()
    .uri(URI.create("https://<endpoint>/v1/face/liveness"))
    .header("X-IDBIO-API-Key", apiKey)
    .header("X-IDBIO-Txn-Id",  txnId)
    .header("Content-Type",    "application/json")
    .timeout(java.time.Duration.ofSeconds(15))
    .POST(HttpRequest.BodyPublishers.ofString(body)).build();
var resp = HttpClient.newHttpClient().send(req,
    HttpResponse.BodyHandlers.ofString());
#include <curl/curl.h>
#include <nlohmann/json.hpp>
using json = nlohmann::json;

json payload = {
    {"liveness_mode", "strong"},
    {"frames", json::array({
        {
            {"frame_index",    0},
            {"image_data_b64", base64_encode(near_bytes)},
            {"liveness_metadata", {
                {"lens_focus_distance", 0.50},
                {"min_focus_distance",  0.10}
            }}
        },
        {
            {"frame_index",    1},
            {"image_data_b64", base64_encode(far_bytes)},
            {"liveness_metadata", {
                {"lens_focus_distance", 5.00},
                {"min_focus_distance",  0.10}
            }}
        }
    })}
};
std::string body  = payload.dump();
std::string txnId = make_uuid_hex();   // unique per request
std::string txnHdr = "X-IDBIO-Txn-Id: " + txnId;

CURL* curl = curl_easy_init();
struct curl_slist* h = nullptr;
h = curl_slist_append(h, "Content-Type: application/json");
h = curl_slist_append(h, "X-IDBIO-API-Key: <api-key>");
h = curl_slist_append(h, txnHdr.c_str());
curl_easy_setopt(curl, CURLOPT_URL, "https://<endpoint>/v1/face/liveness");
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, body.c_str());
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, h);
curl_easy_perform(curl);

Response Body · 200 OK

{
  "txn_id":   "a3f1c8b24e6f4a5d9b8c7e0f1d2a3b4c",
  "decision": "GENUINE",                                // GENUINE | SPOOF · final fused decision
  "frames": [                                            // per-frame · 1 entry passive · 2 entries strong
    { "frame_index": 0, "spoof_score": 0.04 },         // 0.0–1.0 · higher = more likely spoof
    { "frame_index": 1, "spoof_score": 0.02 }
  ],
  "processed_at":       "2026-05-09T12:34:56.789Z",           // ISO 8601 UTC
  "processing_time_ms": 247                                 // server-side latency, excludes network
}

Request Fields (body)

FieldTypeNotes
liveness_modestringRequired · passive · strong
framesarrayRequired · 1 entry (passive) · 2 entries (strong)
frames[].frame_indexintRequired · 0-based · contiguous
frames[].image_data_b64stringRequired · base64 image · ≤ 4 MB decoded · format auto-detected (JPEG/PNG/BMP/WEBP)
frames[].liveness_metadataobjectOptional · recommended for best accuracy
frames[].liveness_metadata.lens_focus_distancefloatDiopters · per-frame · optional
frames[].liveness_metadata.min_focus_distancefloatDiopters · optional

Response Fields (body)

FieldTypeNotes
txn_idstringEchoes the X-IDBIO-Txn-Id header
decisionstringGENUINE · SPOOF · final fused decision across all frames
frames[]array1 entry (passive) · 2 entries (strong)
frames[].frame_indexint0-based · echoes the request index
frames[].spoof_scorefloat0.0–1.0 per-frame spoof score · higher = more likely spoof
processed_atstringISO 8601 UTC timestamp
processing_time_msintServer-side latency (excludes network)

Error Codes

All errors return a non-2xx HTTP status with a minimal JSON body echoing the txn_id and a structured error. HTTP status is the source of truth. Generate a new X-IDBIO-Txn-Id for every retry.

// Error response envelope
{
  "txn_id": "a3f1c8b24e6f4a5d9b8c7e0f1d2a3b4c",
  "error": {
    "code":    "NO_FACE_DETECTED",
    "message": "No face detected in probe image."
  },
  "processed_at":       "2026-05-09T12:34:56.789Z",
  "processing_time_ms": 47
}

All codes apply to both /v1/face/match and /v1/face/liveness. The specific validation that failed for INVALID_REQUEST is carried in error.message.

HTTPCodeDescription
400INVALID_REQUESTMissing or malformed header, body field, or parameter — including X-IDBIO-Txn-Id format, liveness_mode, frame count, focus-distance range, and match_threshold. error.message carries the specific reason.
401UNAUTHORIZEDMissing, malformed, revoked, or environment-mismatched X-IDBIO-API-Key.
402QUOTA_EXHAUSTEDPlan quota exceeded.
403FORBIDDENAPI key is not entitled for this product or operation.
409DUPLICATE_TXN_IDX-IDBIO-Txn-Id already used by this API key. Generate a fresh ID and resubmit.
413PAYLOAD_TOO_LARGEDecoded image exceeds 4 MB or request body exceeds 10 MB.
415INVALID_IMAGEImage could not be decoded. Check base64 encoding and format.
422NO_FACE_DETECTEDNo face found. Improve framing, lighting, or pose.
422MULTIPLE_FACES_DETECTEDMore than one face found. Capture must contain exactly one.
422QUALITY_TOO_LOWImage quality below operational floor (blur, occlusion, illumination, off-pose).
429RATE_LIMIT_EXCEEDEDRate cap hit. Retry after the duration in the Retry-After header — with a new X-IDBIO-Txn-Id.
500INTERNAL_ERRORUnexpected server error. Retry with backoff and a new X-IDBIO-Txn-Id.
503SERVICE_UNAVAILABLETemporary capacity issue. Honour Retry-After and resubmit with a new X-IDBIO-Txn-Id.

Service-level commitments, throughput limits, and pricing are governed by your commercial agreement — contact sales for details.

IDBIO ABIS

1:N Deduplication Fingerprint · Iris · Face Async · Message Queue MOSIP Compliant

IDBIO ABIS is a national-scale Automated Biometric Identification System purpose-built for large-scale identity enrollment and deduplication. It processes fingerprint, iris, and face biometrics on-premise — no biometric data leaves the deployment environment. No personally identifiable information (PII) is ever shared with IDBIO ABIS; only opaque reference IDs and encrypted biometric payloads are exchanged.

IDBIO ABIS is fully MOSIP-compliant. For the complete API specification and message format reference, see the MOSIP ABIS API documentation ↗.

How It Works

IDBIO ABIS integrates via an Apache ActiveMQ message broker — all operations are fully asynchronous JSON messages. Your MOSIP Registration Processor publishes requests to an inbound queue; IDBIO ABIS processes them and publishes responses to an outbound queue.

1

Insert

Enroll a biometric record. IDBIO ABIS fetches the AES-encrypted CBEFF payload from the secure datashare URL, extracts biometric templates, and stores them internally.

2

Identify

1:N deduplication search against the full database or a specified gallery subset. Returns a ranked candidate list with per-modality confidence analytics.

3

Delete

Permanently remove a biometric record by reference ID. Used for deduplication resolution and right-to-erasure workflows.

CapabilityDetail
ModalitiesFingerprint (all 10 fingers + slap), Iris (left, right, dual), Face
ScaleDesigned for national-scale deployments — hundreds of millions of records
TransportApache ActiveMQ or Artemis broker — asynchronous JSON messages
SecurityBiometric data encrypted with AES-GCM (RSA-OAEP key wrap). PII never shared with ABIS.
DeploymentOn-premise within your secure zone. Containerised — Kubernetes-ready.
Image formatsFingerprint: JPEG 2000, WSQ  ·  Iris: JPEG 2000  ·  Face: JPEG 2000  ·  Per ISO 19794-4/5/6:2011
Biometric exchangeCBEFF (ISO/IEC 19785) — all biometric data exchanged as CBEFF XML BIR/BDB blocks, AES-GCM encrypted in transit

IDBIO Biometric SDK

1:1 Authentication Quality Check Template Extraction MOSIP Compliant

IDBIO Biometric SDK is the on-premise biometric processing engine for 1:1 verification and quality assessment across fingerprint, iris, and face. It is the counterpart to IDBIO ABIS — while ABIS handles large-scale 1:N deduplication, the SDK handles 1:1 matching and all biometric quality operations.

Capabilities

OperationDescriptionModalities
Quality Check Evaluates biometric image quality and returns a score (0–100) per modality segment. Used at capture time and server-side during enrollment processing to reject poor captures before they reach the deduplication pipeline. All
1:1 Match Compares a probe biometric against a single gallery record and returns MATCHED, NOT_MATCHED, or ERROR. Supports image-to-image, template-to-template, and image-to-template comparisons. Used for authentication transactions. All
Template Extraction Extracts a compact proprietary biometric template from a raw image (CBEFF BIR). Extracted templates are stored in the ID repository and used for all subsequent 1:1 matching, reducing compute at authentication time. All
Segmentation Segments biometric captures into individual units — slap fingerprint images into individual fingers (e.g. 4-finger slap → 4 ROIs), multi-face frames into individual face crops, and iris images into left/right individual iris regions. All
Format Conversion Converts biometric images between supported formats, e.g. WSQ ↔ PNG, or between ISO 19794 versions. Useful when interoperating with legacy capture devices or external systems. All

Integration

IDBIO Biometric SDK is delivered as a Java library and a containerised REST microservice. Both expose the same biometric processing interface — the library is used inside desktop registration clients, the service is consumed by server-side enrollment and authentication workflows.

Library (Java JAR)

  • Embedded directly in the registration client application
  • Used for capture-time quality checks and slap segmentation
  • Supports offline operation for field enrollment in low-connectivity zones
  • Configured via Spring bean wiring — no code changes to the host application

Microservice (Docker / REST)

  • Deployed as a container in your Kubernetes cluster
  • Exposes HTTP endpoints consumed by the enrollment processor and ID authentication service
  • Horizontally scalable — add replicas to handle higher enrollment or authentication throughput
  • Health and readiness probes included for Kubernetes lifecycle management
SpecDetail
RuntimeJava 11+ · Spring Boot
DeploymentDocker image · Kubernetes-ready · Helm chart available
Biometric data formatCBEFF XML (ISO 19785) — biometric segments in BIR/BDB format, base64-encoded
Image formatsFingerprint: WSQ, JPEG2000, PNG, TIFF, BMP, RAW  ·  Face: JPEG, PNG, BMP, WEBP, RAW  ·  Iris: JPEG, PNG, BMP, RAW
Match resultMATCHED · NOT_MATCHED · ERROR — per gallery entry
Quality score0–100 per modality segment. Configurable minimum threshold per deployment.

Implementation

The SDK is wired into your application via dependency injection. The examples below show quality check and 1:1 match — the two most common operations.

// Java — IDBIO Biometric SDK
import io.mosip.kernel.biometrics.spi.IBioApi;
import io.mosip.kernel.biometrics.entities.BiometricRecord;
import io.mosip.kernel.biometrics.model.*;
import io.mosip.kernel.biometrics.constant.*;

// Injected by Spring — IDBIO provides the IBioApi implementation
@Autowired private IBioApi bioApi;

// ── Quality Check ──────────────────────────────────────────────
// sample: BiometricRecord with CBEFF BIR segments (JPEG2000 / WSQ)
Response<QualityCheck> qr = bioApi.checkQuality(
    sample,
    List.of(BiometricType.FINGER),
    null                                       // optional flags Map
);
// qr.getResponse().getScores() → Map<BiometricType, QualityScore>
// QualityScore.getScore() → Long  (0–100)

// ── 1:1 Match ─────────────────────────────────────────────────
Response<MatchDecision[]> mr = bioApi.match(
    probe,                                     // probe BiometricRecord
    new BiometricRecord[]{ galleryRecord },    // one or more gallery entries
    List.of(BiometricType.FINGER),
    null
);
// mr.getResponse()[0].getMatch() → Match.MATCHED | NOT_MATCHED | ERROR

// ── Template Extraction ───────────────────────────────────────
Response<BiometricRecord> er = bioApi.extractTemplate(
    rawCapture,
    List.of(BiometricType.IRIS),
    null
);
// er.getResponse() → BiometricRecord with PROCESSED-level BDB segments
// Persist to ID repository; used in all subsequent match calls

// ── Segmentation (slap finger / iris / face) ──────────────────
Response<BiometricRecord> sr = bioApi.segment(
    slapCapture,
    List.of(BiometricType.FINGER),
    null
);
// sr.getResponse() → BiometricRecord with individual finger segments
# Python — IDBIO Biometric SDK via REST microservice
import requests, base64, json

SDK_URL = "http://idbio-biosdk-service:80"
HEADERS = {"Content-Type": "application/json"}

def build_segment(cbeff_b64, modality, subtype=None):
    seg = {
        "bdbInfo": {"type": [modality], "level": "RAW",
                     "purpose": "ENROLL", "quality": {"score": 0}},
        "bdb": cbeff_b64
    }
    if subtype: seg["bdbInfo"]["subtype"] = [subtype]
    return seg

# ── Quality Check ────────────────────────────────────────
def check_quality(cbeff_b64, modality):
    r = requests.post(f"{SDK_URL}/check-quality",
        headers=HEADERS,
        json={"sample": {"segments": [build_segment(cbeff_b64, modality)]},
              "modalitiesToCheck": [modality]})
    return r.json()["response"]["scores"]  # {modality: score 0-100}

# ── 1:1 Match ────────────────────────────────────────────
def match_biometric(probe_b64, gallery_b64, modality):
    r = requests.post(f"{SDK_URL}/match",
        headers=HEADERS,
        json={
            "sample":           {"segments": [build_segment(probe_b64,   modality)]},
            "gallery":          [{"segments": [build_segment(gallery_b64, modality)]}],
            "modalitiesToMatch": [modality]
        })
    decisions = r.json()["response"]["matchDecisions"]
    return decisions[0]["match"]  # "MATCHED" | "NOT_MATCHED" | "ERROR"

# ── Template Extraction ───────────────────────────────────
def extract_template(cbeff_b64, modality):
    r = requests.post(f"{SDK_URL}/extract-template",
        headers=HEADERS,
        json={"sample": {"segments": [build_segment(cbeff_b64, modality)]},
              "modalitiesToExtract": [modality]})
    return r.json()["response"]["segments"]  # extracted template segments
// C++ — IDBIO Biometric SDK REST microservice (libcurl + nlohmann/json)
#include <curl/curl.h>
#include <nlohmann/json.hpp>
using json = nlohmann::json;

const std::string SDK_URL = "http://idbio-biosdk-service:80";

// Helper: build a BiometricRecord segment from a base64 CBEFF BIR
json makeSegment(const std::string& b64, const std::string& modality,
                  const std::string& subtype = "") {
    json seg = {
        {"bdbInfo", {{"type",{modality}},{"level","RAW"},{"purpose","ENROLL"},
                      {"quality",{{"score",0}}}}},
        {"bdb", b64}
    };
    if (!subtype.empty()) seg["bdbInfo"]["subtype"] = {subtype};
    return seg;
}

// ── Quality Check ─────────────────────────────────────────
json checkQuality(const std::string& b64, const std::string& modality) {
    json body = {
        {"sample",            {{"segments", {makeSegment(b64, modality)}}}},
        {"modalitiesToCheck", {modality}}
    };
    return json::parse(httpPost(SDK_URL + "/check-quality", body.dump()));
    // → response.scores[modality] = 0–100
}

// ── 1:1 Match ─────────────────────────────────────────────
std::string match(const std::string& probeB64, const std::string& galleryB64,
                   const std::string& modality) {
    json body = {
        {"sample",            {{"segments", {makeSegment(probeB64,   modality)}}}},
        {"gallery",           {{{"segments", {makeSegment(galleryB64, modality)}}}}},
        {"modalitiesToMatch", {modality}}
    };
    json resp = json::parse(httpPost(SDK_URL + "/match", body.dump()));
    return resp["response"]["matchDecisions"][0]["match"]; // MATCHED|NOT_MATCHED|ERROR
}

// ── Template Extraction ───────────────────────────────────
json extractTemplate(const std::string& b64, const std::string& modality) {
    json body = {
        {"sample",               {{"segments", {makeSegment(b64, modality)}}}},
        {"modalitiesToExtract", {modality}}
    };
    json resp = json::parse(httpPost(SDK_URL + "/extract-template", body.dump()));
    return resp["response"]["segments"]; // extracted template — store in ID repository
}

Compliance & Standards

🏆

NIST Standard Compliant

IDBIO biometric algorithms are built to NIST evaluation standards. Evaluations are ongoing.

  • FRTE — Face Recognition Technology Evaluation standard. 1:1 verification and 1:N identification.
  • PFT III — Proprietary Fingerprint Template Evaluation III standard. 1:1 template matching.
  • IREX 10 — Iris Exchange Evaluation standard, Identification Track. #1 on UIDAI Biometric Challenge.
MOSIP

MOSIP Compliant

  • IDBIO ABIS — Passes MOSIP Compliance Toolkit ABIS test suite. All 6 defined operations.
  • IDBIO Biometric SDK — Passes MOSIP Compliance Toolkit SDK test cases.
  • ISO/IEC 19794 — Parts 4, 5, 6 for fingerprint, face, and iris image data formats.

Support & Resources