Which identity verification APIs support mobile onboarding is a product question, not a vendor shortlist. An API supports that journey when the phone can open a camera. The app backend must own the session. Signup must tell a new person from a duplicate. A bare image endpoint does not do that job by itself. VerifEye’s mobile API integration is the product path this guide scores.
Mobile teams usually meet three patterns. One is a hosted browser flow. One is a native SDK. One is a direct image API. VerifEye offers all three. Each one changes who owns the camera and the result. This guide scores the pattern against a signup screen. SDK setup steps live in another post. So does the general integration checklist.
Which Identity Verification APIs Support Mobile Onboarding?
Start with the job, not the brand. Mobile onboarding means day 0 inside an iOS or Android app. The person is new. The account does not exist yet. The check has to finish before that account can act.
The Onboard job is to anchor a real, unique human. Document checks come later, if they come at all. So do logins and step-up reviews. An API that only verifies a returning user is the wrong tool for this screen.
NIST treats enrollment as its own control. The Digital Identity Guidelines (SP 800-63-4) separate proofing a subject from authenticating one later. A mobile API has to support that first bind. A face score with nowhere to put it is not enrollment.
Four returns matter on the first successful check:
- A live-person result, from passive or active liveness.
- A stable face id the app can store instead of an image.
- A new-versus-existing flag, so a second signup cannot mint a second person.
- Room to attach the app’s own user id to that face.
Age range can ride along when the product needs it. It should stay off when signup does not ask for it. VerifEye keeps optional attributes off until the call requests them.
OWASP MASVS-AUTH-3 says the app should protect sensitive operations with an extra check. Biometrics can be that check. Signup is the first of those operations. The same face id should still work later for Reverify, Protect, and Recover. A later match confirms the same face. It does not prove account ownership.
Use that list as the filter. The API has to run on a phone. It has to keep the session on your server. It has to separate a new face from a known one. If it cannot, it does not support mobile onboarding. The rest of this guide shows how the three common patterns pass or fail that filter.
Three API Patterns That Can Support a Phone
Support is the path into the app. It is not the logo on the response. These are the patterns a mobile team can actually ship.
| Pattern. | Who opens the camera. | What the app backend does. | Fit for mobile signup. |
|---|---|---|---|
| Hosted redirect. | A browser page or iframe or popup. | Sends the user out and reads a webhook or session result. | Pilots and low engineering lift. |
| Native SDK. | The iOS or Android app. | Creates a short-lived session, then reads the outcome. | Production apps that own the screen. |
| Direct image API. | The app, with its own capture code. | Posts an image and parses face id and status. | Teams that already capture a frame safely. |
VerifEye maps onto those rows. Redirect is the hosted path. It can be a full page, an iframe, or a popup. The iOS SDK targets iOS 16 and later with SwiftUI. The Android SDK targets Android 7.0, API 24, and later with Jetpack Compose. There is also a React web SDK when the same flow must run in a mobile browser. The Face API is the direct image call. It has separate EU and US base URLs.
The native mobile SDKs share one model. The backend creates a session with the API key. It returns a short-lived session id and access token. The SDK runs consent, liveness, and capture. The backend then reads the outcome from the Session API. The phone never holds the API key.
Redirect needs no SDK. It is the right first build when the team wants a working signup before it writes camera code. It is a weaker long-term fit when the app cannot leave its own screens. A WebView around a hosted page often looks native and still breaks on camera permission. Test that on a real device before you call it supported.
The direct image API is the most flexible and the easiest to misuse. Your app must open the camera, get consent, and send a fresh frame. If any of that is sloppy, the API cannot repair it. Choose this pattern only when the app already has a safe capture path.
A private or on-prem SDK is a fourth path for teams that must keep processing in their own environment. Most mobile onboarding projects should not start there. Start with Redirect or a native SDK. Move the processing boundary only after the signup result is proven.
What the Onboarding Call Must Return
A collection starts empty. The first mobile call has to be an enroll. Later checks have nothing to match until a face is on file. VerifEye splits that work into three Face API calls. They take the same image. They do not do the same job.
Onboard registers the face and deduplicates it. Each face comes back with a face id. The status is New or Existing. Identify asks who this is and writes nothing. Compare checks one named face id. It returns a similarity score and whether it matched.
Signup should call Onboard. Login and recovery should call Compare. A lobby that does not know the person should call Identify. That split is the practical test of API support.
If signup and login share one write-capable call, duplicates and repeats get muddled. If the API cannot say New versus Existing, the app cannot stop a second account for the same person. A match score with no status flag leaves that decision to guesswork.
Keep the image off the phone after the call. Store the face id, the status, and the app user id. VerifEye confirms a real, unique person from a selfie in about three seconds. It does not collect a government ID. It does not store personally identifiable information. Do not design the account record as if a face photo had to live in it.
Ask only for the attributes that signup uses. A lean enroll stays a lean enroll. Age can be turned on for a later call without a new endpoint. Emotion and attention work the same way. The default is off.
External keys matter on mobile because the account id is born in your database, not in the face system. Attach that id when the face is new. Look the face up by it when the user returns. Otherwise the app is stuck passing raw face ids through every screen.
One image can contain more than one face. A signup screen should decide what that means before launch. Usually you want the single largest face and a hard fail if a second face is present. Silent picks create support tickets that look like model errors.
How to Judge Liveness on a Handset
Mobile liveness fails in ways a server demo hides. The front camera changes the frame. So do the lighting and the path a frame takes into the app. Passive and active liveness answer different attacks. A mobile API should let the product pick.
Passive liveness watches the frame the user already gives. Active liveness asks for a prompt. VerifEye supports both. Prompts still help against a static photo. They are weak against a real-time deepfake. A prompt is not a complete defense.
Name the attack before you pick a test. A presentation attack shows a spoof to the camera. That spoof might be a print, a screen, or a mask. An injection attack puts a synthetic frame into the camera pipeline. The sensor never sees a person. Those are different controls.
ISO/IEC 30107-4:2024 profiles presentation-attack testing for some mobile devices. It covers local recognition and integrated biometric modules. It points back to ISO/IEC 30107-3. That standard’s error rates are APCER and BPCER. The profile does not cover phones that only send biometrics to a remote service. It does not cover injection.
A cloud onboarding API can still be the right buy. It should not be sold as a 30107-4 pass. Ask for the test that matches the architecture you will ship. A lab result from a phone’s built-in face unlock does not describe a selfie sent to an API.
For a remote flow, ask a narrower question. Where is the frame captured? Who signs the session? Can a replay of an old frame open a new account? The SDK path binds capture to a short-lived session. A raw upload API cannot do that unless the app builds the binding itself.
Also test the boring failures. Permission denied. Camera in use by another app. A user who backgrounds the app mid-check. Airplane mode halfway through upload. An API that supports mobile onboarding has a defined result for each of these. A timeout with no status is not a result.
Session Design for iOS and Android
The session is the part teams skip, then pay for in fraud review. Create it on the server, for one user action, with a short life. Pass only the session id and access token to the phone. When the SDK or redirect finishes, read the outcome from the server again. Do not trust a result that only the client reports.
Bind the session to the signup attempt. If the user kills the app, the next open should resume or expire. It should not silently enroll a second time. VerifEye’s SDK model is built for that handoff. The client runs the capture. The Session API is where the backend learns what happened.
Keep the API key off the device. A shipped app can be unpacked. A long-lived key in a binary is not a secret. Short-lived tokens limit the blast radius when a phone is rooted or a build leaks.
Region choice belongs in this design too. The Face API has EU and US endpoints. Pick the region that matches where the account data may live. Do not leave that as a client toggle. The app should call your backend, and your backend should call the region you chose.
Accessibility is part of support, not a polish pass. A prompt the user cannot perform will look like a liveness failure. Offer a passive path where the risk allows it. Say clearly when the camera is required. The active liveness integration guide covers prompts and fallbacks in more depth.
A Short Test Before You Commit
Run the pilot on the real signup build. Use iOS and Android, not a desktop webcam. Five checks are enough to see whether the API supports the journey.
- Create the session on the server. Confirm the app only receives a short-lived token.
- Complete a first enroll. Store the face id and a New status. Do not store the image.
- Repeat signup with the same person. The API should return Existing, not a second person.
- Try a printed photo and a screen replay. Record whether passive or active liveness was on.
- Call Compare with the stored face id. Confirm the same person can pass a later re-check.
Add one bad-network pass. Mobile onboarding dies on a flaky radio more often than on a model miss. The session should expire cleanly. A retry must not create a second face.
Then try a second account on a second device with the same person. The enroll should still come back Existing. If it returns New, the API is matching a device, not a person. That fails the onboarding job even if every happy path looks fine.
Write down what the app does with Existing. Block the signup, offer recovery, or route to support. The API can name the collision. The product still has to choose the path. Leave that choice out of the pilot and the launch will invent one in production.
The liveness detection SDK guide covers permission prompts and release checks. Use it after this test, not instead of it. The identity verification API integration checklist covers errors, monitoring, and rollout once the pattern is chosen. Teams comparing country coverage should use the cross-country API guide rather than this one.
If the pilot cannot show a server-owned session, stop. The same bar applies to a New or Existing result and a later Compare on the same face id. Without those, the API does not yet support mobile onboarding. It only accepts a picture.
Frequently Asked Questions
Which identity verification APIs support mobile onboarding?
Look for three capabilities, not a logo. You need a capture path that runs on iOS and Android. You need a session the app backend creates. You need an enroll call that returns a face id plus New or Existing. Hosted redirect, a native SDK, and a direct image API can all qualify. A generic upload URL does not.
Is a native SDK required for mobile onboarding?
No. A hosted redirect is enough for a pilot. A direct image API is enough when the app already captures a frame safely. A native SDK is the better production fit when signup must stay inside the app. VerifEye ships iOS and Android SDKs for that case, plus Redirect and the Face API.
What should the app store after a mobile enroll?
Store the face id, the New or Existing status, and your own user id. Do not store the selfie as the credential. Later checks should send a fresh capture and the saved face id. VerifEye is designed so that record does not need a government ID or a stored face image.
Does a mobile presentation-attack test cover injection?
No. ISO/IEC 30107-4 covers spoofs shown to the camera on devices that do local recognition. Injection is different. A fake frame bypasses the sensor. Ask how the session is bound to the capture. Then test a replay on a real phone.
Can one API cover signup and later step-up?
Yes, if enroll and later checks are different calls on the same face id. VerifEye uses Onboard once, then Compare when you already know who the user claims to be. Use Protect when risk spikes. Use Recover when a real user is locked out. A match still does not prove they own the account.
Verify real humans. Without the friction.
VerifEye confirms users are real and unique in seconds. No documents, no stored data, no drop-off.
For the scale story behind the checks, read how VerifEye handles a billion verifications a day.