Extending Twilio Verify Beyond Carrier Channels: Passkeys, TOTP, and Push Without the Plumbing

November 19, 2026
Written by
Reviewed by

Extending Twilio Verify Beyond Carrier Channels

Extending Twilio Verify Beyond Carrier Channels: Passkeys, TOTP, and Push Without the Plumbing

Most teams arrive at Verify for one channel - usually SMS one-time passwords (OTPs) - then add voice, WhatsApp, or email as a parameter change. Twilio provides useful infrastructure to implement OTP verification channels like carrier integrations, easy onboarding, and seamless developer experience. But what about the open source software channels like Passkeys, Time-based one-time password (TOTP), and Push?

You could build all three. TOTP is a published RFC, WebAuthn is a standard browser API, and push runs on established APNs and FCM infrastructure. But like so many things in software, especially now, building a prototype and running it in production are two different problems.

Why to use Twilio Verify for Passkeys, TOTP, and Push verification channels

Using Twilio Verify creates a durable solution that outlasts the prototype by providing:

Cryptographic server and credential custody. Verify will ensure your application stays current to changing specs so you always have a conformant FIDO2 relying party, a properly encrypted seed store, and a mobile credential manager that's up to date with every OS release.

Identity management overhead. Verify makes managing software factors simple, so you have a uniform user state, combined audit trails, and seamless identity reconciliation during authentication.

Verify provides one object model across every software channel

Verify unifies authentication factors across channels using four core resources:

  1. Service (configuration boundary)
  2. Entity (user identity identifier)
  3. Factor (registered authenticator)
  4. Challenge (authentication attempt and lifecycle).

Verify also provides an identity abstraction boundaryusing the Entity identifier rather than PII. Software factors map directly to this identifier, keeping user profiles isolated within your primary database.

Verify Passkeys: you do not want to run a FIDO2 server

