Cavos

Embedded wallet SDK

Embedded wallets are crypto wallets built into an application instead of a browser extension or a separate wallet app. An embedded wallet lets users sign in the way they already do, and the product resolves an on-chain account they can pay, receive, and sign with. No install, no seed phrase, no trip to another app.

This guide covers how an embedded wallet works: the SDK, the platform and infrastructure, and the solution you ship. The short developer definition is what is an embedded wallet. It is not an API reference. Method-level auth, create, sign, and recovery live in the embedded wallet API guide. Also covered: wallet as a service, non-custodial keys, payments, how they compare to a browser extension, providers, and pricing. Native adapters ship for Starknet, Solana, and Stellar. To install, follow how to add an embedded wallet or the Next.js App Router guide. The shopping list is best embedded wallet. Account model versus in-app UX is embedded wallet vs smart wallet.

Embedded wallets in November 2026

Embedded wallets are in-app crypto wallets. The user signs in the way they already do. An embedded wallet SDK looks up or creates an on-chain account. Approval happens in the product UI. There is no extension to install and no seed phrase to copy. That is the whole category.

Cavos ships that SDK as @cavos/kit 0.5.2: hardware-isolated, non-custodial, free up to 1,000 wallets, setup in minutes on Starknet, Solana, and Stellar. Keys never leave the device in plaintext. Signing always happens on the device. Recovery is a passkey or an opt-in Nitro Enclave sealed copy of the MasterDEK. Essential is $59/month. Complete is $139/month. Gas Sponsorship in Any Token is on every plan and funded separately.

What is an embedded wallet?

A wallet, here, is an on-chain account plus the means to authorize transactions from it. For years that meant a browser extension or a dedicated wallet app: the user installs software, writes down twelve words, switches networks, and approves every call in a window the product does not control.

An embedded wallet SDK inverts that. The wallet is a component of the product. Authentication selects which user this is. The SDK looks up or creates an on-chain address for that identity. A signer bound to the session or the device authorizes transactions from inside the app UI. Gas is often sponsored so the user does not need a native token to start.

An embedded wallet has three properties. The app provisions it at sign-in. Approval happens in the product UI, not in a popup from another program. The address is a real on-chain account, not a balance in the app's database. The developer primer is what is an embedded wallet. A browser extension is a different install and approval model. Embedded wallet vs smart wallet is a different split: smart usually means a contract account, which can be embedded or not.

Teams adopt this model when the audience is not crypto-native. Games, commerce, and consumer finance cannot ask a first-time user to understand seed phrases. The tradeoff is that the application now owns the wallet experience, including recovery, device changes, and how honest it is about who can sign. The commercial name for the same job is wallet as a service, or embedded wallet as a service.

When to use an embedded wallet

Use an embedded wallet when most users have never installed a crypto wallet, when sign-up should look like any other app, or when payments and on-chain actions are a feature of the product rather than the reason users came. Keep a browser extension connection if users already arrive with one.

Use Cavos when the product is Starknet, Solana, or Stellar and the review requires a device-native key. Signing stays on the device. Recovery is a passkey or an opt-in Nitro Enclave sealed copy of the MasterDEK. Cavos cannot see the key, sign with it, or move funds. The free tier covers the first 1,000 wallets. Setup is minutes with @cavos/kit 0.5.2. It is the worse fit when you need broad EVM coverage or must connect MetaMask. The shopping list is best embedded wallet. The named-vendor table is embedded wallet providers.

Embedded wallet SDK

An embedded wallet SDK is the library that provisions the wallet and signs from inside your application. It is not a wallet app or a browser extension. The user never installs a second program. Authentication selects the user. The SDK looks up or creates an on-chain address. A signer bound to the device authorizes transactions from inside the app UI.

A wallet app or extension keeps keys in software the user manages. The dapp requests access; it does not create the account. An embedded wallet SDK inverts that: login selects the user, the library resolves the account, and approval happens in the product.

