> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://docs.withverifa.com/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://docs.withverifa.com/_mcp/server.

# Choosing an Integration Method

> Compare Verifa's integration options and pick the right one for your use case.

Verifa offers four ways to integrate identity verification into your product.
Choose based on your engineering resources, platform, and how much control you
need over the user experience.

## Comparison

|                            | Web Capture            | Mobile SDK                  | API-Only          | **verifa.js SDK**          |
| -------------------------- | ---------------------- | --------------------------- | ----------------- | -------------------------- |
| **Setup time**             | Minutes                | Hours                       | Days              | **Minutes**                |
| **Engineering effort**     | Minimal                | Moderate                    | Full              | **Minimal**                |
| **Platforms**              | Web (all browsers)     | iOS, Android, React Native  | Any               | **Web (all browsers)**     |
| **User stays in your app** | Redirect or iframe     | Yes                         | Yes               | **Popup or modal**         |
| **UI customization**       | Theming (colors, logo) | Theming + native feel       | Complete control  | **Theming (colors, logo)** |
| **Camera handling**        | Verifa-managed         | Verifa-managed (native)     | You build it      | **Verifa-managed**         |
| **Liveness detection**     | Built-in               | Built-in (native)           | You implement     | **Built-in**               |
| **Fraud signals**          | Automatic (150+)       | Automatic (native + device) | Manual submission | **Automatic (150+)**       |
| **Backend required**       | Yes                    | Yes                         | Yes               | **Recommended**            |
| **Best for**               | Web apps, quick launch | Mobile-first products       | Custom workflows  | **SPAs, popup/modal UX**   |

## Web Capture (recommended for most)

The fastest path to production. Create a session via the API, redirect the user
to the `capture_url`, and receive results via webhook.

**How it works:**

1. Your server calls `POST /api/v1/sessions`
2. Redirect the user to `capture_url` (or embed it in an iframe)
3. Verifa handles document scanning, selfie, liveness, and consent
4. User is redirected back to your `redirect_url`
5. You receive a webhook with the result

**When to choose this:**

* You're building a web application
* You want to launch quickly with minimal frontend code
* You want automatic fraud signal collection
* You don't need deep native camera control

See [Web Capture Flow](/integration-guides/web-capture-flow) for the full integration guide.

## Mobile SDK

Native SDKs for iOS, Android, and React Native. The SDK handles camera capture,
liveness detection, and document scanning with a native look and feel.

**How it works:**

1. Your server calls `POST /api/v1/sessions` and passes the session token to
   your mobile app
2. Initialize the SDK with the session token
3. The SDK presents native camera screens for document and selfie capture
4. On completion, the SDK calls back to your app
5. You receive a webhook with the result

**When to choose this:**

* You're building a native mobile app
* You need the best camera quality and UX
* You want native device signals (root detection, gyroscope, touch pressure)
* You need iOS App Clip or Android Instant App support

See [Mobile SDK](/integration-guides/mobile-sdk) for the integration guide.

## API-Only

Full control over the capture experience. You build the camera UI, collect
documents and selfies, and submit them through the API. Verifa handles
verification processing.

**How it works:**

1. Your server calls `POST /api/v1/sessions`
2. Your app captures document images and selfie
3. Upload documents via `POST /api/v1/sessions/\{id\}/documents`
4. Submit for processing via `POST /api/v1/sessions/\{id\}/complete`
5. You receive a webhook with the result

**When to choose this:**

* You need complete control over the user experience
* You're integrating into an existing capture flow
* You're building for a non-standard platform (kiosk, desktop app, etc.)
* You want to pre-process images before submission

See [API-Only Integration](/integration-guides/api-only-integration) for the full guide.

## verifa.js SDK (easiest)

A lightweight JavaScript SDK that opens the Verifa capture UI as a popup,
modal, or redirect. Works with any web framework.

**How it works (recommended):**

1. Your server creates a session via `POST /api/v1/sessions` (secret key stays
   on your server)
2. Your frontend receives the `capture_url`
3. Call `Verifa.open()` — opens the capture UI in a popup or modal
4. Handle the completion in your callback

```html
<script src="https://app.withverifa.com/static/verifa.js"></script>
<script>
  document.getElementById('verify-btn').addEventListener('click', async function() {
    // Your backend creates the session
    const res = await fetch('/api/create-verification', { method: 'POST' });
    const session = await res.json();

    Verifa.open({
      captureUrl: session.capture_url,
      sessionId: session.id,
      mode: 'popup',
      onComplete: function(data) {
        console.log('Done:', data.sessionId, data.status);
      }
    });
  });
</script>
```

**When to choose this:**

* You want a popup or modal verification UI without building it yourself
* You're building a single-page application (SPA)
* You want a drop-in "Verify Identity" button
* You already have a backend that can create sessions

See [JavaScript SDK](/integration-guides/java-script-sdk) for the full integration guide.

## Decision guide

```
Do you have a mobile app?
├── Yes → Is native camera quality critical?
│         ├── Yes → Mobile SDK
│         └── No  → Web Capture (in WebView) or Mobile SDK
└── No  → Do you need full UI control?
          ├── Yes → API-Only
          └── No  → Do you want a popup/modal in your page?
                    ├── Yes → verifa.js SDK (with backend session creation)
                    └── No  → Web Capture (full-page redirect)
```

## Mixing methods

You can use different integration methods for different parts of your product.
For example:

* **Web Capture** for onboarding on desktop
* **Mobile SDK** for onboarding on mobile
* **API-Only** for re-verification or document updates

All methods create the same session object and produce the same result format.
Your webhook handler and backend logic work identically regardless of how the
user completed capture.

## Next steps

* [Web Capture Flow](/integration-guides/web-capture-flow) — Integrate the hosted capture
  experience
* [JavaScript SDK (verifa.js)](/integration-guides/java-script-sdk) — Drop-in frontend
  integration with popup or modal
* [API-Only Integration](/integration-guides/api-only-integration) — Build your own capture
  UI
* [Mobile SDK](/integration-guides/mobile-sdk) — Native iOS, Android, and React Native

## Related

* [Quickstart](/getting-started/quickstart) — Create your first session in 5 minutes
* [Sessions](/core-concepts/sessions) — Session lifecycle and API reference
* [Webhooks Guide](/integration-guides/webhooks-guide) — Set up real-time result delivery