S
Opening Swivy console
Checking your secure session.
WORKSPACE / Overview
Testnet previewDocumentation โ†—
Your workspace

Workspace overview

Everything you need to build, test, and manage your app.

Developer console
Start with a project. Connect your app. Keep control.
LETโ€™S GET YOU BUILDING

Your app. Your users.
One place to start.

Create your first project to connect authentication, wallets, and your backend.

Choose your networks and login methods during setup.
Quick project setupCreate a project or adjust your starting configuration
Simple onboarding

Create or open a project

Name your app, choose its wallets, and select how customers sign in.

1Signed in

This dashboard session is active. App users sign in separately through your product or the hosted test flow.

Operator
Signed-in team account
2Project and wallets
3Customer auth

Your workspace

Explore the tools for your app
Sign in or load an environment to see project, user, wallet, custody, auth, and signer status.
Integration checklistFrom your first project to your first user

Your integration path

Swivy has two surfaces: this dashboard for your team, and the API/SDK your app calls for your users. Follow these three steps before touching the advanced controls.

1 Create your app
Creates the organization, project, environment, App ID, publishable key, and backend secret.
2 Choose wallet rules
Enable EVM and/or Solana, decide custody behavior, allowed origins, and gas sponsorship.
3 Test as a user
Sign in with an email code, create wallets, inspect users, and confirm wallets are attached.

What you copy into your app

Once setup is complete, use the Integrations section as your handoff checklist.

  • Frontend
    App ID and publishable key for Swivy Web SDK login and embedded wallet creation.
  • Backend
    Secret key for server-side API calls, webhooks, and controlled admin operations.
  • Users and wallets
    The Users page shows user email, identity ID, linked wallets, managed wallets, and custody status.
App-side shape createSwivyClient({ appId, publishableKey })
Exact values appear after setup under Integrations.

Overview

Total users 0
Loaded from this app environment.
Total wallets 0
EVM, Solana, linked, and managed accounts.

Recommended next steps

1
Create or load your app environment
This is the thing your product integrates with. It gives your app public browser credentials and a private server credential.
2
Pick chains, wallets, and auth rules
Decide what users can create and sign with: EVM, Solana, passkeys, session rules, and gas policy.
3
Copy SDK snippets into your app
Use Integrations for the browser SDK, Node SDK, OIDC callback, API URL, App ID, publishable key, and secret key.
1 Create app
Create or load the Swivy environment that will issue wallet sessions for your app.
2 Enable chains
Apply the self-custody policy and configure safe EVM plus Solana RPC targets.
3 Test wallets
Sign in like a user, create EVM and Solana wallets, enroll passkey step-up, and sign locally.
4 Deploy app
Copy the publishable key, app ID, secret key, and SDK snippets into your app.
First-time setup uses the guided flow Fastest path
Start with one app setup action, then move to Integrations and Test user flow after the environment is created.

What this setup gives you

Use the generated credentials in your own frontend and backend. Your app users sign in through your UI, then Swivy creates and manages their wallets under this environment.

You are signed in to the console.
Your team manages the organization. App users are separate; they appear under Users after they sign into your app or the hosted test flow.
Setup checklist
  • 1
    Click Create my app. Keep the default development names unless you already know your production naming.
  • 2
    Open Integrations and copy the frontend and backend snippets into your app.
  • 3
    Open Test user flow, sign in as a test user, create wallets, then confirm that user and wallet appear in Users.
Create or load an environment to get the exact setup completion checklist, SDK keys, and app handoff links.
1
Create a new app
Use the default development names if you just want a working app quickly. This creates the organization, project, environment, keys, policy, and testnet RPC routes in one pass.
Already have an app or need manual setup?
2
Load an existing app environment
Use this when the environment already exists and you want to open its dashboard, SDK keys, and integration bundle.
3
Manual creation steps
Only use this if you need to create the organization, project, or environment separately instead of using the one-click setup.

Commerce setup

Create a Swivy organization, project, environment, owner invite, and Commerce settings for a new Commerce deployment.

Sign in, then create the Commerce tenant.
Commerce readiness not checked Save Commerce settings, then refresh signer status before funding or settlement.
Edit Commerce settings
Ready means decrypt/export passed, the active signer wallet equals the expected service wallet, and AAD/fingerprints are recorded without exposing keys.

Step 2: Choose Wallet Features

Turn on the chains and runtime features your app should expose, then save them to the environment.

Wallet feature controls

