<!--
Sitemap:
- [Stridge — The infrastructure bridging crypto payments](/index): Crypto payment infrastructure for modern fintechs. Accept on any chain, settle through the cheapest route, and pay out in any asset — all from a single SDK.
- [API Reference](/api-reference/): Stridge REST API reference — complete endpoint documentation for deposits, payouts, Universal Deposit Addresses, settlements, and supported networks.
- [Changelog](/changelog): Release notes for Stridge SDKs and developer tools.
- [Stridge Gateway Kit](/gateway/): Drop-in deposit and withdraw flows for crypto apps. Mount a single React provider, render a dialog, and ship any-to-any payments in minutes.
- [Getting Started](/getting-started): Get started with Stridge — pick your integration shape, generate keys, and make your first call from the React Kit, the TypeScript SDK, or the REST API.
- [Supported Networks](/networks): Blockchain networks and tokens supported by the Stridge payment infrastructure — network_id (SLIP-44), EIP-155 chain IDs, and the available native and stablecoin assets per chain.
- [TypeScript SDK](/sdk/): TypeScript client for the Stridge Gateway API. Used internally by @stridge/kit and exposed for backend and server integrations that need direct API access.
- [Security](/security/): Stridge Security — how the Stridge KMS protects wallet keys and signs transactions without ever exposing private keys.
- [Universal Deposit Addresses](/uda/): Universal Deposit Addresses (UDA) — one multi-chain deposit address per user, with automatic cross-chain settlement to a fixed destination.
- [Webhooks](/webhooks/): Stridge webhooks — signed HTTP POSTs for deposits, UDA settlements, wallets, and balances. Verify HMAC, handle retries, and use the Dashboard to inspect event payloads.
- [Gateway HTTP API](/gateway/http): Raw HTTP contract for the Stridge Gateway — supported-assets catalogue, gateway/start provisioning, and per-owner status polling.
- [UDA Quickstart](/uda/quickstart): Create your first Universal Deposit Address and trace a deposit end-to-end — from the POST call, through webhooks, to a settled transaction on the destination chain.
- [Settlements](/uda/settlements): UDA settlements — lifecycle, routing scenarios, fees, and the settlement record API. Reconcile deposits with webhooks; the Dashboard shows each settlement end-to-end.
- [UDA Webhook Events](/uda/webhooks): Reference for the three webhook events UDA deposits emit — deposit.confirmed, uda.settlement.created, and uda.settlement.completed — with payloads and lifecycle guidance.
- [Get a single deposit transaction by ID](/api-reference/deposits/get-a-single-deposit-transaction-by-id): Get details of a specific deposit transaction by its unique ID
- [Get a single deposit transaction by transaction id](/api-reference/deposits/get-a-single-deposit-transaction-by-transaction-id): One row per matching tx_id; multiple same-tx transfers are separate rows. Returns the latest by on-chain time (then id). Use GET /v1/deposits with tx_id filter
- [List deposit transactions](/api-reference/deposits/list-deposit-transactions): Get a paginated list of deposit transactions for the authenticated tenant with filtering support
- [Get blockchain assets](/api-reference/networks/get-blockchain-assets): Get a list of all supported blockchain assets (tokens and native assets).
- [Get blockchain networks](/api-reference/networks/get-blockchain-networks): Get a list of all supported blockchain networks.
- [Get network list](/api-reference/networks/get-network-list): Get a public list of all networks with category grouping.
- [Get tenant network](/api-reference/networks/get-tenant-network): Get a specific network for the authenticated tenant by network ID and contract address
- [Get tenant networks](/api-reference/networks/get-tenant-networks): Get a list of networks available to the authenticated tenant with their enabled status
- [Update tenant network status](/api-reference/networks/update-tenant-network-status): Update the enabled status of a network for the authenticated tenant
- [Create payout](/api-reference/payouts/create-payout): Creates a new payout from the tenant's vault wallet to an external address
- [Create payout with USD amount](/api-reference/payouts/create-payout-with-usd-amount): Creates a new payout converting a USD amount to crypto at current rate
- [Get payout by ID](/api-reference/payouts/get-payout-by-id): Retrieves a payout by its ID
- [Get vault address by network](/api-reference/payouts/get-vault-address-by-network): Get the vault address for a specific network
- [Get vault balances](/api-reference/payouts/get-vault-balances): Get balances for all vault addresses with optional filtering
- [Get vault total value](/api-reference/payouts/get-vault-total-value): Get the total USD value across all vault assets
- [List payouts](/api-reference/payouts/list-payouts): Lists payouts for a vault with filtering and pagination
- [List vault addresses](/api-reference/payouts/list-vault-addresses): Get all vault addresses for the authenticated tenant
- [List vaults](/api-reference/payouts/list-vaults): List all vault accounts for the authenticated tenant
- [Transfer from vault to external address](/api-reference/payouts/transfer-from-vault-to-external-address): Transfer assets from the tenant's vault wallet to an external address.
- [Get a settlement](/api-reference/settlements/get-a-settlement): Fetch a single settlement by ID. A settlement is created per confirmed deposit on a UDA address and carries the lifecycle state, scenario, and routing tx ids.
- [Create a UDA address](/api-reference/uda/create-a-uda-address): Allocate a new Universal Deposit Address for the tenant. If a UDA for the (tenant, owner) pair already exists, the existing record is returned with 200 instead
- [Get a cross-chain / cross-token quote](/api-reference/uda/get-a-cross-chain-cross-token-quote): Returns an indicative quote for routing from/to given (chain, token) pair. USD fields are omitted until a price feed is wired in.
- [Get a UDA address](/api-reference/uda/get-a-uda-address): Fetch a single UDA address by ID, including its delegation status.
- [List settlements for a UDA address](/api-reference/uda/list-settlements-for-a-uda-address): List all settlements that have been created for a given UDA address, optionally paginated.
- [List UDA addresses](/api-reference/uda/list-uda-addresses): List UDA addresses belonging to the authenticated tenant. Supports filtering by owner and status and pagination via limit/offset.
- [List UDA-supported chains](/api-reference/uda/list-uda-supported-chains): Returns every chain with `uda_support=true` along with its native currency and configured token contracts. Rows are grouped by network.
- [Retire a UDA address](/api-reference/uda/retire-a-uda-address): Mark a UDA address as retired. Future deposits will no longer trigger settlements; any already-confirmed settlements continue to run to completion.
- [Update a UDA address](/api-reference/uda/update-a-uda-address): Update the destination, accepted tokens, or status of an existing UDA. Owner is immutable.
-->