Some vendors ship a finished client SDK. Some ship a REST or RPC signing layer you assemble yourself. Confirm which layer you are buying. Cavos ships a client SDK as @cavos/kit. There is no public create-wallet REST endpoint. The method-level map (auth, create, sign, gas, recovery) is the embedded wallet API guide. The SDK label still does not decide custody: ask who can produce a valid signature without the user, which chains are native, how a lost device is recovered, and whether approval happens in your UI or in someone else's.

Embedded wallet platform and infrastructure

An embedded wallet platform is the hosted infrastructure the SDK talks to: authentication, a registry that looks up or claims an address, gas sponsorship, and recovery. Embedded wallet infrastructure is the same job from the operator side. The commercial name is wallet as a service.

The platform does not decide custody. Device-native keys, MPC shares, and a provider-operated HSM can sit behind the same login modal. Cavos is device-native embedded wallet infrastructure: signing keys are created and used on the user's device. Cavos cannot see them, sign with them, or move funds. Adapters ship today for Starknet, Solana, and Stellar.

Embedded wallet solution

An embedded wallet solution is what you ship to users: they sign in, they approve in your UI, they hold a chain-native account, and they can complete a payment without installing a second program. The SDK is how you embed that. The platform is how you run it.

Choose a solution on the custody question, the native chain question, and the recovery question. Worked comparisons live on the compare pages. To install, follow how to add an embedded wallet.

How an embedded wallet works

The product owns the wallet path. Four steps cover sign-in, key creation, signing, and recovery in this model.

  1. Sign in. The user authenticates with an identity the product already owns: hosted login including email, or an identity you pass in from your own auth. Authentication selects which user this is. It does not, by itself, authorize a spend.
  2. Key creation. The wallet’s account key is derived on the user’s device from a MasterDEK that stays protected at rest by the platform’s non-extractable key: WebCrypto in the browser (React Native is a work in progress). Cavos cannot see the key, sign with it, or move funds.
  3. Signing. The device signs. Approval happens in the product UI, not in a browser-extension popup. Gas is often sponsored so the user does not need a native token to start.
  4. Recovery. A new device restores the wallet’s MasterDEK, not by reconstituting a master key on a server. Restore paths are another signed-in device, a passkey, and opt-in hardware-isolated recovery in an AWS Nitro Enclave (off by default).

Embedded wallet vs browser extension

Browser-extension wallets keep keys in a separate application. The user installs it, controls the seed, and approves transactions in that UI. The dapp requests access; it does not provision the account. That is the right default when users already have wallets, hold assets across many apps, or must connect an existing address. It is a poor default when the user has never used crypto: another download, another permission prompt, and another place the session can break.

QuestionBrowser extensionEmbedded wallet
Who creates the accountThe user, in another applicationThe product, from a login the user already has
Where approval happensA wallet popup the app does not controlIn the product UI
PortabilityHigh: the same wallet across many sitesProduct-scoped unless you also connect or export
Typical audiencePeople who already hold crypto walletsPeople who should never see a wallet picker

Cavos does not connect existing extensions. If connecting MetaMask or WalletConnect is a requirement, a connection-focused provider is the better fit, and the two models can coexist in one product. That split is spelled out on the Cavos vs Dynamic page. For signing UX, key custody, recovery, gas, and how to migrate an extension-first product, read embedded wallet vs browser extension.

Embedded wallet vs smart wallet

Embedded says where the wallet appears. Smart wallet usually means a smart-account or account-abstraction wallet: a contract that can enforce policy, batch calls, or sponsor gas. Those are not opposites. An embedded wallet can be a smart account. A browser extension can be a smart account too.

Cavos on Starknet is both: an in-app wallet whose on-chain account is an audited OpenZeppelin account contract (AccountUpgradeable v3.0.0). Cavos on Solana and Stellar is embedded and native, not a contract wallet. Account abstraction does not decide custody. A paymaster or relayer is not a signer.

The full split, including ERC-4337 and when to pick a contract account, is embedded wallet vs smart wallet. The shopping-list version of best embedded wallet is how to choose.

Embedded vs hosted, MPC, and custodial wallets

“Embedded” only says where the wallet appears. It does not say who can move the funds. The same login modal is used for three different custody designs.

Hosted or delegated