Saving toggles updates the environment policy and applies testnet RPC routes for the enabled chains. The JSON below stays visible as the advanced view of the same settings.
Sponsor walletMissing
Configure SWIVY_GAS_SPONSORS_JSON for each sponsored network.
Network--
Saved from the sponsored network allowlist.
BalanceUnknown
Live balance checks require deployment-level sponsor wallet config.
Remaining transactionsUnknown
Estimated after balance telemetry is connected.
Save sponsorship policy changes.
These controls write to the environment policy. Client-side sponsorship stays disabled by default.

Webhooks registered for this environment

Load an environment to inspect whether this deployment is using log, HTTP, or SMTP code delivery.

Recommended: HTTP provider

Use this when you have an email service webhook, worker, or transactional email endpoint. Render stores the token as a secret env var.

SMTP provider

Use this for SendGrid, Postmark, Resend SMTP, Mailgun, or any hosted SMTP mailbox provider.

Where to set this on Render
  • 1
    Open Render, choose swivy-api, then open Environment.
  • 2
    Set either the HTTP env vars or the SMTP env vars below, then keep SWIVY_LOG_CODES=false.
  • 3
    Redeploy swivy-api, refresh this page, and request a new email code.
Feature status
Saved in offlineSigningPolicy.enabled. When off, SDKs reject offline envelope creation.
Transport status
Bluetooth mesh is treated as untrusted. Request envelopes should be signed with a pairing key and checked before signing.
Replay status
Signer clients cache signed request IDs and reject repeated packets before key reconstruction.
Native adapter package
Install @swivy/expo-bluetooth-mesh in the mobile app to provide the Bluetooth scan, advertise, permission, and packet-send layer.
App install command
npm install @swivy/expo @swivy/expo-bluetooth-mesh react-native-ble-plx
App wiring
import { createSwivyBluetoothMeshAdapter } from "@swivy/expo-bluetooth-mesh"; const swivy = await SwivyExpoClient.create({ ...config, bluetoothMeshAdapter: createSwivyBluetoothMeshAdapter() }); await swivy.startBluetoothMeshOfflineSigning({ onEnvelope });
This toggle controls the Swivy feature surface. Online coordinators still need to prepare fresh nonce, fee, and blockhash data, and relays still need internet access to broadcast the signed payload.
Swivy RPC Infra is the primary provider.
The staging gateway is live at https://rpc-fabric-gateway-swivy-staging.onrender.com. It fronts an Alchemy-backed mixed model for EVM and Solana networks, while third-party providers remain selectable below when a customer needs direct routing or fallback coverage.
Status
Swivy RPC Infra First-party
Default data plane for chain reads, simulations, sends, wallet tools, and hosted environment routes.
Alchemy-backed routing
The hosted gateway can use Alchemy upstreams without exposing customer API keys in browser or dashboard fields.
Third-party fallbacks
Enable fallback providers for direct Alchemy, QuickNode, Helius, or custom endpoints when needed.
Provide Network Family Chain ID RPC URL override
ethereum-mainnet evm
base-mainnet evm
arbitrum-mainnet evm
optimism-mainnet evm
polygon-mainnet evm
base-sepolia evm
ethereum-sepolia evm
tempo-testnet evm
solana-mainnet solana
solana-devnet solana
Use Swivy RPC Infra's /api/provider/v1/projects/:projectId/descriptor or /api/control-plane/projects/:projectId/swivy-export as the source for live URLs. Secret values stay in deploy env vars; this policy stores only secret names.
API keys are stored as deploy secrets. Put secret names in policy only when needed; do not paste provider keys into this console field set.
API key management
  • 1
    Rotate keypair creates a publishable key for your frontend and a secret key for your backend.
  • 2
    The secret is shown once in Admin Output and the Integration Bundle, then the credential ID is used for revoke/rotation.
  • 3
    Use Revoke keypair when a key is leaked or an app environment should stop accepting that key.

Advanced policy JSON

Use swop-self-custody for the current Swop posture: email bootstrap, passkey step-up, split_custody wallets, no SMS, and no sponsorship. Use the toggles for normal operation, and edit JSON only when you need an advanced policy value.
Advanced tenant and organization controls

Organization Access

Manage enterprise operators, org-scoped admin keys, and invite flows from the same environment context.

Load an environment or enter an organization ID to inspect org access state.

Organization Context

Use the row actions below to prefill member, invite, and admin-key controls before making changes.

Organization Projects

Browse projects and environments without manually chasing IDs through separate API calls.

Load an organization to explore its projects and environments.