# UDA Quickstart \[Go from `POST /v1/uda` to a settled transaction in under five minutes]

This page takes you from an empty project to a live, multi-chain
deposit address with webhooks wired up. Every request can be run
against the Stridge sandbox at `https://api.stridge.dev` and the
production API at `https://api.stridge.com`.

:::::steps

### Get an API key

Create an account in the
[Stridge Dashboard](https://beta.dashboard.stridge.com) and generate
an API key. Keep it server-side only — every UDA call is authorized
with the `X-API-Key` header.

### Create the UDA

Pick a stable `owner` identifier for the end user (wallet address,
internal user id, or email all work) and a `destination` where every
deposit should ultimately land.

:::code-group

```bash [cURL]
curl -X POST 'https://api.stridge.com/v1/uda' \
  -H 'X-API-Key: '"$STRIDGE_API_KEY"'' \
  -H 'Content-Type: application/json' \
  -d '{
    "accepted_tokens": ["USDC", "USDT", "ETH"],
    "destination": {
      "address": "0x8f4a2c9e1b3d7f5a6c8e0d9b2a4c6e8f0a2c4d6e",
      "asset_symbol": "USDC",
      "network_id": "9001"
    },
    "owner": "user_8a7f3c"
  }'
```

```ts [Node.js]
const res = await fetch('https://api.stridge.com/v1/uda', {
  method: 'POST',
  headers: {
    'X-API-Key': process.env.STRIDGE_API_KEY!,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    accepted_tokens: ['USDC', 'USDT', 'ETH'],
    destination: {
      address: '0x8f4a2c9e1b3d7f5a6c8e0d9b2a4c6e8f0a2c4d6e',
      asset_symbol: 'USDC',
      network_id: '9001',
    },
    owner: 'user_8a7f3c',
  }),
})

const uda = await res.json()
```

```python [Python]
import os, requests

uda = requests.post(
    'https://api.stridge.com/v1/uda',
    headers={'X-API-Key': os.environ['STRIDGE_API_KEY']},
    json={
        'accepted_tokens': ['USDC', 'USDT', 'ETH'],
        'destination': {
            'address': '0x8f4a2c9e1b3d7f5a6c8e0d9b2a4c6e8f0a2c4d6e',
            'asset_symbol': 'USDC',
            'network_id': '9001',
        },
        'owner': 'user_8a7f3c',
    },
).json()
```

```go [Go]
body, _ := json.Marshal(map[string]any{
  "accepted_tokens": []string{"USDC", "USDT", "ETH"},
  "destination": map[string]any{
    "address":      "0x8f4a2c9e1b3d7f5a6c8e0d9b2a4c6e8f0a2c4d6e",
    "asset_symbol": "USDC",
    "network_id":   "9001",
  },
  "owner": "user_8a7f3c",
})

req, _ := http.NewRequest("POST", "https://api.stridge.com/v1/uda", bytes.NewReader(body))
req.Header.Set("X-API-Key", os.Getenv("STRIDGE_API_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)
```

:::

The response contains the new `id` and a per-chain
`deposit_addresses` list. Store both — the `id` drives every
subsequent lookup, and the addresses are what you show to your user.

```json
{
  "id": "31d32b68-e455-42b7-9d39-d2904adbe1b8",
  "status": "active",
  "owner": "user_8a7f3c",
  "deposit_addresses": [
    { "eip155_id": "1",    "network_name": "ethereum", "address": "0x3204…f741" },
    { "eip155_id": "56",   "network_name": "bsc",      "address": "0x3204…f741" },
    { "eip155_id": "8453", "network_name": "base",     "address": "0x3204…f741" },
    { "eip155_id": "42161","network_name": "arbitrum", "address": "0x3204…f741" }
  ]
}
```

:::info
Calling `POST /v1/uda` with the same `owner` twice returns the
existing record — safe to retry and safe to fan out from idempotent
workers.
:::

### Display the address

Pick the chain and token the user wants to deposit in and render the
corresponding `deposit_addresses[i].address`. The same address works
for every `accepted_tokens` entry on that chain — ERC-20, native
coin, or both.

The recommended UX is a chain picker + "copy" button. Never ask the
user to pick the destination chain; that is already locked in when
the UDA was created.

### Subscribe to webhooks

In the dashboard, register a webhook subscriber with these event
types:

* `deposit.confirmed`
* `uda.settlement.created`
* `uda.settlement.completed`

Stridge signs every delivery with HMAC SHA-256; see
[Signature verification](/webhooks#signature-verification) for the
canonical check.

### Trigger a test deposit

Send any amount of any `accepted_tokens` to one of the
`deposit_addresses`. As soon as the transaction is confirmed:

1. `deposit.confirmed` fires with `to_wallet_category: "uda"`.
2. `uda.settlement.created` fires with the settlement id, source
   amount, and detected `scenario` (same-chain swap, bridge, or
   swap-and-bridge).
3. `uda.settlement.completed` fires once the destination tx has
   landed in the destination token.

See [UDA Webhook events](/uda/webhooks) for the full payload
reference.

### Look up the settlement

Any time after a deposit, fetch the canonical settlement record:

```bash
curl 'https://api.stridge.com/v1/settlements/bcc2b0c1-f75c-43b2-b1bc-c44437d775f4' \
  -H 'X-API-Key: '"$STRIDGE_API_KEY"''
```

The response includes the source deposit tx, the destination
settlement tx, the route + provider, and the total fee — useful for
reconciliation and support tooling.

:::::

## What to build next

* **Multi-user UDAs** — call `POST /v1/uda` with each user's id as
  `owner`. One UDA per user, forever.
* **Dashboard reconciliation** — poll
  [`GET /v1/uda/{id}/settlements`](/api-reference/uda/list-settlements-for-a-uda-address)
  to hydrate an internal deposit ledger.
* **Quotes before deposit** — use
  [`GET /v1/uda/quote`](/api-reference/uda/get-a-cross-chain-cross-token-quote)
  to show users an expected fee and settlement time before they
  broadcast.

## Common pitfalls

* **Hard-coded chain in the UI.** A UDA is multi-chain by design —
  always read `deposit_addresses` rather than assuming a specific
  network.
* **Treating the UDA id as the address.** The UDA `id` is a UUID; the
  actual on-chain deposit targets are inside `deposit_addresses[].address`.
* **Skipping webhook signature verification.** All deliveries are
  signed; unauthenticated payloads must be rejected.
* **Accepting tokens you haven't enabled.** `accepted_tokens` is a
  hard filter — tokens outside the list are ignored, not returned.

## Next

* [UDA Webhook events](/uda/webhooks)
* [Settlements](/uda/settlements)
* [API reference — `POST /v1/uda`](/api-reference/uda/create-a-uda-address)