JavaScript SDK

Vanilla JS / framework-agnostic integration.

• JavaScript SDK Overview — A headless, framework-agnostic SDK for authentication, wallets, and signing. You build the UI — Dynamic handles everything else.
• User and Session Management

Authentication Methods

• Adding Captcha Protection
• Cookie-based authentication — Configure the JavaScript SDK to use cookie-based authentication with a custom API base URL.
• Device Registration — Verify new devices and manage trusted devices for your users.
• Authenticate with Email
• Authenticate with an external JWT — Sign users into Dynamic with a JWT issued by your own authentication provider.
• Authenticate with External Wallets
• Authentication screens
• Check Recovery Codes Acknowledgment
• Check MFA Authentication Status
• Check User Scopes
• MFA Enrollment
• Action-Based MFA
• MFA Device Management — How to delete user MFA devices and perform admin resets.
• MFA Overview
• Passkeys
• Recovery Codes
• Session-Based MFA
• Authenticator Apps
• Authenticate with Passkey
• Refresh Authentication
• Refresh User Data
• Authenticate with SMS
• Social Account Linking — Link and unlink social accounts (Google, Apple, Twitter, etc.) on an authenticated user.
• Authenticate with Social
• External Auth Step-Up — Request elevated access tokens using your own backend's signed JWTs — no user interaction required.
• Step-Up Authentication — Headless step-up authentication using the JavaScript SDK — check, verify, and the SDK handles the rest.

Building UI

• Account conflict resolution — Handle the case where a user tries to add a credential — an email, phone, social account, or wallet — that already belongs to a different account.
• Account merging — Complete an account merge when a user adds a credential that belongs to a mergeable second account — including resolving field-level conflicts.
• Handling blocked wallets — Detect a wallet rejected by compliance screening and show a clear access-denied experience.
• Building for Flow (deposits & payments) — Build a deposit/payment UI with Fireblocks Flow — load a flow, attach a source, quote, sign, and track it to settlement.
• Connected wallets management — Show a user's connected wallets, let them choose which one to act on, and remove wallets they no longer want.
• Connecting external wallets — Let users connect a browser-extension or mobile wallet — list the available providers, connect, and verify ownership.
• Device registration — Approve a new device when it's required at sign-in, complete the approval redirect, and manage a user's registered devices.
• Email & SMS OTP sign-in — Build a one-time-passcode sign-in UI: send a code to an email or phone, then verify it to authenticate the user.
• Embedded wallet delegated access — Let your app sign for a user's embedded wallet without prompting each time — and let users revoke it.
• Embedded wallet password & security — Protect embedded wallets with a user password — set it during setup, unlock on a new device, and let users change it.
• Building an exchange transfer UI — Let users withdraw crypto from a connected Kraken or Coinbase account to an external wallet, including Coinbase's two-step verification and Travel Rule steps.
• Funding flows — Let users buy crypto with fiat by generating a hosted on-ramp URL for their wallet.
• Upgrading legacy embedded wallets to Dynamic WaaS — Detect users whose embedded wallets need upgrading and move them onto Dynamic WaaS with the ready-made upgrade app — by redirect, embed, or popup — using the legacy-embedded-wallet-upgrade package.
• Embed the upgrade app (iframe) — Render the Dynamic upgrade app inline in an iframe within your own sheet or modal, reacting to its origin-checked completion message.
• Going lower-level (build the URL yourself) — Build the upgrade app URL and own the mounting and completion handling yourself with buildUpgradeUrl and subscribeToUpgradeCompletion — the escape hatch behind the redirect, embed, and popup routes.
• Upgrade by popup — Open the Dynamic upgrade app in a popup window (web) or the system auth session (React Native) without navigating away, using openUpgradePopup.
• Upgrade by redirect — Navigate the user to the Dynamic upgrade app and read the outcome when they return, using detectUpgradeRedirect and completeUpgradeRedirect.
• MFA enrollment & management — Enroll an authenticator app (TOTP), verify it, show recovery codes, and let users manage their MFA devices.
• Network switching & validation — Show the active network, let users switch, and make sure a wallet is on the right network before you transact.
• Building UI Overview — Guides for building complete, real-world UI flows with the headless JavaScript SDK — you own the interface, the SDK does the work.
• Passkey sign-in & registration — Let returning users sign in with Face ID, a fingerprint, or a security key, and manage their registered passkeys.
• Post-login user setup — Get a freshly signed-in user ready for your app — collect required fields, enroll MFA, register their device, and create an embedded wallet.
• Social sign-in & OAuth redirect handling — Start a social login and complete the OAuth redirect so users land back in your app authenticated.
• Step-up authentication — Require fresh authentication before a sensitive action — signing, exporting a key, or updating a profile — scoped to what the action needs.
• Building a swap UI — Quote a token swap, show the estimate, execute it from the user's wallet, and track it to completion.
• Token balances & display — Show a wallet's native balance and its token holdings — with prices, market values, and spam filtering.
• Transaction confirmation & simulation — Simulate a transaction, show the user what it will do (assets, fees, security), send it, and wait for confirmation.
• User profile & settings — Display the signed-in user, edit profile fields, verify email or phone changes, and delete the account.
• Wallet backup & recovery — Show backup status, back an embedded wallet up to Google Drive, and export the private key as a last-resort escape hatch.

