Inyo

Compliance & Fraud

Identity Verification (KYC)

Know your customer is who they say they are. In Inyo360's hosted widget the customer photographs a government ID and takes a selfie; Inyo360 verifies the document, confirms a live person who matches its portrait, and weighs every other signal it holds, returning one result you can act on.

A real, readable document

Passports, driver's licenses and identity cards are read and checked for authenticity and expiry, with their machine-readable zone and barcode decoded. Documents

A live face, matched to the ID

Liveness confirms a real person in front of the camera, and the face is matched against the document portrait. Biometrics

Beyond the document

The data you already hold, the phone and its carrier, sanctions lists, and the device and its connection are all weighed in the same session. Signals & Checks

One result to act on

Every check, a trust index from 0 to 100 and, under managed decisioning, a decision, delivered by signed webhook or redirect. Session Results

Welcome screen — ID verification then face verification, about a minute Choosing a document type — passport, driver's license, or identity card Prepare screen — what will be captured before the camera opens

Capturing a passport photo page, with the machine-readable zone inside the guide

Spinner with the message Reading your document

Selfie intro — why we ask, only your face in the shot, and face the light

Taking a selfie, face centred in the oval

Checking liveness and matching the face against the document portrait

All done — the customer's part of the verification is finished

Device verification
Document scanning
Selfie and liveness
Screening and checks
Session results
Completed


Two Ways to Integrate

Choose one per verification — both produce the same normalized result and honor the same configuration.

ModeHow it worksChoose this when
Hosted widgetYou create a session and receive a widgetUrl. Send it to your customer or open it in a webview. Inyo360 handles camera capture, framing guidance, retries, and localization.You want the fastest integration and no camera code of your own. This is the recommended default.
Server-to-serverYou capture the images yourself and post them to POST /v1/verifications. The call is accepted immediately; the outcome arrives by webhook or is read back.You already have a capture UI, or verification happens without a live customer (for example, re-verifying stored documents).

What Each Path Gives You

Server-to-server runs the full Inyo360 verification engine on the images you send. The hosted widget runs the same engine and adds everything that happens while the customer is holding the camera.

Server-to-server The full engine on the images you sendHosted widget The same engine, plus live capture
The full verification engine, in both Same checks, same configuration, same result
Passports, driver’s licenses and identity cards checked for authenticity, type and expiryIncludedIncluded
MRZ and barcode decoded and checked against the printed dataIncludedIncluded
Identity data compared with the document and with what you already holdIncludedIncluded
The phone line checked with the carrier: the kind of line, such as VoIP, and whether it is registered to the personIncludedIncluded
The selfie matched to the document portraitIncludedIncluded
Age estimation consistent with the document’s date of birthIncludedIncluded
The name screened against sanctions listsIncludedIncluded
US driver’s licenses matched against the issuing DMV’s recordsIncludedIncluded
Documents limited to the issuing countries you acceptIncludedIncluded
Every signal counts toward one trust scoreIncludedIncluded
Optional managed decisioning and manual reviewIncludedIncluded
Added by the hosted widget What live capture makes possible
No camera code to build or maintainNot part of this pathIncluded
Live framing and glare guidanceNot part of this pathIncluded
Customer retries an unusable capture on the spotNot part of this pathIncluded
Localized capture screensNot part of this pathIncluded
Liveness confirmed as the selfie is taken, not from a photo or a screenNot part of this pathIncluded
The device recognised across visits, by an identifier that persistsNot part of this pathIncluded
Device data: tampered browser environments and identifications replayed from another sessionNot part of this pathIncluded
Behavioral data: sessions driven by automation rather than by a personNot part of this pathIncluded
Geolocation: connections routed through VPNs, proxies, anonymising networks or hosting providersNot part of this pathIncluded
Payment card verification add-on, in the same sessionNot part of this pathIncluded
Guided capture and selfie clips as compliance evidenceNot part of this pathIncluded
Signed redirect back to your appNot part of this pathIncluded

Included Not part of this path

