> ## Documentation Index
> Fetch the complete documentation index at: https://turnkey-0e7c1f5b-traian-remove-eip-712-note.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# Overview

export const SolutionCard = ({title, description, icon, href}) => {
  return <a href={href} className="not-prose font-normal group ring-0 ring-transparent cursor-pointer block rounded-lg border border-zinc-950/10 dark:border-white/10 bg-white dark:bg-transparent p-5 no-underline hover:border-primary/40 transition-colors">
      <div style={{
    display: 'flex',
    alignItems: 'flex-start',
    gap: '16px'
  }}>
        <img src={`/images/solutions/light/${icon}.svg`} className="tk-card-icon-img block dark:hidden" alt="" />
        <img src={`/images/solutions/dark/${icon}.svg`} className="tk-card-icon-img hidden dark:block" alt="" />
        <div>
          <div className="font-semibold text-sm text-zinc-950 dark:text-white group-hover:text-primary transition-colors">
            {title}
          </div>
          <div className="text-sm text-zinc-500 dark:text-zinc-400 mt-1">
            {description}
          </div>
        </div>
      </div>
    </a>;
};

## What are embedded wallets?

An embedded wallet is a crypto wallet built directly into your application. Instead of asking users to install a browser extension or manage seed phrases, your app handles wallet creation, authentication, and signing behind the scenes. **Users interact with your product; the wallet is infrastructure they never have to think about.**

## Why Turnkey for embedded wallets?

Building embedded wallets from scratch means solving key management, multi-chain signing, authentication, custody models, and policy controls, all without exposing private keys. Turnkey handles this infrastructure so you can focus on your product.

With Turnkey, you can:

* Authenticate users via email, phone number, biometrics, social logins, or passkeys
* Create and manage wallets across multiple chains
* Configure custodial, non-custodial, or hybrid custody models
* Control signing permissions with a programmable policy engine
* Sponsor gas so users never need native tokens
* Leverage pre-built UI components or build fully custom experiences
* Import and export keys to support user sovereignty

## How it works

User authentication flows into a signed request to Turnkey. Inside the secure enclave, the
[policy engine](/features/policies/overview) evaluates the request; key derivation and signing
follow, and only the signature is returned. Your app can then broadcast the transaction through
another provider or with
[Turnkey Transaction Management](/features/transaction-management).

<Frame>
  <img
    src="https://mintcdn.com/turnkey-0e7c1f5b-traian-remove-eip-712-note/30U7DjYzyHmQU4Bm/assets/files/embedded-consumer-wallet.png?fit=max&auto=format&n=30U7DjYzyHmQU4Bm&q=85&s=e0ac4cb42540d0860c10f1eb8e164460"
    alt="Embedded Wallets architecture: user/service, wallets, policy engine, authenticators,
secure enclave infrastructure"
    width="3738"
    height="1734"
    data-path="assets/files/embedded-consumer-wallet.png"
  />
</Frame>

### Custody models

We recommend creating a Turnkey [sub-organization](/features/sub-organizations) for each end user. This gives every user a fully isolated environment with their own wallets, credentials, and policies.

Private keys in Turnkey never leave the [secure enclave](/security/secure-enclaves). Custody is determined by who holds the credentials that can authorize the enclave to sign.

* **Non-custodial:** The user is the sole party with signing authority. Only their authenticator (passkey, email, biometric) can authorize the enclave to produce a signature. Users can [export their keys](/features/wallets/export-wallets) to access assets independently of your application.
* **Custodial:** Your application holds signing authority (via API key) and can authorize transactions without per-action user approval. Common for automated workflows like trading or subscription payments.
* **Hybrid:** Both the user and your application hold credentials, but [policies](/features/policies/quickstart) define what each party can authorize. For example, the user controls asset transfers while your app handles gas sponsorship or scheduled operations.

Turnkey supports all three models. The custody configuration is up to your application and can be tailored to match your product's requirements.

### Security model

* **Keys never leave the enclave.** Private keys live in [Trusted Execution Environments (TEEs)](/security/secure-enclaves). All derivation and signing happen inside verifiable infrastructure; only signatures are returned.
* **Authenticator-bound requests.** Every sensitive operation is signed by a user-held authenticator (passkey, email, etc.). The enclave verifies the signature before performing the operation. See [Authentication Overview](/features/authentication/overview).
* **Scoped, programmable control.** Choose non-custodial, hybrid, or app-controlled custody. [Policies](/features/policies/quickstart) and sub-organization isolation limit who can sign what.
* **Trusted vs. untrusted separation.** Verification and execution run only inside secure enclaves. A breach of your app or backend does not expose keys or signing capability.

For a deeper look, see [Security](/security/our-approach) and [Secure Enclaves](/security/secure-enclaves).

## Building with Turnkey

For React applications, the **[Embedded Wallet Kit (EWK)](/solutions/embedded-wallets/integration-guide/react/index)** is the recommended starting point. It provides pre-built auth and wallet UI components, a hook-based API, and requires no backend. It is the most opinionated path, designed to get you to a working embedded wallet with minimal configuration.

Turnkey also provides SDKs for [React Native](/solutions/embedded-wallets/integration-guide/react-native/overview), [Swift](/solutions/embedded-wallets/integration-guide/swift/overview), [Kotlin](/solutions/embedded-wallets/integration-guide/kotlin/overview), and [Flutter](/solutions/embedded-wallets/integration-guide/flutter/index). For fully custom implementations, you can call the Turnkey API directly.

See the [Integration Guide](/solutions/embedded-wallets/integration-guide/overview) to start building, or the [SDK Reference](/sdks/introduction) for detailed method documentation.

## Use cases

Embedded wallets serve different needs depending on who holds the wallet and how it's operated. Choose the pattern that matches what you're building.

<div style={{display: 'grid', gridTemplateColumns: 'repeat(2, 1fr)', gap: '12px'}}>
  <SolutionCard title="Consumer Wallet" icon="embedded-consumer-wallets" href="/solutions/embedded-wallets/embedded-consumer-wallet" description="One wallet per end user. Users authenticate with passkeys, email, or social login. No seed phrases or browser extensions." />

  <SolutionCard title="Business Wallet" icon="embedded-business-wallets" href="/solutions/embedded-wallets/embedded-business-wallets" description="Shared wallets with role-based signing controls for teams, operators, and finance workflows." />

  <SolutionCard title="Wallet-as-a-Service" icon="embedded-wallet-as-a-service" href="/solutions/embedded-wallets/embedded-waas" description="White-labeled wallet infrastructure for platforms that resell embedded wallets to their own customers." />
</div>

## Ready to build?

* [Quickstart](/solutions/embedded-wallets/quickstart) -- explore the live demo, clone a starter app, or jump straight into building
* [Integration Guide](/solutions/embedded-wallets/integration-guide/overview) -- step-by-step guides for React, React Native, Flutter, Swift, and Kotlin
* [Documentation](/features/authentication/overview) -- dig into the underlying concepts: auth, wallets, policies, and more