Project Stats

Select a project to prefill environment creation, or open an environment to refresh the full admin dashboard.

Projects and Environments

Organization Members

Organization Invites

Organization Admin Keys

Environment Snapshot

Step 4: Deploy Handoff

Once the Test Wallets checklist is green, copy these into your app and deploy your own frontend/backend.

Frontend
Use the App ID and publishable key with the browser SDK to sign users in and create embedded wallets.
Backend
Use the secret key server-side for controlled environment operations, webhooks, and agent session grants.
Chains
Keep EVM and Solana RPC targets configured before moving from testnets to production networks.
Embedded wallets
Use the Web SDK with your App ID and publishable key to create EVM and Solana wallets.
LI.FI swaps Enabled
Runtime users and agents can request EVM or cross-chain swap quotes at /v1/runtime/tools/lifi/quote. Swivy checks walletToolPolicy token allowlists, max value, max slippage, and the normal execution approval path.
Jupiter swaps Enabled
Solana wallets can request Jupiter quotes and optional serialized swap transactions at /v1/runtime/tools/jupiter/quote. Mint allowlists, value caps, slippage caps, and MFA are enforced before execution.
Hyperliquid perps Planned
Perps need market allowlists, leverage caps, daily loss limits, and expiring agent delegation before Swivy should let a deployed wallet trade them.
Polymarket orders Policy-gated
Toggle Polymarket under Policies to expose /v1/runtime/tools/polymarket market discovery and CLOB V2 order previews. The Node SDK signs and submits orders through Swivy EVM wallet intents.
Get started
Boot the stack, create an environment, issue keys, test email login, and submit a first transaction intent.
SDK quickstarts
Copy the integration path that matches your app: React, Expo, Node, or the agent CLI.
Authentication
Email login, runtime sessions, passkeys, SMS/TOTP MFA, and OIDC exchange flows.
Users
Model customer identities, linked wallets, managed wallets, session grants, and support review paths.
Wallets
Embedded EVM and Solana wallets, split custody, local signing, transaction intents, and wallet tools.
Deployment
Self-hosting, staging readiness, production hardening, credentials, and cutover runbooks.
Customer dashboard mental model
  • 1
    API keys are where a developer copies browser and server credentials for their app.
  • 2
    Users is where they inspect their app users, emails, linked wallets, managed wallets, and recent intents.
  • 3
    Wallets is where they test the same embedded wallet flow their app will run.
Swivy operator mental model
  • 1
    Developer dashboard is the public customer surface. It should never expose break-glass credentials.
  • 2
    Internal admin is a separate console surface for support, customer org inspection, platform health, and emergency scoped access.
  • 3
    Render deploys the API and console as separate URLs. Customers use the console URL; apps call the API URL.
1. Get credentials
Open Keys, issue an environment keypair, then copy the App ID plus publishable key into your frontend and the secret key into your backend.
2. Install SDKs
Use @swivy/web in browser apps and @swivy/node in backend jobs, API routes, and agents.
npm install @swivy/web@1.0.1 @swivy/node@1.0.1
3. Verify users
After the first login, open Users to confirm the app user email, external user ID, embedded wallets, linked wallets, and recent intents.
Public URLs
  • 1
    Console URL: give this to customer developers so they can create keys, inspect users, read docs, and test wallets.
  • 2
    API URL: use this in SDK config and backend requests. Current proxied API is http://swivy-api:3000.
  • 3
    Docs URL: share /docs for the OpenAPI-backed reference and this tab for the shortest integration checklist.
What your app users get
  • 1
    Email-code login creates a Swivy identity in this environment.
  • 2
    Wallet bootstrap can auto-create EVM and Solana embedded wallets under that identity.
  • 3
    The dashboard user directory shows email, external user ID, managed wallets, linked wallets, custody mode, sessions, and intents.

Recommended reading order

  • 1
    Get started to boot the stack, create an app, and prove email login plus wallet bootstrap.
  • 2
    SDK quickstarts to wire the React, Expo, Node, or CLI surface that matches your app.
  • 3
    Authentication and Wallets before implementing passkey approvals or signing flows.
  • 4
    Deployment and Migration before staging rollout or a Privy replacement cutover.

Key docs topics

The structured docs now cover:
Email login Passkeys Users Embedded wallets Split custody Session grants OIDC Self-hosting Production cutover

Frontend quickstart

Load or create an environment, then use the Web SDK snippet below this page.

Backend quickstart