When server-to-server is the right fit

You already own a capture UI, or you verify documents you already hold with no customer present. You get every check in the engine above and the same result your widget sessions would produce.


How It Works

sequenceDiagram
    autonumber
    participant Y as Your System
    participant I as Inyo360
    participant C as Customer
    Y->>I: POST /v1/sessions
    I-->>Y: sessionId +<br/>widgetUrl
    Y->>C: deliver widgetUrl
    C->>I: document<br/>front / back
    C->>I: selfie + liveness
    Note over I: Run verification<br/>checks
    I-->>Y: signed webhook<br/>or redirect
    Y->>I: GET /v1/sessions/{id}
    I-->>Y: assessment,<br/>and a decision<br/>if managed
    Y->>C: show outcome

Integration Steps

StepActionEndpointDescription
1AuthenticatePOST /oauth/tokenExchange your client credentials for a Bearer token
2Create a sessionPOST /v1/sessionsReturns a sessionId and a widgetUrl
3Deliver the widget—Send the link, or open it in a webview
4Receive the resultyour webhookUrlA signed POST of the verification result
5Read the result—Interpret status, checks[], trustIndex, and decision if you have it
6Confirm server-sideGET /v1/sessions/{sessionId}The authoritative record for a single widget session. A server-to-server verification is read at GET /v1/verifications/{verificationId}

Skipping the widget? Replace steps 2-4 with a server-to-server verification, and read step 6 at GET /v1/verifications/{verificationId}.


What You Receive

Every verification resolves to one normalized result containing the extracted document and person data, the individual checks, and — under managed decisioning — the decision:

{
  "sessionId": "…",
  "userRef": "user-123",
  "status": "completed",
  "decision": "approved",
  "document": { "type": "passport", "number": "…", "expirationDate": "2033-09-30" },
  "person": { "firstName": "…", "lastName": "…", "dateOfBirth": "1988-03-04" },
  "checks": [
    { "name": "document_not_expired", "status": "passed", "group": "document", "severity": "critical", "detail": "…" },
    { "name": "face_match", "status": "passed", "group": "selfie", "severity": "high", "detail": "similarity vs threshold 90.0" }
  ],
  "provider": "inyo",
  "trustIndex": 100,
  "completedAt": "2026-07-31T14:04:57.874Z"
}

What that result concludes depends on your decisioning mode. Under non-managed decisioning — the default — Inyo360 publishes the assessment and you decide. Under managed decisioning Inyo360 also reaches a verdict, delivered as decision: approved, declined, inconclusive, or in_review while a person looks at it.

The full payload and the rules for reading it are on Session Results.


Architecture Pattern

Your OAuth credentials are server-side only. Create sessions from your backend and hand the customer only the returned widgetUrl — it carries a single-use, time-limited code and grants access to nothing but that one verification.

flowchart TB
    subgraph browser["Customer's device"]
        C["Browser /<br/>webview"]
    end
    subgraph yours["Your infrastructure"]
        S["Your server<br/>holds OAuth credentials"]
    end
    subgraph inyo["Inyo360"]
        W["Hosted widget"]
        A["Tenant API"]
    end
    S -->|"POST /v1/sessions<br/>Bearer token"| A
    A -->|"widgetUrl"| S
    S -->|"widgetUrl only"| C
    C -->|"document + selfie"| W
    W --> A
    A -->|"signed result"| S

Environments

ResourceURL
Tenant API (sandbox)https://{FQDN}
Tenant API (production)https://{FQDN}
Widget hosthttps://{FQDN}

Base URLs, OAuth client credentials, and IP allowlisting are issued by Inyo during onboarding. Sandbox and production credentials are not interchangeable.


Next Steps

PageWhat it covers
Getting StartedRun one verification end to end
AuthenticationTokens, scopes, and error handling
Verification SessionsEvery field on POST /v1/sessions
Receiving ResultsSignature verification and delivery modes
Manual ReviewHandling an in_review decision correctly
Sandbox & Test DataTesting before you go live