The provider, or an HSM it operates, can produce a signature. Email magic-link login often sits on this model: access to the inbox is enough to spend, because the provider holds the signing capability. FinCEN describes hosted wallet providers as account-based money transmitters when they have total independent control over the value.

MPC

The private key is split into shares. Signing reconstructs or jointly computes a signature from those shares, typically some mix of the user’s device, the provider’s network, and a recovery factor. MPC is a legitimate design. It is not the same as “the provider never has a key.” The provider holds a share used in reconstruction. Export is often supported, which is a feature and a different threat model.

Self-custodial, device-native

The signing key is created on the user’s device and does not leave it. The provider cannot see it, cannot sign with it, and cannot move funds. A new device restores the MasterDEK off-chain with a passkey or the Nitro enclave; there is no on-chain device list.

Calling a product non-custodial does not make it so. The test is whether the provider can complete a transaction without the user, or holds the means of access. That is the test the custody page cites under MiCA, FinCEN, California, and other regimes. The developer checklist is the non-custodial embedded wallet guide.

Key-management models

When a vendor says “embedded wallet SDK,” ask where the signing key lives. Four designs cover almost every product in the category.

SDK key modelWho can signTypical vendors
Device-nativeThe signing key is created and used on the user device. The provider cannot see it, sign with it, or move funds.Cavos
MPCThe private key is split into shares. Signing uses some mix of the user device, the provider network, and a recovery factor.Web3Auth / MetaMask Embedded Wallets, Dynamic, Para
Remote TEEKey material decrypts inside a measured enclave. Who can authorize that enclave decides custody.Turnkey, Privy user wallets
HostedThe provider, or an HSM it operates, can produce a signature. Access to the login is often enough to spend.Custodial wallet products; some optional paths at finished SDKs

Device-native keys

The wallet's account key is derived on the device from a MasterDEK, which the platform's secure store keeps protected at rest: WebCrypto in the browser (React Native is a work in progress). The device signs, and a new device restores the same MasterDEK instead of being added on-chain. This is the Cavos default. Those platform primitives provide the isolation: WebCrypto cannot hold a stark key, so outside the Cavos vault the Starknet key is re-derived into memory for the session, and the SDK does not enforce non-extractability on Node or other server runtimes.

Passkeys

Passkeys (WebAuthn) are often described as “the wallet.” They are not one thing. On Starknet, Solana, and Stellar in Cavos, a WebAuthn PRF credential encrypts a copy of the wallet's MasterDEK, which Cavos stores and cannot open. That is not 2FA: anyone with the synced passkey (iCloud Keychain or Google Password Manager) can spend, which is also how a synced passkey recovers the wallet on a new device. When a vendor says “passkey wallet,” ask whether the passkey signs spends, approves devices, or unwraps a key the vendor also holds.

MPC

Shares are distributed so that no single party should reconstruct the key alone. In practice you are trusting the share holders, the reconstruction protocol, and whoever can coerce enough shares. Web3Auth is the well-known social-login implementation of this pattern. Broad chain coverage and key export are the usual reasons to pick it. The cost is a reconstructable key and a provider share in the signing path. Cavos does not split or reconstruct a signing key with MPC.

Enclaves

A secure enclave (AWS Nitro, or a vendor HSM) holds key material that is supposed to be usable only inside a measured environment. Turnkey sits here as infrastructure: you build a wallet on top of policy-driven signing in remote hardware. Remote enclaves are not the user's device. Server-side signing is the point of that design. Cavos uses an enclave only for opt-in hardware-isolated social recovery: an AWS Nitro Enclave with pinned attestation, off by default, which can only unwrap a wallet's MasterDEK on Starknet, Solana, and Stellar. It is not general server-side signing. The docs call that path non-custodial, and not trustless.

Custody and regulatory implications

If your company can move a user's crypto, you are holding it. The EU, US money-transmission rules, California, and the UK from 25 October 2027 put a price on that. Argentina writes exclusive self-custody wallet providers out of its registry; Brazil, Costa Rica, Mexico, and the UK never wrote that exception. Figures, statutes, and the control test live on the custody page. This guide does not repeat them.

