> ## Documentation Index
> Fetch the complete documentation index at: https://docs.rhinestone.dev/llms.txt
> Use this file to discover all available pages before exploring further.

# Deposits

> Accept deposits from any chain into your app with Rhinestone's cross-chain deposit infrastructure.

Rhinestone Deposits is a cross-chain deposit infrastructure that lets you accept tokens from users on any supported chain and deliver them to a target chain and token automatically. You don't need to build bridging logic, manage gas across chains, or handle token swaps — the service detects deposits, bridges them via [intents](/home/concepts/intents), and notifies your app when funds arrive.

It's built for teams that need reliable deposit rails: neobanks, modern dapps, DeFi protocols, or any app that onboards users from multiple chains.

It supports a wide range of EVM chains and Solana — see [supported chains and tokens](/deposits/overview/resources/supported-chains-and-tokens).

## Funding methods

* [Onramps](/deposits/onramps/overview): accept fiat payments.
* [Crypto](/deposits/crypto/overview): connected wallets, deposit addresses, asset migrations, and withdrawals.
* [Exchanges](/deposits/exchanges/overview): connect a centralized exchange through Swapped.

## Two ways to integrate

**Start with the widget.** It ships the whole deposit UI — funding methods, chain and token selection, status screens, withdrawals, and history recovery — and it uses the same API underneath, so nothing is closed off later. Reach for the API directly when you're not building in React, or when you want a deposit flow that doesn't look like a modal.

<Tabs>
  <Tab title="Deposit Widget">
    A React modal that handles funding method, chain and token selection, and deposit execution out of the box. Also covers [fiat and exchange funding](/deposits/overview/widget/widget-configuration#funding-methods), [withdrawals](/deposits/crypto/withdraw-funds), [history and recovery](/deposits/overview/widget/history-and-recovery), and [migrating balances from other apps](/deposits/crypto/asset-migrations) (e.g. Polymarket). The same flow runs in a [native mobile app](/deposits/overview/widget/mobile-apps), presented in a sheet with your app's wallet signing.

    Run the live widget on [Try it out](/deposits/overview/try-it-out) before you install anything.

    [Get started with the Deposit Widget →](/deposits/overview/widget/quickstart)
  </Tab>

  <Tab title="Deposit API">
    A headless backend service for programmatic deposit handling. You register accounts, configure webhooks, and process deposits server-side, and you build the UI. Use it for non-React frontends, or fully custom flows.

    <Frame caption="Example of an integration into a mobile app">
      <video src="https://mintcdn.com/rhinestone/HlXVyGMPtnAkQz8V/images/deposits_api_integration.mp4?fit=max&auto=format&n=HlXVyGMPtnAkQz8V&q=85&s=a72b94759fa6d87e1a00fa91cbef45b9" muted loop controls className="rounded-2xl" style={{ maxHeight: "500px", margin: "0 auto" }} data-path="images/deposits_api_integration.mp4" />
    </Frame>

    [Get started with the Deposit API →](/deposits/headless/quickstart)
  </Tab>
</Tabs>

## Which should you use?

| | Deposit Widget | Deposit API |
| - | - | - |
| Frontend | React component, customizable, modal or inline | You build it |
| Backend | A [proxy holding your API key](/deposits/overview/widget/backend-setup) — ours or your own | Your service, holding the key |
| Deposit triggers | Any transfer to the deposit account, plus in-modal funding | Any transfer to the deposit account |
| Fiat / exchange | Card, Apple Pay, bank and CEX funding, UI included | [Endpoints](/deposits/headless/funding/create-an-onramp-checkout); you open Swapped’s hosted UI |
| Withdrawals | [Withdraw modal](/deposits/crypto/withdraw-funds); your app signs the transfer | You build it |
| Recovery | [History recovery](/deposits/overview/widget/history-and-recovery) for users; dashboard for operators | Dashboard, or build your own |
| Status | Lifecycle callbacks in the browser | [Webhooks](/deposits/headless/processing-and-tracking/webhooks) server-side |

Both need a backend, and both see the same deposits — a user who sends funds to the deposit address never touches your UI either way. Use [webhooks](/deposits/headless/processing-and-tracking/webhooks) with either integration for fulfillment that can't depend on the UI being open.

## How it works

```mermaid actions={false} theme={null}
sequenceDiagram
    participant App as Your app
    participant DS as Deposit Service
    participant Orch as Orchestrator
    participant Dest as Target chain

    App->>DS: Register account with target chain/token
    Note over App: User sends tokens on any source chain
    DS->>DS: Detect deposit via webhook listener
    DS->>Orch: Create bridging intent
    Orch->>Dest: Route and settle funds
    DS->>App: Webhook notification (bridge-complete)
```

1. You register a smart account with a target chain and token
2. The user transfers tokens to their smart account on any supported source chain
3. The deposit service detects the transfer, creates a bridging intent, and routes the funds to the target chain
4. Your app receives a webhook notification when the deposit completes

The user makes a single transfer. Everything else — bridging, swaps, gas — is handled automatically.

## Why Deposits

Deposits supports [user-owned and service-managed accounts](/deposits/headless/setup/account-registration#choose-an-account-type). User-owned accounts use session permissions for processing; the widget uses service-managed accounts that settle to your configured recipient. Stablecoin swaps settle at parity and fees can be fully sponsored. The result is a deposit rail that feels like a native single-chain transfer.

Under the hood, Rhinestone aggregates multiple bridging providers, solvers, and quoting services, routing each deposit through the best available path. If one provider is degraded or a route is unavailable, the service falls back automatically — giving you a single integration with the reliability of several.

## Key features

* **Automatic bridging** — deposits are detected and bridged to the target chain without any user interaction beyond the initial transfer
* **Multi-chain support** — accept deposits from [any supported chain](/deposits/overview/resources/supported-chains-and-tokens), EVM or Solana, with more added regularly
* **1:1 stablecoin swaps** — USDC and USDT are swapped at parity
* **Swap routing** — route between tokens as part of the deposit
* **Fee sponsorship** — cover gas, bridging, and swap fees on a per-chain basis

## User experience

From the user's perspective, depositing is a simple token transfer — send tokens to an address on any supported chain. There's no bridging UI, no gas token management, and no chain switching.

With the **widget**, the user picks how to fund — connected wallet, QR transfer, card, or an exchange — then confirms, all in one modal. Withdrawals use their own host modal; both modals expose account-scoped history and signed recovery.

With the **API**, you build the deposit integration without the Rhinestone widget. Fiat and exchange funding still open Swapped’s hosted experience; headless does not mean without a UI.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.