Skip to main content

Best Identity Verification APIs 2026

·APIScout Team
identity verificationkycstripe identitypersonajumioonfidodocument verificationbiometric verification

Identity Verification Is Regulatory and Fraud Reality

Know Your Customer (KYC) requirements are no longer just for banks. Crypto exchanges, fintech apps, marketplaces, and gig economy platforms face regulatory requirements to verify user identity before onboarding. Beyond compliance, identity verification prevents synthetic identity fraud — the creation of fake identities using a mix of real and fabricated information.

The technical challenge: verify a government-issued ID document (passport, driver's license, national ID) and confirm the submitting person matches the document photo, without building a computer vision pipeline, a document validation database, or a liveness detection system from scratch.

In 2026, four platforms dominate developer-accessible identity verification: Stripe Identity (simple, Stripe-integrated, $1.50/verification), Persona (modular, flexible, used by Brex and OpenAI), Jumio (enterprise KYC/AML with global document support), and Onfido (AI-powered document and biometric verification).

TL;DR

Stripe Identity is the easiest integration for Stripe-native applications — $1.50/verification, 50 free, minimal setup, and the result flows into your Stripe customer record. Persona is the most modular and developer-friendly platform — mix and match verification steps (government ID, selfie, database checks, custom signals) to build the right verification flow for your use case. Jumio is the enterprise KYC/AML choice for regulated industries (banking, crypto, lending) requiring the highest compliance standards. Onfido is the well-regarded alternative for global document verification with AI-powered document authenticity checks.

Key Takeaways

  • Stripe Identity charges $1.50 per verification — document + selfie check. First 50 verifications are free. Only works within Stripe ecosystem.
  • Persona pricing is $1-2/verification for standard flows — modular platform where you pay for the verification steps you configure.
  • Jumio pricing is custom (enterprise, contact sales) — estimated $2-5/verification at scale, with compliance-grade outputs including KYC/AML results.
  • Onfido charges per check — ID document verification, facial similarity, and database checks priced separately; typical full-stack verification is $1.50-$3.00.
  • Document support varies significantly — Jumio and Onfido support 200+ countries with 5,000+ document types; Stripe Identity focuses primarily on US/major markets.
  • Liveness detection (anti-spoofing that ensures the selfie is of a live person, not a photo of a photo) is included in all four platforms but varies in sophistication.
  • Compliance outputs (KYC status, AML watchlist screening, PEP checks) are available on Jumio and Onfido but not Stripe Identity or Persona standard plans.

Pricing Comparison

PlatformPer VerificationFree TierDocument Coverage
Stripe Identity$1.5050 verificationsUS-focused
Persona$1-2/verificationYes (sandbox)200+ countries
JumioCustom (contact sales)No200+ countries, 5,000+ docs
Onfido$1.50-$3.00 (varies by check)No (sandbox)195+ countries

Stripe Identity

Best for: Stripe-native applications, simple verification, US-focused, fast integration

Stripe Identity integrates directly with Stripe's payments ecosystem — verified identity results are attached to Stripe Customer records and can be used alongside Stripe Radar for fraud prevention. The integration is intentionally simple: minimal code, hosted verification UI, and results delivered via webhook.

Pricing

  • $1.50 per verification (document + selfie)
  • First 50 verifications free
  • Included in standard Stripe dashboard, no separate contract

Integration

// Server-side: create a verification session
const stripe = require("stripe")(process.env.STRIPE_SECRET_KEY);

app.post("/verify-identity", async (req, res) => {
  const verificationSession = await stripe.identity.verificationSessions.create({
    type: "document",
    metadata: {
      user_id: req.user.id,
    },
    options: {
      document: {
        allowed_types: ["driving_license", "passport", "id_card"],
        require_id_number: true,
        require_live_capture: true,
        require_matching_selfie: true,
      },
    },
    return_url: `https://your-app.com/verification-result?session_id={CHECKOUT_SESSION_ID}`,
  });

  // Return the verification URL — redirect user to hosted Stripe verification UI
  res.json({
    url: verificationSession.url,
    id: verificationSession.id,
  });
});

// Webhook: receive verification result
app.post("/webhooks/stripe", express.raw({ type: "application/json" }), async (req, res) => {
  const event = stripe.webhooks.constructEvent(
    req.body,
    req.headers["stripe-signature"],
    process.env.STRIPE_WEBHOOK_SECRET
  );

  if (event.type === "identity.verification_session.verified") {
    const session = event.data.object;

    // session.verified_outputs contains:
    // - first_name, last_name, dob, address
    // - document type and number
    // - id_number (if required)

    await db.users.update({
      where: { id: session.metadata.user_id },
      data: {
        identity_verified: true,
        verified_name: `${session.verified_outputs.first_name} ${session.verified_outputs.last_name}`,
        verified_at: new Date(),
      },
    });
  }

  if (event.type === "identity.verification_session.requires_input") {
    // Verification failed — document unclear, selfie mismatch, etc.
    const session = event.data.object;
    await notifyUserVerificationFailed(session.metadata.user_id);
  }

  res.json({ received: true });
});

Limitations

  • Primarily optimized for US/major market document types
  • No AML watchlist screening or PEP checks
  • Requires Stripe integration — can't use as standalone verification outside Stripe
  • No white-label option for verification UI

When to Choose Stripe Identity

Applications already processing payments through Stripe, US-focused products where global document support is not required, or teams that need identity verification quickly without enterprise sales conversations or complex integration.

Persona

Best for: Modular verification flows, startup to scale, developer experience, flexibility

Persona is the modular identity verification platform — you compose verification flows from building blocks (government ID check, selfie match, database verification, custom signals) and configure the logic (pass/fail thresholds, re-verification triggers). Used by Brex, OpenAI, Marqeta, and hundreds of fintech and marketplace companies.

Pricing

Persona's pricing is usage-based and depends on the verification steps configured:

  • Government ID + selfie: ~$1.50-2.00/verification
  • Database checks (SSN, address verification): Additional cost
  • Custom requirements: Enterprise pricing

Free sandbox environment for development and testing.

Flow Builder (No-Code Configuration)

// Persona embedded flow — client-side
import Persona from "persona";

const client = new Persona.Client({
  templateId: "itmpl_your-template-id",  // Configured in Persona dashboard
  environmentId: process.env.NEXT_PUBLIC_PERSONA_ENVIRONMENT_ID,
  onLoad: (error) => {
    if (error) console.error("Persona load error:", error);
  },
  onComplete: ({ inquiryId, status, fields }) => {
    // inquiryId: use to retrieve results server-side
    console.log(`Verification ${status}: ${inquiryId}`);
    submitVerification(inquiryId);
  },
  onFail: ({ inquiryId, fields }) => {
    console.log("Verification failed:", fields);
  },
});

// Open verification flow
client.open();

// Server-side: retrieve inquiry results
async function getVerificationResult(inquiryId) {
  const response = await fetch(
    `https://withpersona.com/api/v1/inquiries/${inquiryId}`,
    {
      headers: {
        "Authorization": `Bearer ${process.env.PERSONA_API_KEY}`,
        "Persona-Version": "2023-01-05",
      },
    }
  );

  const inquiry = await response.json();

  return {
    status: inquiry.data.attributes.status,  // "completed" | "failed" | "needs_review"
    name: inquiry.data.attributes["name-first"] + " " + inquiry.data.attributes["name-last"],
    dob: inquiry.data.attributes.birthdate,
    documentType: inquiry.data.attributes["identification-class"],
    documentNumber: inquiry.data.attributes["identification-number"],
  };
}

Webhook Integration

app.post("/webhooks/persona", async (req, res) => {
  const event = req.body;

  // Verify webhook signature
  const signature = req.headers["persona-signature"];
  // Validate against PERSONA_WEBHOOK_SECRET

  switch (event.data.type) {
    case "inquiry.completed":
      await approveUser(event.data.attributes.reference_id);
      break;
    case "inquiry.failed":
      await flagUserForReview(event.data.attributes.reference_id);
      break;
  }

  res.json({ received: true });
});

When to Choose Persona

Startups and growth-stage companies that need flexible identity verification without enterprise pricing, marketplaces and fintech requiring modular verification flows (e.g., lighter verification for low-risk users, stricter for high-risk), or teams that want to configure verification logic without hard-coding business rules into their application.

Jumio

Best for: Enterprise KYC/AML, regulated industries, global document support, compliance outputs

Jumio is the enterprise identity verification platform for regulated industries — banking, crypto exchanges, lending, insurance, healthcare. The platform goes beyond document verification to provide full KYC/AML outputs: identity verification, watchlist screening (OFAC, UN, EU sanctions), PEP (Politically Exposed Persons) checks, and adverse media screening.

Enterprise KYC Outputs

CheckDescription
Document verification5,000+ document types from 200+ countries
Biometric livenessActive and passive liveness detection
AML watchlist screeningOFAC, UN, EU sanctions, custom lists
PEP screeningPolitically Exposed Persons database
Adverse mediaNews screening for negative coverage
Address verificationAddress validation and residency check

Pricing

No public pricing — contact sales. Industry estimates:

  • Standard verification (ID + selfie): $2-5/verification
  • With AML screening: $5-15/verification
  • Enterprise volume: Significant discounts for 10K+/month

API Integration

import jumio

client = jumio.Client(
    api_token=os.environ["JUMIO_API_TOKEN"],
    api_secret=os.environ["JUMIO_API_SECRET"],
    region="US",  # or "EU", "SGP"
)

# Create a verification transaction
transaction = client.account.initiate(
    customer_internal_reference=f"user_{user_id}",
    user_reference=f"user_{user_id}",
    workflow_id=200,  # 200 = Document + ID check + Liveness
    success_url=f"https://your-app.com/verify/success",
    error_url=f"https://your-app.com/verify/error",
)

# Redirect user to Jumio's hosted verification UI
redirect_url = transaction["web"]["href"]

# Webhook: receive compliance result
@app.route("/webhooks/jumio", methods=["POST"])
def jumio_webhook():
    payload = request.json

    if payload["workflowExecution"]["status"] == "PROCESSED":
        result = payload["workflowExecution"]["credentials"][0]

        if result["decision"]["type"] == "PASSED":
            # User verified — activate account
            activate_user(payload["userReference"])
        elif result["decision"]["type"] == "REJECTED":
            # Document or liveness check failed
            flag_for_manual_review(payload["userReference"])

    return jsonify({"received": True})

When to Choose Jumio

Regulated industries with strict KYC/AML compliance requirements (banking, crypto, lending), applications requiring global document coverage (200+ countries), or organizations where AML watchlist screening is a regulatory requirement alongside identity verification.

Onfido

Best for: AI-powered verification, global coverage, developer-friendly API, flexible check bundles

Onfido's differentiator is AI-powered document authenticity analysis — checking for signs of document manipulation, fake IDs, or digitally altered documents beyond basic OCR. The platform supports 195+ countries and is used by Revolut, Zipcar, HSBC, and others.

Check Types

CheckDescription
Document reportAuthenticity analysis, data extraction
Facial similarity photoSelfie vs. document photo comparison
Facial similarity videoVideo selfie with liveness detection
Watchlist AMLOFAC, PEPs, adverse media
Right to Work (UK)UK-specific employment eligibility

Integration

// Onfido — create applicant and SDK token
const { Onfido, Region } = require("@onfido/api");

const onfido = new Onfido({
  apiToken: process.env.ONFIDO_API_TOKEN,
  region: Region.US,
});

// Create applicant
const applicant = await onfido.applicant.create({
  first_name: "Jane",
  last_name: "Smith",
  email: "jane@example.com",
});

// Generate SDK token for frontend
const sdkToken = await onfido.sdkToken.generate({
  applicant_id: applicant.id,
  referrer: "https://your-app.com/*",
});

// Frontend: launch Onfido SDK
import Onfido from "onfido-sdk-ui";

Onfido.init({
  token: sdkToken,
  containerId: "verification-container",
  steps: [
    "welcome",
    { type: "document", options: { documentTypes: { passport: true, driving_licence: true } } },
    "face",
    "complete",
  ],
  onComplete: async (data) => {
    // data contains uploaded document and selfie references
    await submitForCheck(applicant_id, data);
  },
});

// Create verification check
const check = await onfido.check.create({
  applicant_id: applicantId,
  report_names: ["document", "facial_similarity_photo"],
});

When to Choose Onfido

Applications needing AI-powered document authenticity analysis (detecting fake IDs, not just reading real ones), global coverage across 195+ countries with deep document type support, or organizations in financial services that need Onfido's established compliance credibility and regulator relationships.

Decision Framework

ScenarioRecommended
Already using StripeStripe Identity
US-focused, fast integrationStripe Identity
Modular flow, startupPersona
Flexible verification logicPersona
Enterprise KYC/AML complianceJumio
AML watchlist + PEP screeningJumio or Onfido
Global document coverageJumio or Onfido
AI document authenticityOnfido
Crypto exchange (strict KYC)Jumio
Marketplace onboardingPersona or Onfido

Verdict

Stripe Identity is the right starting point for applications already in the Stripe ecosystem — the integration takes hours, the $1.50/verification pricing is transparent, and the 50 free verifications let you test in production before committing.

Persona is the most developer-friendly platform for growth-stage companies. The modular flow builder, good documentation, and usage-based pricing without enterprise sales conversations make it the practical choice for most startups and scale-ups.

Jumio is the enterprise compliance choice for regulated industries. Banking, crypto exchanges, and lending platforms need Jumio's depth — AML watchlist screening, PEP checks, adverse media screening — that simpler platforms don't provide.

Onfido sits between Persona and Jumio — AI-powered document analysis beyond basic OCR, global coverage, and flexible check bundling for organizations that need more than Stripe Identity offers but aren't in a heavily regulated industry requiring full AML compliance.

Compare identity verification API pricing, document coverage, and compliance capabilities at APIScout — find the right KYC/AML platform for your application.

Comments