Two product facts still belong here. Integrating a self-custodial SDK does not mean the rest of the product is unlicensed. Exchange, fiat on-ramps, and sending crypto for a customer are classified on their own. Recovery paths count: a provider that cannot sign in the ordinary flow but can restore a spend key in an incident is a different fact pattern than one that never can. Counsel has to read the recovery path, not only the happy path.

Chain considerations

“One embedded wallet, every chain” usually means an EOA-style key reused across networks, or an account-abstraction layer on EVM. Chains that are not EVM do not share that account model. If you are building on Starknet, Solana, or Stellar, the adapter has to be native: address derivation, signatures, execution, and fees stay explicit per chain.

Starknet

Each wallet is an audited OpenZeppelin account contract (AccountUpgradeable v3.0.0) controlled by one stark key derived from the MasterDEK and app salt. There is no on-chain device list. Execution is paymaster-sponsored (SNIP-29); the account deploys lazily on first execute. Signatures are SNIP-12.

Embedded Starknet wallet

How to send gasless Starknet transactions

Solana

Cavos provisions a native Ed25519 system account whose spend key is derived from the user's MasterDEK. A relayer co-signs as fee payer so users hold no SOL to start. Arbitrary program calls (SPL, swaps) go through allowlisted programs.

Embedded Solana wallet

A typed wallet object from one SDK is not the same as pretending every chain is Ethereum. Cavos currently ships those three adapters. It is not an EVM-wide wallet layer; if your product is EVM-first, Privy covers ground Cavos does not.

Embedded wallet payments

Embedded wallet payments are pay, receive, and sign from inside the application. The user does not install an extension, paste a seed, or approve in someone else's popup. Authentication selects which user this is. The SDK resolves an on-chain account. A signer bound to the device authorizes the spend in your UI.

The remaining wall is the native gas token. An embedded wallet that still asks the user to hold ETH, STRK, SOL, or XLM before the first payment has not removed the wallet. Gas Sponsorship in Any Token takes that wall down: the product can sponsor fees, or settle them in a token the user already holds. USDC is one example of such a token, not a required asset. The embedded wallet payments guide is the chain-by-chain walkthrough: Stellar trustlines, Solana SPL, and Starknet execute.

Gas Sponsorship in Any Token

An embedded wallet that still asks the user to hold ETH, STRK, SOL, or XLM before the first tap has not removed the wallet. The native gas token is the remaining onboarding wall. Gas Sponsorship in Any Token takes that wall down: the product can sponsor fees so the user transacts from a login, and can settle those fees in a token they already hold. USDC is one example of such a token, not a required asset.

The mechanism is chain-native, not a universal gas tank. On Starknet, execute routes through a paymaster, so deployment and later calls do not need ETH or STRK. The gasless Starknet transactions guide is that path. On Solana, the relayer is the fee payer, or the fee settles in a token the account holds. On Stellar, the relayer is the transaction source and fee payer: it sponsors reserves and fee-bumps, so the user locks no XLM to start.

Sponsorship is available on every plan and funded separately. Integrators set spend limits in the dashboard. Pricing publishes the free 1,000 wallet creates, Essential at $59/mo, and Complete at $139/mo.

How to integrate an embedded wallet

Setup is minutes: install @cavos/kit, create an app for an App ID, wrap the tree or call Cavos.connect, sign the user in, then execute. The free tier covers the first 1,000 wallets. The product path is sign-in, wallet resolve, sign and send, then recovery. The step-by-step integration guide walks a React app through @cavos/kit. The numbered steps below are that same contract, with the kit docs for each stage.

  1. Sign in. Authenticate the user with Cavos hosted login (Google, Apple, or email) or pass a stable userId from your own auth. Login selects which user this is. It never signs a transaction. Authentication docs.
  2. Resolve the wallet. Call Cavos.connect or mount CavosProvider. The kit looks up (userId, appId, chain) in the registry and returns the existing address, or claims a new one. Connect never deploys Starknet or Stellar. Quickstart.
  3. Sign and send. Narrow on wallet.chain, then execute. Undeployed and ready wallets can send. On Starknet the first execute deploys and runs atomically; on Stellar, create() creates the sponsored account first. needs-device-approval means this device has no key yet and must restore the MasterDEK. Wallet actions.
  4. Set up recovery. Add a second authority before it is needed: a passkey or opt-in hardware-isolated social recovery. None of those paths can be arranged after every device is gone. Recovery docs.

