Give your users a self-custodial Soroban wallet secured by their passkey — Face ID, Touch ID, or Windows Hello. No seed phrases. Guardian-backed recovery. Five minutes to ship.
// 1. Init with your publishable key const parax = new Parax({ publishableKey: 'pk_live_…', network: 'mainnet', }); // 2. Authenticate — email OTP await parax.auth.requestOtp(email); await parax.auth.verifyOtp(email, code); // 3. Create a Soroban smart wallet // triggers Face ID / Touch ID registration const wallet = await parax.wallets.create({ displayName: user.name, walletType: 'CONTRACT', }); // wallet.stellarAddress → "C…" (contract) // 4. Sign a transaction const { txHash } = await parax.wallets.sign({ walletId: wallet.id, transaction: txXdr, // your XDR }); // biometric → on-chain ✓
Each wallet is an individual Soroban smart contract — not a shared multisig, not a custodial account. Signing policy, recovery, and access control live on-chain.
Parax deploys a unique WASM contract for each user. The contract is initialised with the user's passkey public key and two guardian addresses. Every on-chain action — transfer, policy update, recovery — is validated by the contract itself.
init() and stored in the contract.One package. Works in React, Next.js, Vue, or plain TypeScript. Initialise with your app's publishable key.
Send a six-digit code to the user's inbox. On verify, Parax returns a signed JWT scoped to your app — no accounts, no passwords.
One API call triggers a WebAuthn passkey registration. Parax deploys the Soroban contract and returns the on-chain address.
Pass any XDR to wallets.sign(). The user's device prompts for biometrics, the guardian cosigns, and the transaction hits Stellar.
User proposes a new passkey. After the on-chain timelock elapses, the contract allows execution — no backdoor, no trust required.
# install pnpm add @parax/sdk // init in your app import { Parax } from '@parax/sdk'; const parax = new Parax({ publishableKey: 'pk_live_…', network: 'mainnet', });
// Send OTP to the user's email await parax.auth.requestOtp(email); // User submits the 6-digit code const session = await parax.auth.verifyOtp( email, code, ); // → JWT scoped to your app // → 7-day expiry, auto-stored
// Browser prompts for Face ID / Touch ID // Parax deploys the Soroban contract const wallet = await parax.wallets.create({ displayName: 'Alice', walletType: 'CONTRACT', // Soroban }); // wallet.stellarAddress // → "CABC…XYZ" — Soroban contract // → initialised with passkey + 2 guardians
// Prepare — get tx hash for signing // Sign — biometric prompt fires // Submit — guardian cosigns + broadcasts const result = await parax.wallets.sign({ walletId: wallet.id, transaction: xdr, }); // result.txHash → confirmed ✓ // result.signatures → { passkey, guardian }
// Initiate recovery — proposes new passkey await parax.wallets.initiateRecovery({ walletId: wallet.id, newPasskeyPublicKey: newKeyHex, }); // → contract records proposal on-chain // → timelock starts (e.g. 7 days) // After timelock — execute the swap await parax.wallets.executeRecovery({ walletId: wallet.id, }); // → old passkey revoked, new one active
Every transaction needs the user's passkey plus one guardian cosignature — enforced by the Soroban contract, not by Parax servers. No single party can move funds alone. Even if Parax disappears, the wallet keeps working.
Stored in the device's secure enclave (TPM / Secure Enclave chip). Never exported, never transmitted to Parax or your server.
Your backend holds this key and co-signs every transaction. You can enforce spending limits, whitelist addresses, or require approval flows before cosigning.
Parax's guardian key is used only during recovery. It cannot be used to initiate transactions. Even if Parax shuts down, wallets remain fully operable via passkey + tenant.
Deploy programmable contract wallets on Stellar. On-chain policy enforcement, timelock recovery, and composability with DeFi protocols.
Users sign transactions with Face ID, Touch ID, or Windows Hello. WebAuthn / FIDO2 under the hood — keys never leave the secure enclave.
A six-digit code to the user's inbox is all it takes. No app install, no Chrome extension, no crypto knowledge required.
Your backend holds a co-signing key. Enforce spend limits, KYC gates, or custom approval flows before every guardian cosignature.
Users can register multiple passkeys — phone, laptop, hardware key. Each device gets its own signer slot in the contract.
Full-typed SDK for browser and Node.js. Covers auth, wallet creation, signing, export, and recovery — plus a server-side admin client.
All infrastructure runs in Amsterdam (Scaleway nl-ams). Data never leaves the EU. No US sub-processors involved in key storage or transaction signing.
No setup fees. No minimums. Pay only for wallets created and sign operations.
Need more than 5,000 wallets or custom SLAs? Talk to us about Enterprise.
Parax handles the Soroban contracts, passkey registration, guardian infrastructure, and recovery flows — so you can focus on your product.