Operating a WebAuthn relying party requires generating PublicKeyCredentialCreationOptions, parsing CBOR binary payloads (it's like JSON but less readable), verifying signatures over authenticatorData and clientDataJSON, (more crypto!) and managing public key storage (EVEN more crypto!).

Cross-platform origin validation adds further complexity: Web applications send HTTPS origins, whereas Android applications transmit hash signatures (e.g., android:apk-key-hash:<base64>). Verify abstracts origin validation across build variants via Service configuration:

curl -X POST "https://verify.twilio.com/v2/Services" \
  --data-urlencode "FriendlyName=My App" \
  --data-urlencode "Passkeys.RelyingParty.Id=example.com" \
  --data-urlencode "Passkeys.RelyingParty.Name=My App" \
  --data-urlencode "Passkeys.RelyingParty.Origins=https://example.com" \
  --data-urlencode "Passkeys.UserVerification=preferred" \
  -u $TWILIO_API_KEY:$TWILIO_API_SECRET

Twilio Verify Passkey registration only requires two API steps:

  1. Create a passkey factor by making a call to the Factors subresource /Passkeys/Factors
  2. Verifying the passkey factor by making a call to the VerifyFactor subresource /Passkeys/VerifyFactor:
curl -X POST "https://verify.twilio.com/v2/Services/$VERIFY_SERVICE_SID/Passkeys/Factors" \
    -u $TWILIO_API_KEY:$TWILIO_API_SECRET \
    --json @- <<EOF
  {
    "identity": "$USER_UUID",
    "friendly_name": "Alex's iPhone"
  }
  EOF

Authentication follows the same pattern using /Passkeys/Challenges and /Passkeys/ApproveChallenge. This eliminates self-hosted relying party maintenance, assertion parsing, and custom origin branching. Authenticator settings like DiscoverableCredentials are managed directly via API so your coding agent can seamlessly make changes for you.

Three things stay on your side of the line.

Client implementations. Web applications use standard navigator.credentials API calls directly against Verify endpoints. Mobile applications use Twilio SDKs to wrap platform credential manager APIs.

Domain association requirements. Applications must serve .well-known/assetlinks.json and apple-app-site-association files matching the application's signing certificates to prevent registration failures.

Credential sync and fallback. Passkey sync is managed by client ecosystem providers (e.g., iCloud Keychain, Google Password Manager). For new or un-synced devices, Verify allows seamless fallback to carrier channels within the same Service.

TOTP: the algorithm is easy, the seed is the problem

TOTP seeds require secure key storage equivalent to password hashes. Like Passkeys, while the standard is manageable the edge cases will be what cause you frustration and incidents. While generating a one-time code is trivial, storing the secret seed is not. A TOTP seed is a long lived shared secret in the same risk class as a password hash, with less industry muscle memory around handling it. Verify simplifies this for you by generating the seed, storing it, and securely handling the things that are easy to mess up like clock drift skew.

To create a new TOTP factor with Verify:

curl -X POST "https://verify.twilio.com/v2/Services/$VERIFY_SERVICE_SID/Entities/$USER_UUID/Factors" \
  --data-urlencode "FriendlyName=Alex's Authenticator" \
  --data-urlencode "FactorType=totp" \
  -u $TWILIO_API_KEY:$TWILIO_API_SECRET
# The response carries binding.uri. Render it as a QR code for Google Authenticator, 1Password, Authy, or any RFC 6238 app. Verify the Factor before issuing your first challenge

Your application then renders the factor.binding.uri as a QR code which the end user can scan with their RFC 6238 compliant application like Authy or Google Authenticator. When you want to issue a verification challenge, one API call will allow you to check the user-entered token from their application:

curl -X POST "https://verify.twilio.com/v2/Services/$VERIFY_SERVICE_SID/Entities/$USER_UUID/Challenges" \
  --data-urlencode "FactorSid=$FACTOR_SID" \
  --data-urlencode "AuthPayload=123456" \
  -u $TWILIO_API_KEY:$TWILIO_API_SECRET
# status is "approved" when the code is valid and "pending" when it is not.
# A wrong code is not an error response.

If you already have a different TOTP solution, existing secrets can be imported via Binding.Secret for seamless migration into Verify.

Push and silent device approval: the lifecycle is the work

Push factors store an asymmetric public key on Verify while securing the private key on the device with the Android Keystore or iOS Keychain.

In addition to properly managing the key storage, benefits of using Verify Push include:

  1. Resilient delivery. Automated key lifecycle management, token rotation, challenge timeouts, and signed webhook notifications.
  2. Seamless customization. Custom payloads can include user-visible details and secure hidden_details.
  3. Notification reliability. Because APNs and FCM delivery can be delayed by power-saving modes or network constraints, Verify SDKs support active polling for pending challenges to ensure completion.
  4. Silent device approval. Silent authentication validates in-app sessions in the background. Always match challenge SIDs or transaction tokens in hidden_details prior to approval to prevent unauthorized validations.

Why Verify Passkeys, TOTP, or Push belong in the stack you already have

If you already run Verify, adding a software channel is not a new integration. It is a Factor call against an Entity you already have, in a Service you already configured, with the same provider authentication, error conventions, and console.

Using Verify beyond OTP channels provides:

  • Multi-factor flexibility. Support diverse user preferences (TOTP, push, SMS) through one API surface and object model.
  • Centralized factor inventory. Querying GET /Entities/{identity}/Factors provides a single source of truth for user authentication capabilities.
  • Seamless account recovery. If the user loses access to one channel your application can transition back to configured carrier channels within the same Service, maintaining rate limits and fraud protection.

Two boundaries worth knowing before you design

Verify gives you factor primitives, lifecycle state, and verification endpoints, but it does not enforce cross channel policy. Deciding when to challenge with a passkey versus falling back to push or SMS lives in your application logic, or in CIAM tooling that calls these same Verify APIs underneath. The one native fallback is channel=auto, where Silent Network Auth can fall back to SMS, and it does not touch the software channels.

Audit logging has the same shape. Verify Events and the Verification Attempts API cover SMS, WhatsApp, RCS, and Voice. Push has webhooks, but TOTP and passkeys support neither events nor attempts, so persist API responses at your integration layer if you need an audit trail.

Next steps

Explore our documentation and guides to start implementing advanced verification channels in your application.

We can't wait to see what you build.