How to choose a provider

Ask the custody question first, then the chain question, then the product-shape question.

  1. Who can produce a valid signature without the user present?
  2. Where does the signing key live: device, MPC shares, HSM, or enclave?
  3. Which chains are native, and which are a compatibility layer?
  4. How does a second device get authorized?
  5. What does recovery actually do, and is it on by default?
  6. Do you need to connect existing wallets, or provision new ones?

Worked comparisons (including when the other product is the better choice) are on the compare pages: Privy, Dynamic, Turnkey, Web3Auth, and Magic.

Embedded wallet provider comparison

Cavos, Privy, Dynamic, Turnkey, Web3Auth / MetaMask Embedded Wallets, Magic, and Para all ship an embedded wallet. They do not share a key model, the same native chain coverage, or the same pricing. Each name opens the full comparison except Cavos, which links to published fees, and Para, which has no Cavos vs Para compare page.

ProviderPricing and free tierChainsKey model
CavosFree up to 1,000 wallets. Essential $59/mo. Complete $139/mo.Starknet, Solana, and Stellar.Device-native. One stark key from MasterDEK and app salt. No MPC. Starknet uses an audited OpenZeppelin AccountUpgradeable v3.0.0.
PrivyFree (0–499 MAU) with 50K signatures and $1M volume/mo. Core $299/mo. Scale $499/mo.Managed send on EVM, Solana, Tempo, and Tron. Sign-only on Stellar, Starknet, Bitcoin, and others: Privy signs, your app broadcasts. Per Privy’s chain-support docs, November 2026.User wallets: 2-of-2 Shamir shares reconstituted only in AWS Nitro Enclaves (enclave share + auth share). Key export is supported. Optional custodial wallets via Bridge.
Dynamic$249/mo for up to 5,000 MAUs. Then $0.05 per extra MAU. Sandbox is free.Multi-chain, with EVM breadth and additional non-EVM support; parity varies by chain.Embedded wallet keys managed by the provider’s key infrastructure with configurable custody models.
TurnkeyPay as you go: 1,000 wallets and 25 free signatures/mo, then $0.10/signature. Pro $99/mo.Broad cryptographic curve and chain support at the signing primitive level.In hardware-backed secure enclaves operated as infrastructure.
Web3Auth / MetaMask Embedded WalletsFree 1,000 monthly active wallets. Growth $69/mo. Scale $399/mo.Broad multi-chain coverage.MPC / threshold shares combined to reconstruct a private key.
MagicFree 1,000 monthly active wallets and 50K signatures. $99/mo includes 2,500 MAWs.EVM-focused with additional chain support.Delegated key management backed by hardware security modules operated by the provider.
Alchemy Account KitFree 30M compute units/mo. PAYG $0.525 per million CUs. Gas Manager: 8% admin fee on PAYG; free on testnets.Many EVM networks plus Solana. Bundler, ERC-20 gas payments, and Bundler Sponsored Operations are documented for those EVM networks, not for Solana.Bring-your-own signer. Wallet APIs leave login and keys to Privy (recommended), Turnkey, Openfort, or a viem-compatible signer.
PollarPay as you go with credits, no subscriptions, per pollar.xyz (checked November 2026).Stellar and Solana.Three custody types in Pollar’s integration guide: internal (social and email users; keys managed server-side, the server signs), smart (Soroban C-address signed by a device passkey), and external (a wallet the user already has). Pollar skill on GitHub, commit 761ed60, November 2026.
BluxNo public price list on blux.cc (checked November 2026).Stellar.Blux’s wallet verification API returns wallet_type: custodial for Blux-provisioned accounts and external for a wallet the user connects. Blux docs, November 2026.
ParaFree to 1,200 MAUs. Starter $200/mo (2,500 MAUs). Growth $500/mo (10,000). Scale $1,000/mo (25,000). Public pricing page does not charge per signature.Named table: EVM, Solana, Cosmos chains (Noble, Initia, Osmosis), and Stellar. No Starknet native adapter.2-of-2 MPC. User share on the device. Para share in cloud HSMs.

