Most identity verification APIs look alike in a demo. A user holds a passport up to a phone camera and takes a selfie, and a green tick appears a few seconds later. The work that separates one vendor from another shows up after the contract is signed, when you wire the result into your backend and try to test the failure paths.
Your login stack already confirms that someone holds a password or a passkey. It doesn’t tell you who that person is, and that’s the gap an identity verification API fills by matching a government document to a live face, usually at signup and again before a risky action such as a payout.
This comparison covers six providers from the integration side. Each was checked against its own developer documentation and pricing pages in November 2026, so the notes below describe what a backend engineer meets on the first day of work, from the first API call to the last webhook.
What separates one identity verification API from another
The six APIs share one basic shape. Your backend creates a session, the user completes capture in a client the vendor supplies, and the vendor sends the result back to your server. The differences sit in five places:
- Session start: how the backend authenticates and how much the first request needs.
- Client options: a hosted page, an embeddable web flow, native mobile SDKs, or a server-side endpoint that accepts images you captured yourself.
- Result delivery: webhook events, signature checks, and whether a human review can change an automated result after it lands.
- Testing: whether a sandbox lets you force approved and declined outcomes on demand.
- Pricing: published on the website or quoted after a sales call.
The order below reflects how much of that list each API covers without extra work for a team that wants to ship within weeks.
iDenfy
iDenfy keeps the session model small. One POST to its token endpoint, authenticated with HTTP Basic auth using your API key and secret, starts a verification, and the only required field is a clientId you choose. The response returns an authToken for the client, a scanRef to store against the user and a redirect URL.
From there you pick the client. A redirect or an iFrame covers web apps, native SDKs cover Android, iOS, React Native and Flutter, and a direct processing endpoint accepts document and face images that your own app captured. For a team choosing an identity verification service on integration effort, this range is the main reason iDenfy sits first here: one backend session serves every client, so a web launch and a later mobile launch share the same server code. iDenfy ships no JavaScript web SDK by design and recommends the iFrame, which keeps the web side to a URL and a few attributes. Direct processing has to be enabled on your contract and skips 3D liveness, so most teams will start with the iFrame or a mobile SDK.
Results come back as webhooks signed with an HMAC-SHA256 of the body in the Idenfy-Signature header. The automated result arrives first, and a separate event follows when a manual review finishes, so a handler can treat an early approval as provisional until the reviewed result lands. Each result carries an overall status of APPROVED, DENIED, SUSPECTED or REVIEWING, together with mismatch and fraud tags, such as a duplicate face or a virtual camera, that explain a decision without a support ticket.
Most extra checks are flags on the same token request, including AML screening, proof of address, phone and email verification, NFC chip reading and duplicate-face detection. Returning users can be re-authenticated against the face from an earlier verification by passing its scanRef, with no second document scan.
Testing is just as direct. In the development environment you set a dummyStatus when creating the token and get an approved, denied, suspected or expired result on demand, which lets you exercise every webhook branch before a real document goes through. A deletion endpoint removes a verification’s images and personal data by scanRef. Billing is charged per successful verification, and a free trial runs for 14 days or 10 verifications, whichever comes first.
Persona
Persona organizes verification around inquiries, each created from an inquiry template that you configure in its dashboard. On the web, you can send users to a hosted flow on Persona’s domain or load an embedded flow as an iframe through a JavaScript SDK. Native SDKs cover iOS, Android and React Native.
Webhook handling is documented in detail. Each delivery carries a persona-signature header that combines a timestamp with an HMAC-SHA256 of the body, the header can hold more than one signature while you rotate a secret, and a failed delivery is retried up to seven more times with exponential backoff between attempts. Webhooks can also be pinned to a dated API version, so a schema change does not reach your handler until you choose to move.
The sandbox carries no usage charges and offers a toggle that forces passes or fails. The trade-offs appear when you go live. Production is enabled only after you contact Persona, and a fully custom capture UI, which Persona calls a transactions-based integration, also goes through its support engineering team. Much of the verification logic sits in dashboard templates outside your repository. The Essential plan starts at $250 per month with a 12-month minimum term, and higher tiers are quoted.
Stripe Identity
Stripe Identity suits teams that already take payments through Stripe. A verification is a VerificationSession with its type set to document, and setting options.document.require_matching_selfie adds the face match. On the web, the flow opens as a modal from Stripe.js or as a redirect to a Stripe-hosted page, and mobile SDKs cover iOS, Android and React Native.
Results arrive as identity.verification_session.verified or identity.verification_session.requires_input events, verified through the stripe-signature header with the same SDK call you already use for payment webhooks. When a session needs input, a last_error code such as document_expired or selfie_face_mismatch states the reason, so you can map failures to user-facing messages without guessing.
Pricing is public: $1.50 per document and selfie verification, charged when the user completes it, with the first 50 verifications free. The main limit for international products is document data. Stripe does not extract fields from documents written in Arabic, Chinese, Cyrillic, Greek, Hebrew, Korean, Tamil or Thai script, so a team with users in those markets should check what a session returns for their documents before committing.
Onfido (Entrust)
Onfido now operates under the Entrust name. Its developer portal and SDKs carry the new branding, while API hosts such as api.eu.onfido.com keep the old one. The model centers on applicants and on workflows built in Workflow Studio, Entrust’s visual orchestration tool. Creating a workflow run returns an sdk_token for the client, and API tokens cannot be used to authenticate the SDKs.
Clients include the Smart Capture Web SDK and native SDKs for iOS, Android and React Native. Smart Capture Link adds a hosted option, with each user’s unique URL returned in the workflow run response. Webhooks such as workflow_run.completed carry an HMAC-SHA256 signature in an X-SHA2-Signature header. In the sandbox, results are pre-determined and free of charge: an applicant with the last name Consider returns a consider result, and any other name returns clear.
The detail to plan for is regions. API v3.6 has separate base URLs for the EU, the US and Canada with no default, and API tokens are prefixed by region, so a product serving more than one region needs its configuration and secrets split to match. Pricing is not published.
Veriff
Veriff starts a session with a POST to /v1/sessions, authenticated by an API key in the X-AUTH-CLIENT header, and returns a verification URL for the client. It has the longest client list in this group: a redirect, a JavaScript SDK, an InContext SDK for in-page flows, and SDKs or plugins for Android, iOS, React Native, Flutter and Cordova.
Results come through a decision webhook, with an optional event webhook that tracks the user’s progress through the flow. Veriff guarantees at-least-once delivery and retries for up to a week, so the receiving endpoint has to be idempotent. Decision statuses include approved, declined, resubmission_requested, review, expired and abandoned. The resubmission state means your interface needs a path for a user who is asked to try again.
Other API calls must be signed with an HMAC-SHA256 of the payload using a shared secret, which adds a signing helper to your client code. Self-serve pricing is published, starting at $0.80 per verification with a $49 minimum monthly commitment. A 15-day free trial includes 50 live verifications alongside unlimited sandbox tests.
Plaid Identity Verification
Plaid Identity Verification runs inside Plaid Link. You create a Link token with an identity verification template ID, and most options live in the Template Editor in Plaid’s dashboard. Identity verification cannot share a Link session with other Plaid products. Besides the Link SDKs for web and mobile, Plaid offers a shareable verification link that does not expire, though it cannot be embedded in an iframe, and a backend-only flow for data source checks with no user interface.
A session can combine SMS verification, a data source check against records, a document check and a selfie check. AML screening needs Plaid’s separate Monitor product. Webhooks report STEP_UPDATED, STATUS_UPDATED and RETRIED events, are configured in the dashboard and arrive in no guaranteed order.
The sandbox has to be enabled for the product, always treats uploaded documents as genuine and does not run selfie checks, so the selfie path gets its first real test in production. Two business constraints come before any code. Your company must be based in the US, Canada or the UK, and pricing is not public, with a base fee for each attempted verification plus separate fees per check.
The six APIs side by side
| Provider | Session start | Client options | Published pricing |
|---|---|---|---|
| iDenfy | POST /api/v2/token, Basic auth, clientId only | Redirect, iFrame, Android, iOS, React Native, Flutter, direct image processing | Charged per successful verification; free trial of 14 days or 10 verifications |
| Persona | Inquiry from a dashboard template | Hosted flow, embedded iframe, iOS, Android, React Native | Essential plan from $250 per month, 12-month term |
| Stripe Identity | VerificationSession through the Stripe API | Stripe.js modal, redirect, iOS, Android, React Native | $1.50 per document and selfie verification, first 50 free |
| Onfido (Entrust) | Workflow run returns an sdk_token | Web SDK, Smart Capture Link, iOS, Android, React Native | Not published |
| Veriff | POST /v1/sessions with an X-AUTH-CLIENT key | Redirect, JavaScript and InContext SDKs, Android, iOS, React Native, Flutter, Cordova | From $0.80 per verification, $49 monthly minimum |
| Plaid Identity Verification | Link token with a template ID | Plaid Link for web and mobile, shareable link, backend data checks | Not published; US, Canadian or UK companies only |
Picking one for your stack
The platform you already run narrows the choice quickly. A team on Stripe payments gets identity checks without adding a vendor, and a team already using Plaid Link can add verification to a flow its users have seen before. Outside those cases, most of the integration effort goes into the webhook handler and the test suite, so before signing it’s worth asking each vendor whether you can force every outcome from code in a sandbox, and whether results arrive as signed events that keep an automated decision apart from a reviewed one.
Build a short spike against your top two choices before you commit. A day spent creating sessions, receiving signed webhooks and forcing a declined result in each sandbox will show you what the next few years of maintenance look like, and the code you write for the winner won’t go to waste.