Issue an API key, then use the Node SDK snippet below this page.
Keep this docs page practical.
This is the first-stop developer surface inside the console. Deep OpenAPI detail lives in the hosted API reference, while advanced policy and org controls stay in Settings.

Quickstart Env Vars

Create or rotate an environment keypair to reveal the full publishable and secret keys.

Web SDK Snippet

Load an environment to generate a browser integration snippet.

Node SDK Snippet

Load an environment to generate a backend integration snippet.

Launch Readiness

Computed from the loaded environment policy, chain routes, runtime keys, webhook state, OIDC clients, and signer trust.

Load an environment to inspect launch readiness.
Load an environment to inspect signer and custody posture.

OIDC / Sign in with Swop

Create issuer clients on this environment so another app can use Swop as its login provider and then exchange that identity into its own runtime session.

Use none for public PKCE clients. Confidential server-side clients should use one of the client-secret methods.

OIDC Integration

Load an environment to generate issuer discovery, JWKS, and exchange URLs.
Load an environment to generate a relying-party integration snippet.
The tester drives the proxied /oidc/* flow end to end. If this client uses a secret, keep the latest client secret available before starting the popup test.
No hosted OIDC auth test run yet.

Session Grants

Active users 0
Users with environment activity, including sessions, wallets, linked wallets, or intents.
Total users 0
Customer identities, wallets, and sessions from this app environment.

Credentials

Open API keys to manage environment credentials.

Chain Targets

Open Policies to manage chain routes.

Recent Intents

Webhooks

Open Webhooks to manage event endpoints.

OIDC Clients

Activity

Recent user, wallet, session, and control-plane events for this project.

Audit Log

Admin Output

Ready.

Step 3: Test the Wallet Flow

Use this as the acceptance pass before deploying: sign in as a user, create both embedded wallets, add a passkey, then prove the browser can sign with the local share.

How to prove this works inside your app
  • 1
    Copy the App ID and publishable key from Integrations into your frontend.
  • 2
    Run the same sequence here that your app will run: request email code, verify user, create EVM wallet, create Solana wallet.
  • 3
    Refresh the admin dashboard. The user and both wallets should appear under Users, proving Swivy issued real runtime wallet records for the app.
Local email codes are written to the API logs. Run docker compose -f compose.dev.yaml logs api | rg "Issued verification code", then paste the six-digit code into Email Login.

3A: App Config

These are the publishable credentials your frontend will use. The local setup wizard fills them automatically.

The current hosted UI uses email bootstrap plus runtime session APIs, matching the app-side integration path in Swop. If you used the local test setup, these credentials are already filled.
Save or load app credentials, then load signup readiness.

Passkey enrollment

After a test user signs in, enroll a passkey here to prove Swivy can gate wallet signing and self-custody unlocks with WebAuthn.

No passkey enrollment started.

Sign in a test user

Ready for wallet testing Sign in with the email-code flow first, then create an EVM or Solana wallet. This panel will show the result immediately.
Total assets โ€”
Live balances are not available in this preview.
Total wallets 0
Managed accounts visible in the current runtime session.
Custody mode --
Default mode used when creating wallets below.
Use personal + split_custody for browser-held self-custody. Use agent + managed_tee for terminal, backend, and agentic flows. Swivy can keep both wallet types on the same chain.
Sign in to see embedded wallets.

Signing keys

Server signing keys are managed through API keys in local development. User passkeys, TOTP, and SMS factors appear below after sign-in.
Sign in to enroll passkeys, TOTP, and SMS factors.

3E: Prepare Self-Custody

For a Privy-style browser wallet, create it from the wallet composer above with split_custody. Prepare self-custody will select or create the browser wallet, make sure a passkey exists, and open a wallet_reconstruction unlock. This panel also lets you migrate a signer-backed wallet into legacy split-custody metadata or reconstruct a local export using the saved device share plus the server share.
No split-custody update submitted.

Optional: Backend Session Grant

This generates an Ed25519 session key in the browser, registers the public key with Swivy, and returns the private key PEM once so you can hand it to a backend agent using @swivy/node.
No delegated session grant created.

TOTP Enrollment

No TOTP enrollment started.

SMS Enrollment

No SMS enrollment started.

Passkey Enrollment

Open User authentication to enable and enroll passkeys for the signed-in test user.

Approval Challenge

No challenge created.

Signing

If no valid wallet_reconstruction unlock is active, the local-sign buttons will now prepare self-custody automatically and continue with the signature.

Execute Transaction

Hosted Output

Ready.