Cavos fees are from this site. Other fees are from each vendor's public pricing page as of October 2026 and can change. The category has consolidated. Stripe acquired Privy in 2025. Fireblocks acquired Dynamic in 2025. Consensys acquired Web3Auth in 2025 and now ships it as MetaMask Embedded Wallets. In 2026 Payward, the parent of Kraken, acquired Magic Labs wallet infrastructure.

Teams replacing a named vendor can start with Privy alternatives, Turnkey alternatives (turnkey alternative, Turnkey embedded wallet competitors) , Dynamic alternatives, Magic alternatives, or Para alternatives. One-to-one write-ups live on the compare pages. The longer listicle (pricing, chains, and key models for the same vendors) is Best Embedded Wallet Providers 2026: Compared.

Embedded wallet pricing

Cavos prices on wallet creates, not monthly active users or signatures. The full SDK, including Gas Sponsorship in Any Token, is on every plan. Paid plans add unlimited creates and recovery options. Published fees live on pricing.

Free

Free up to 1,000 wallets. The first 1,000 wallet creates are included. Sponsorship is funded separately.

Essential

Essential $59/month. Unlimited wallet creates and on-device recovery.

Complete

Complete $139/month. Unlimited wallet creates plus opt-in hardware-isolated enclave recovery.

Where Cavos fits

Cavos is device-native embedded wallet infrastructure. Applications resolve a self-custodial account from a stable user identity. Signing keys are created and used on the user's device. Keys never leave the device in plaintext. Signing always happens on the device. Cavos cannot see them, sign with them, or move funds. Adapters ship today for Starknet, Solana, and Stellar, via @cavos/kit 0.5.2 on web and @cavos/kit/react-native on mobile, a work in progress (Expo Development Builds, EAS, or bare React Native; Expo Go is not supported).

Cavos is not an EVM-wide wallet layer, not a WalletConnect aggregator, and not a drop-in replacement for Privy. It is the better fit when you need those three chains' native account models and a signing architecture with no provider-held reconstructable key. It is the worse fit when you need broad EVM coverage, external wallet connection, or server-side signing as a product feature. The backend is built so it cannot spend user funds or add itself as a signer. Registries, recovery, paymasters, and relayers can coordinate a transaction; they cannot authorize one.

The free tier covers the first 1,000 wallet creates. Pricing and the Complete plan's enclave recovery are documented there. The security write-up is in the concepts and hardware-isolated recovery docs. To add the wallet to a React app, follow the step-by-step integration guide.

Related guides

The pillar is the category. These pages are the platform, the API, self-custody, payments, the install, and the comparisons.

Frequently asked

What is an embedded wallet?

An embedded wallet is a crypto wallet that lives inside an application instead of in a browser extension or a separate wallet app. The user signs in with an identity the product already owns, and the app resolves an on-chain account they can pay, receive, and sign with, without installing software or handling a seed phrase. Where the wallet appears is not who can sign.

What are embedded wallets?

Embedded wallets are in-app crypto wallets. The plural names the category: wallets provisioned inside products so users never install an extension or copy a seed phrase. An embedded wallet SDK is the library that does that job. Cavos ships that SDK as @cavos/kit 0.5.2, hardware-isolated and non-custodial, free up to 1,000 wallets on Starknet, Solana, and Stellar.

How is an embedded wallet different from a browser extension?

An extension wallet keeps keys in a separate application the user installs and manages. An embedded wallet is provisioned by the product: login selects the user, the SDK looks up or creates an on-chain account, and approval happens in the app UI. Extensions are the better fit when users already hold wallets you must connect to.

What is an embedded wallet SDK?

An embedded wallet SDK is the library that provisions the wallet and signs from inside your application. It is not a wallet app or a browser extension the user installs. Authentication selects the user; the SDK looks up or creates an on-chain account; a signer bound to the session or the device authorizes transactions in your UI. Cavos ships that as @cavos/kit on web and @cavos/kit/react-native on mobile (a work in progress).

What is an embedded wallet as a service?

