Identity Build Sheet

import boto3

client = boto3.client("textract", region_name="ap-south-1")

with open("id_front.jpg", "rb") as f:
    img = f.read()

resp = client.analyze_id(DocumentPages=[{"Bytes": img}])

# WHAT COMES BACK: one IdentityDocument per page, each with
# IdentityDocumentFields = list of {Type, ValueDetection}
out = {}
for doc in resp["IdentityDocumentFields"] if "IdentityDocumentFields" in resp \
          else resp["IdentityDocuments"][0]["IdentityDocumentFields"]:
    key  = doc["Type"]["Text"]              # e.g. FIRST_NAME, DATE_OF_BIRTH
    val  = doc["ValueDetection"]["Text"]
    conf = doc["ValueDetection"]["Confidence"]   # 0-100, NOT 0-1
    out[key] = {"value": val, "confidence": conf}

# WHAT TO CHECK, in this order:
# 1. confidence per FIELD, not per document
# 2. DATE_OF_BIRTH parsed to a real date - the string can be anything
# 3. ID_NUMBER against a checksum (Verhoeff for Aadhaar - see the module)
# 4. that every field you rely on is actually present; missing != empty

from azure.ai.documentintelligence import DocumentIntelligenceClient
from azure.core.credentials import AzureKeyCredential

client = DocumentIntelligenceClient(ENDPOINT, AzureKeyCredential(KEY))

with open("id_front.jpg", "rb") as f:
    poller = client.begin_analyze_document("prebuilt-idDocument", body=f)
result = poller.result()

# WHAT COMES BACK: documents[] -> fields{} keyed by name,
# each with .value_string / .value_date and .confidence (0-1 here)
doc = result.documents[0]
first = doc.fields.get("FirstName")
dob   = doc.fields.get("DateOfBirth")

out = {
  "first_name": first.value_string if first else None,
  "first_conf": first.confidence   if first else 0.0,
  "dob":        dob.value_date.isoformat() if dob and dob.value_date else None,
  "doc_type":   doc.doc_type,     # tells you WHICH id it thinks it is
}

# WHAT TO CHECK:
# - doc_type first. If it classified a PAN card as a passport,
#   every field mapping below it is wrong.
# - value_date is already parsed - prefer it over value_string
# - confidence is 0-1 here (contrast with Textract's 0-100)

from paddleocr import PaddleOCR
import json, re

ocr = PaddleOCR(use_angle_cls=True, lang="en")   # add 'devanagari' etc as needed

def read(path):
    res = ocr.ocr(path, cls=True)
    lines = []
    for block in res:
        for (_box, (text, conf)) in block:
            lines.append({"text": text, "conf": float(conf)})   # conf 0-1
    return lines

# WHAT COMES BACK: a flat list of text lines with confidences and boxes.
# NO field names. Structuring is your job - see the module for the
# LLM prompt and the grounding check that stops invented values.

def to_text(lines, min_conf=0.60):
    return "\n".join(l["text"] for l in lines if l["conf"] >= min_conf)

# WHAT TO CHECK:
# - drop low-confidence lines BEFORE structuring, or the LLM will
#   faithfully structure garbage
# - keep the raw lines: they are your grounding corpus for verifying
#   whatever the LLM returns

1. AUTHENTICATE
   POST /auth  {client_id, client_secret}  ->  {token, expires_in}
   Cache the token. Re-authenticating per request is the most common
   cause of rate-limit errors in the first week.

2. INITIATE (for flows needing consent or a redirect)
   POST /kyc/initiate
     {customer_ref, purpose, redirect_url, consent_text}
   -> {request_id, redirect_url}
   Store request_id. Everything afterwards is keyed on it.

3. RESULT  (webhook is authoritative; polling is a fallback)
   POST  your /webhook   <- the vendor calls YOU
     {request_id, status, data{...}, signature}
   GET /kyc/status/{request_id}   <- poll only if the webhook is late

4. WHAT TO CHECK, every time:
   [ ] verify the webhook SIGNATURE before trusting the body
   [ ] status is an ENUM - handle 'pending' and 'manual_review',
       not just success/failure
   [ ] match the returned name against the name you submitted;
       a "success" can still be a different person
   [ ] store the vendor's transaction reference - you will need it
       to answer "prove this customer was verified"
   [ ] treat the raw response as evidence: store it, do not just
       parse and discard

CLIENT SIDE (mobile SDK or web)
  1. SDK captures - you never receive a raw upload path the user controls
  2. SDK returns a session token / encrypted payload, NOT an image
     -> if a vendor lets you POST an arbitrary image for liveness,
        that is not liveness. It is face matching on a file.

SERVER SIDE
  POST /liveness/verify {session_token}
  -> {liveness: pass|fail, score, face_match_score, session_id}

WHAT TO CHECK
  [ ] device attestation passed (Play Integrity / App Attest)
      -> this is what stops CAMERA INJECTION, the attack that
         defeats passive AND active liveness
  [ ] liveness and face_match are SEPARATE decisions with separate
      thresholds. A live person who is not the document holder
      passes liveness and must fail match.
  [ ] face_match is a band, not a line:
        > 0.80  accept
        0.60-0.80  human review
        < 0.60  reject
      Calibrate on YOUR user base. Published thresholds are tuned
      on datasets that do not look like your customers.
  [ ] store session_id - the vendor holds the recording and you will
      need to retrieve it during a dispute