External Auth

• Using your own authentication provider
• Configuring your authentication provider
• Integrating your authentication provider with Dynamic

Funding

• addCoinbaseOnrampOrderEventListener
• createCoinbaseExchangeTransfer
• createCoinbaseOnrampOrder
• createCryptoDotComPayment
• createKrakenExchangeTransfer
• getCoinbaseAccounts
• getCoinbaseBuyUrl
• getKrakenAccounts
• getKrakenWhitelistedAddresses
• getMissingVerificationForCoinbaseOnrampOrder
• getMoonPayCurrencies
• getMoonPayUrl
• Kraken Integration — Transfer crypto from Kraken exchange accounts to external wallets

Migrating From React

• Account conflict resolution — The React SDK rendered the account-exists and merge screens for you. In the JavaScript SDK you catch the conflict errors and build the resolution UI yourself.
• Basic setup — Migrate provider setup, context access, and the event model from the React SDK to the JavaScript SDK.
• Cookies — Cookie-based sessions work the same way in the JavaScript SDK, but you enable them by passing apiBaseUrl in createDynamicClient()'s coreConfig instead of a provider prop, and you read the session from the user rather than a JWT.
• Embedded wallets: backup & recovery — The React SDK drove keyshare backup and private-key export from its widget screens. In the JavaScript SDK you run the readiness check, the Google Drive backup, and the secure export yourself.
• Embedded wallets: delegated access — The React SDK managed delegated signing through its hooks and widget. In the JavaScript SDK you check, grant, and revoke delegated access with explicit functions and hooks.
• Embedded wallets: password & security — The React SDK popped a password modal for you on the first wallet action. In the JavaScript SDK you check whether a password is needed and run the set, unlock, and change flows yourself.
• Embedded wallets: setup & creation — The React SDK auto-created embedded wallets during its login flow. In the JavaScript SDK you decide when to create them and for which chains — the full build lives in the Building UI post-login guide.
• Embedded wallets: transactions & session keys — The React SDK signed and sent from embedded wallets through the widget, and had dedicated session-key approval screens. In the JavaScript SDK signing uses the same functions as any wallet, and scoped session keys move to delegated access.
• Funding — The React SDK opened funding, on-ramp, and exchange screens from hooks like useFundWithWallet and useOnramp. In the JavaScript SDK each funding path is a function (and hook), and you build the menu that routes between them.
• Gas sponsorship & smart wallets — The React SDK exposed smart accounts through useSmartWallets and configured gas sponsorship behind the widget. In the JavaScript SDK smart wallets come from the ZeroDev extension and gas sponsorship is a set of EVM functions you call.
• Global wallets — Global wallets — embedded wallets that connect across multiple apps — are a React SDK feature. The JavaScript SDK does not support them yet.
• Integrating chains — The React SDK enabled chains by passing a walletConnectors array to the provider. In the JavaScript SDK you enable each chain by calling its add<Chain>Extension() once when you set up the client.
• Multi-factor authentication — The React SDK exposed MFA through a single useMfa hook and drove enrollment screens in the widget. In the JavaScript SDK each MFA operation is its own function and hook.
• Network management — The React SDK rendered the network picker and the 'switch in your wallet' modal for you. In the JavaScript SDK you read the network data and drive switching yourself.
• Non-wallet authentication — Migrate email, SMS, social, passkey, and external-JWT sign-in from the React SDK to the JavaScript SDK.
• Migrating from React to the JavaScript SDK — What changes when you move from the React SDK (@dynamic-labs/sdk-react-core) to the headless JavaScript SDK, and where to find the implementation for each flow.
• Post-login user setup — SyncAuthFlow is gone — migrate the automatic post-login orchestration (onboarding, MFA, device registration, wallet creation) to an explicit chain you own.
• Step-up authentication — The React SDK could pop step-up UI inside the widget. In the JavaScript SDK you run the same scope-based check yourself and pass requestedScopes on the verify call.
• Transactions & balance — The React SDK gave you balance hooks and a built-in transaction confirmation modal. In the JavaScript SDK you read balances and drive the review-and-send flow yourself.
• Upgrading embedded wallets — The React SDK ran the wallet upgrade inside its widget. In the JavaScript SDK you detect who needs upgrading and route them to the ready-made upgrade app with the legacy-embedded-wallet-upgrade package.
• Users — The React SDK exposed the user through useDynamicContext() and rendered the profile, settings, and delete screens inside DynamicUserProfile. In the JavaScript SDK you read the user with useUser() and build those screens yourself.
• Using connected wallets — The React SDK managed the wallet list, wallet selection, and connection prompts for you. In the JavaScript SDK you read the wallet accounts with functions and build the management UI yourself.
• Wagmi integration — The React SDK offered a wagmi connector. A wagmi integration for the JavaScript SDK is coming; until then, use the EVM extension directly.
• Wallet authentication — Migrate external wallet discovery, connection, and verification from the React SDK to the JavaScript SDK.