Embedded wallet as a service, also called wallet-as-a-service, is the commercial name for provisioning a crypto wallet through an SDK instead of asking the user to install an extension. Login selects the user, the platform looks up or creates an on-chain account, and approval happens in the product UI. The label does not decide who can sign.

What is an embedded wallet platform?

An embedded wallet platform is the hosted infrastructure behind the SDK: authentication, registry lookup or create, gas sponsorship, and recovery. Embedded wallet infrastructure is the same job from the operator side. The commercial name is wallet-as-a-service. The label does not decide who can sign. Cavos is device-native embedded wallet infrastructure for Starknet, Solana, and Stellar.

What is an embedded wallet solution?

An embedded wallet solution is the product you ship: login, an in-app approval UI, a chain-native account, and a fee path the user can complete. The SDK and the platform are how you build that. Cavos ships the SDK as @cavos/kit. Compare solutions on custody, native chains, and recovery, not on the login modal.

What are embedded wallet providers?

Embedded wallet providers are vendors that ship an in-app wallet through an API or SDK. Cavos, Privy, Dynamic, Turnkey, Web3Auth, and Magic all do this, with different key models, native chains, and pricing. Compare them on the Cavos compare pages, or start with Privy alternatives if you are replacing that stack.

What is a non-custodial embedded wallet?

A non-custodial embedded wallet is one the provider cannot spend from. The wallet still lives inside the application, but the signing key is created and used on the user’s device and is not reconstructed from provider-held shares. Calling a product non-custodial does not make it so. The test is who can move the assets.

Which chains does Cavos support for embedded wallets?

Cavos currently ships native adapters for Starknet, Solana, and Stellar. It is not an EVM-wide wallet layer. Each adapter uses that chain’s account model, signatures, and fee path. Cavos, LLC is a software and SaaS company; the wallet is the main product.

How do I add an embedded wallet to a React app?

Install @cavos/kit, create an app in the Cavos dashboard for an App ID, wrap the tree in CavosProvider, sign the user in, then execute. Connect never deploys Starknet or Stellar. On Starknet the first execute deploys and runs atomically; on Stellar, create() creates the sponsored account. The step-by-step integration guide on this site walks through that path.

How should I choose an embedded wallet SDK?

Ask who can produce a valid signature without the user, where the key lives, which chains are native rather than compatibility layers, how a second device is authorized, and what recovery actually does. Then match that to the product: provision new accounts, or connect existing ones. Worked comparisons live on the Cavos compare pages.

What are embedded wallet payments?

Embedded wallet payments are pay, receive, and sign from inside the app: the user does not open an extension or paste a seed. Gas Sponsorship in Any Token removes the native-token wall so the product can sponsor fees, or settle them in a token the user already holds. USDC is one example of such a token, not a required asset.

How long does it take to add an embedded wallet SDK?

Setup is minutes, not a week: npm install @cavos/kit, create an app in the dashboard for an App ID, wrap the tree in CavosProvider or call Cavos.connect, sign the user in, then execute. Connect never deploys Starknet or Stellar. On Starknet the first execute deploys and runs atomically; on Stellar, create() creates the sponsored account. The free tier covers the first 1,000 wallets.

What is the difference between an embedded wallet and a smart wallet?

They answer different questions. Embedded says where the wallet appears: inside the app, provisioned at login. Smart wallet usually means a smart-account or account-abstraction wallet, a contract that can enforce policy, batch calls, or sponsor gas. An embedded wallet can be a smart account. Cavos on Starknet is an audited OpenZeppelin account contract. Cavos on Solana and Stellar uses native system accounts, not contract wallets. A browser extension can also be a smart account.

What is the best embedded wallet?

There is no single best embedded wallet. Choose on chain, custody, and whether you provision new accounts or connect existing ones. Cavos is the closer fit when the product is Starknet, Solana, or Stellar and the review requires a device-native key. If the product is EVM-first or must connect MetaMask, Privy or Dynamic cover ground Cavos does not. The dated vendor table is the embedded wallet providers guide.

Pick a chain, then the signing model.

Follow the step-by-step integration guide, or compare Cavos with the provider you already have on a shortlist.

We use anonymous analytics to understand how developers use Cavos. No personal data is collected. Privacy Policy