React Native

• Setup on Bare React Native — Install and configure the JavaScript SDK in a bare React Native app.
• Setup on Expo — Install and configure the JavaScript SDK in an Expo React Native app.
• React Native Passkeys — Configure native passkey support for the JavaScript SDK on Expo and bare React Native — associated domains, asset links, and client setup.
• React Native Setup — Run the headless JavaScript SDK in a React Native app — Expo or bare React Native.

Reference

• Adding Extensions — Add chain wallet and addon support to your Dynamic client with extensions
• Adding Aptos Extensions — Add Aptos blockchain support to your Dynamic client
• Checking Aptos Wallet Account Type
• getAptosClient
• signAndSubmitTransaction (Aptos)
• signTransaction (Aptos)
• Adding Bitcoin Extensions — Add Bitcoin blockchain support to your Dynamic client
• Checking Bitcoin Wallet Account Type
• Embedded Wallet Differences — How Bitcoin functions behave differently with embedded wallets
• sendBitcoin
• sendRawTransaction
• signMessageWithCustomOptions
• signPsbt
• signPsbts
• Add Wallets to a Business Account — Create a fresh business-account wallet, or bring an existing embedded wallet under the account.
• Create a Business Account — Create a business account, then list and read back its details.
• Manage Signers — Grant and revoke the ability to sign with a business-account wallet.
• Members & Roles — Administer who can manage a business account, and transfer ownership.
• Business Accounts — Share embedded wallets across a team, with separate control over who manages the account and who can sign.
• Policies — Apply account-wide, wallet, and signer policy rules to business-account wallets using the JavaScript SDK policy helpers.
• Quorum policies — Require multiple approvals for wallet and business-account actions with quorum policies.
• Signing with a Business-Account Wallet — Sign transactions and messages with a wallet owned by a business account.
• Step-Up Authentication — Obtain the elevated token required before calling sensitive business account operations.
• attachFlowSource
• broadcastFlow
• canConnectWithHardwareWallet — Check if a wallet provider supports a given hardware wallet vendor
• cancelFlow
• Creating a Dynamic Client — The first step in using the JavaScript SDK is to create a Dynamic Client
• Delete User Account — Permanently delete the current user's account.
• Distinguishing Login Methods — Determine how the user authenticated by inspecting their verified credentials.
• Events Catalog — Full reference of events emitted by the Dynamic JavaScript client, including payload shapes.
• executeSwapTransaction
• getFlowQuote
• getFlow
• getSwapQuote
• getSwapStatus
• Initializing the Dynamic Client
• isHardwareWalletAccount — Check if a wallet account was connected via a hardware wallet
• JWT Scopes & Access Lists — Read access list / gate scopes from the user's JWT to gate parts of your app.
• offEvent
• onEvent
• prepareFlowSigning
• submitFlowTransaction
• Creating Extensions — Build a custom extension that adds wallet providers or other runtime services to the Dynamic JavaScript SDK.
• Custom Functions — Write standalone functions that use DynamicClient services and follow the Dynamic JavaScript SDK conventions.
• Publish an Extension — Package and publish a Dynamic JavaScript SDK extension so other developers can install and use it.
• Open deep links — Open cross-platform deep links from a Dynamic JavaScript SDK extension.
• Storage — Use regular and secure Storage from DynamicCore in your JavaScript SDK extension.
• Wallet provider priority — Understand WalletProviderPriority levels and registry replacement in the Dynamic JavaScript SDK.
• Add swap capabilities — Implement executeSwapTransaction on a custom WalletProvider to enable Fireblocks Flow and Swaps.
• Build a payment deep link — Build a custom extension that turns a Fireblocks Flow deposit into a deep link or QR code for a mobile wallet app.
• Build a WalletProvider — Implement and register a custom WalletProvider with the Dynamic JavaScript SDK.
• Wallet Provider — Integrate a custom wallet with the Dynamic JavaScript SDK through a WalletProvider.
• Supported wallet standards — Wallet standards the Dynamic JavaScript SDK already supports.
• Adding EVM Extensions — Add one or more EVM extensions to support embedded wallets and external wallets on EVM chains
• calculateEvmTransactionFee — Estimate the gas fee for an EVM transaction
• Checking EVM Wallet Account Type
• EIP-5792 (Batched Calls) — Use wallet_getCapabilities and wallet_sendCalls to batch and sponsor EVM transactions.
• EVM Gas Sponsorship — Sponsor EVM transaction fees for your users with Dynamic's built-in gas sponsorship feature.
• Getting a Viem PublicClient
• Getting a Viem WalletClient
• Managing EIP-7702 delegation — Check, sign, and activate the one-time EIP-7702 delegation that powers gas-sponsored EVM transactions.
• sendSponsoredTransaction — Send a gas-sponsored EVM transaction and wait for it to land on-chain.
• Sign a Transaction — Sign an EVM transaction without broadcasting it to the network.
• Sign Typed Data (EIP-712) — Sign EIP-712 typed data with an EVM wallet account using a Viem WalletClient.
• simulateEvmTransaction — Preview an EVM transaction's effects before sending it
• Splitting sign & send — Pre-sign a sponsored intent, relay it, and poll relay status for custom transaction flows.
• Validate Signatures — Verify EIP-191, EIP-712, ERC-1271, and EIP-6492 signatures produced by Dynamic wallets.
• Flow: Getting Started — Set up the Dynamic client for Fireblocks Flow — enable chains, add extensions, and create your first flow.
• Flow: Building a Payment UI — Build a multi-chain payment widget with Fireblocks Flow — wallet connection, token selection, quoting, signing, and status tracking.
• Network Transformers — Customize the network list before it's used throughout the SDK
• JavaScript Quickstart
• React Hooks Catalog — Complete reference for all hooks exported by @dynamic-labs-sdk/react-hooks, organized by category.
• How React Hooks Work — The rules behind @dynamic-labs-sdk/react-hooks — how client functions map to hooks, which functions get one, and the three shapes a hook can take.
• React Hooks — Reactive bindings for the Dynamic JavaScript SDK — useUser, useGetWalletAccounts, useOnEvent, and more.
• React Native Quickstart (JS SDK)
• React Quickstart (JS SDK)
• Adding Solana Extensions — To interact with the Solana wallets, you need to add the appropriate extensions
• calculateSolanaTransactionFee — Estimate the fee for a Solana transaction
• Checking Solana Wallet Account Type
• Solana Connection
• isSolanaGasSponsorshipEnabled — Check if SVM gas sponsorship is enabled for your project.
• addPhantomRedirectSolanaExtension — Enable Phantom wallet support via deep link redirect on mobile
• Signing and Sending Transactions with Solana
• simulateSolanaTransaction — Preview a Solana transaction's effects before sending it
• SVM Gas Sponsorship — Sponsor Solana transaction fees for your users with Dynamic's built-in gas sponsorship feature.
• Adding Starknet Extension — Add Starknet blockchain support to your Dynamic client
• Checking Starknet Wallet Account Type
• getStarknetAccount
• Adding Stellar Extension — Add Stellar blockchain support to your Dynamic client
• Checking Stellar Wallet Account Type
• signTransaction (Stellar)
• Adding Sui Extensions — Add Sui blockchain support to your Dynamic client
• Checking Sui Wallet Account Type
• getSuiClient
• signAndExecuteTransactionBlock (Sui)
• signAndExecuteTransaction (Sui)
• signTransactionBlock (Sui)
• signTransaction (Sui)
• Algorand — Derive Algorand addresses and sign transactions using Dynamic embedded wallets
• Aptos — Derive Aptos addresses and sign transactions using Dynamic embedded wallets
• Cardano — Derive Cardano addresses and sign transactions using Dynamic embedded wallets
• Cosmos — Derive Cosmos SDK chain addresses and sign transactions using Dynamic embedded wallets
• Mavryk — Derive Mavryk addresses and sign transactions using Dynamic embedded wallets
• NEAR — Derive NEAR addresses and sign transactions using Dynamic embedded wallets
• Using chains with Tier 2 and 3 support — Technical Overview — Embedded wallets via raw signing with helper methods and EOA support
• XRP (Ripple) — Derive XRP addresses and sign transactions using Dynamic embedded wallets
• Tron — Derive Tron addresses and sign transactions using Dynamic embedded wallets
• Adding TON Extensions — Add TON blockchain support to your Dynamic client
• Checking TON Wallet Account Type
• generateTonConnectProof
• sendJetton
• sendTon
• sendTransaction (TON)
• Adding Tron Extensions — Add Tron blockchain support to your Dynamic client
• Checking Tron Wallet Account Type
• getTronWeb
• sendTransaction (Tron)
• Checking if Dynamic WaaS is enabled
• Checking WaaS Wallet Account Type
• Creating WaaS Wallet Accounts
• Exporting WaaS Private Key
• getGoogleDriveBackupReadiness — Pre-flight readiness check for backing up MPC key shares to Google Drive
• Importing WaaS Private Key
• Migrate from Fireblocks
• Password encryption — Add password protection to embedded wallets for enhanced security
• Adding a network
• Build a Wallet Picker — Render every wallet a user can connect to — installed, URI-based (deeplink + QR), in-app browser, and install-only — from a single SDK call.
• Checking Wallet Account Availability
• Connecting and Verifying a Wallet
• Getting Active Network
• Getting Available Wallets to Connect
• Get Balances for All Wallets — Use getMultichainTokenBalances to fetch token holdings across every connected wallet in a single API call.
• Getting Connected Addresses
• Getting Multichain Token Balances
• Getting Native Balance
• Getting Networks Data
• Getting Token Balances — Retrieve token balances for a wallet account on one chain (one or more networks).
• Getting Transaction History
• Getting the Wallet Account Given an Address and Chain
• Getting Wallet Accounts
• Get Wallet Options Catalogue — Get every wallet a user can sign in with — installed providers, WalletConnect, MetaMask SDK URI, in-app browsers, and install links — in a single ordered list.
• Hardware Wallet Support — Connect and verify Ledger hardware wallets via supported software wallets
• List WalletConnect Wallets — Use getWalletConnectCatalog to render a simple list of WalletConnect wallets with their names, icons, and deep link URLs.
• MetaMask Connection Guide — Handle MetaMask connections across desktop (extension), desktop (QR code), and mobile (deeplink) using the JavaScript SDK.
• Removing a Wallet Account
• Signing a Message
• Switching Active Network
• Wallet Provider Events
• Authenticate with WalletConnect — Connect mobile wallets to your dapp - add extension, get wallet list, connect (QR or deep link), handle prompts
• Adding ZeroDev Extension — Add ZeroDev account abstraction support to your Dynamic client
• calculateFeeForUserOperation — Calculate the fee for a ZeroDev user operation from known gas values
• canSponsorUserOperation
• createKernelClientForWalletAccount
• estimateUserOperationGas
• ZeroDev Gas Sponsorship Quickstart — Set up gasless EVM transactions with ZeroDev (ERC-4337) so your app pays gas for users
• getSignerForSmartWalletAccount
• isGasSponsorshipError
• Migration Guide - v0.9.0 — Guide for migrating from transaction-based APIs to UserOperation APIs
• sendUserOperation
• signEip7702Authorization
• simulateZerodevUserOperation — Preview a ZeroDev user operation's effects before sending it

Wallets

• Developer Actions — Use the delegated materials to act on behalf of the user.
• Delegation Flow — What happens when a user approves delegation and how to handle the webhook.
• Revoking Delegation — How to revoke delegation using the JavaScript SDK.
• Triggering Delegation — How to trigger delegation for a user using the JavaScript SDK.
• Google Drive backup setup — Configure Google Drive as a backup option for embedded wallet recovery.