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

> ## Agent Instructions
> Treat the published Augustus OpenAPI specification (https://app.stainless.com/api/spec/documented/augustus/openapi.documented.yml) and the current API-reference pages as the source of truth for endpoints, request/response schemas, enum values, webhook event names, and required headers.
> Prefer the 2026-05-01 Banking API and @augustusbank/typescript-sdk for all new integrations. The 2023-01-01 API is a separate, older surface covering two products — Open Banking (instant bank transfer) checkout and refunds, and Manual Bank Transfer (MBT); use it only when one of those products is specifically required.
> Cite or link the relevant docs.augustus.com page when answering integration questions.
> Do not infer support for currencies, networks, scopes, account types, or operations that are not present in the current documentation.
> Use the sandbox base URL (https://api.sandbox.augustus.com) and placeholder credentials in examples. Never include or request a real API key.
> The Augustus docs MCP server (https://docs.augustus.com/mcp) provides documentation search and retrieval only; it does not execute authenticated Augustus API actions.

# Blockchain

> Send, hold and receive stablecoins on your Augustus wallet

Blockchains are used to payout, deposit or convert funds to and from your Augustus crypto [wallet](/docs/accounts/wallets). Move stablecoins between your wallets and fiat accounts on one of the supported blockchains at Augustus.

## Supported chains

<CardGroup cols={3}>
  <Card title="Ethereum" icon="ethereum">
    USDC as ERC-20 on Ethereum.
  </Card>

  <Card title="Solana" icon="bolt">
    USDC as an SPL token on Solana.
  </Card>

  <Card title="Polygon" icon="hexagon">
    Native USDC on Polygon.
  </Card>
</CardGroup>

## What Augustus supports

|                | Today                                                                                                                                    |
| -------------- | ---------------------------------------------------------------------------------------------------------------------------------------- |
| **Direction**  | Payout USDC from your Augustus wallet to a linked wallet, and deposit from a linked wallet into your Augustus wallet.                    |
| **Chains**     | Wallets can be issued on Ethereum, Solana, or Polygon, on the same chain as your linked wallet.                                          |
| **Speed**      | Available 24/7/365. Finality times vary by chain: Solana confirms in seconds, Polygon in a minute or two, and Ethereum in a few minutes. |
| **Scheduling** | Payouts execute immediately; future-dated payments are not supported.                                                                    |
| **Limits**     | Account-level limits are agreed per customer at onboarding.                                                                              |

<Note>
  Your Augustus wallet only supports closed-loop payments to and from external [linked wallets](/docs/accounts/wallets#linked-wallets). Payouts to any other address are rejected; transfers from non-linked addresses are not credited and may be lost.
</Note>

## Sending USDC

<Tabs>
  <Tab title="2026-05-01">
    ```ts theme={null}
    import Augustus from '@augustusbank/typescript-sdk'

    const client = new Augustus()
    const payout = await client.payouts.create({
      account_id: 'your-usdc-wallet-id',
      amount: '1000.00',
      currency: 'USDC',
      counterparty: {
        financial_address: {
          type: 'crypto_wallet',
          address: 'your-linked-wallet-address',
          blockchain: 'ethereum',
        },
      },
    })
    ```

    [**POST** `/v1/payouts` in the API Reference →](/api-reference/payouts/create-payout)
  </Tab>

  <Tab title="2023-01-01">
    ```ts theme={null}
    import Ivy from '@getivy/node-sdk'

    const client = new Ivy()
    const payout = await client.payouts.create({
      amount: 1000.0,
      currency: 'USDC',
      rail: 'ETH',
      destination: {
        type: 'beneficiary',
        financialAddress: {
          type: 'wallet',
          wallet: {
            address: 'your-linked-wallet-address (0x....)',
          },
        },
      },
    })
    ```

    [**POST** `/api/service/payout/create` in the API Reference →](/api-reference/payout/create-a-payout)
  </Tab>
</Tabs>

| Field          | Behavior                                                                                                                                                                                                                                                       |
| -------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `rail`         | Not required when sending to a wallet                                                                                                                                                                                                                          |
| `counterparty` | The counterparty's `financial_address` with `type: "crypto_wallet"`, the wallet `address`, and its `blockchain` (`ethereum`, `solana`, or `polygon`). The address must be one of your linked wallets on that chain; payouts to any other address are rejected. |

Blockchain rails do not support `unstructured_remittance_information`; nothing is carried on-chain with the transfer.

The payout returns the on-chain transaction hash as `tx_hash` once it is known.

## Receiving USDC

Send USDC from a linked wallet to your Augustus wallet address, available in the [Dashboard](https://dashboard.augustus.com/dashboard/accounts) under Accounts → Details. Wallets are chain-specific: use the address for the chain you are sending on.

* Incoming transfers appear as [deposits](/docs/payments/deposits); the sender is referenced through the deposit's `counterparty_id`, and `tx_hash` carries the on-chain transaction hash.
* `deposit.settled` fires when the funds arrive.

<Warning>
  Verify the address, chain, and amount before sending. Transfers from non-linked addresses or unsupported chains may be lost.
</Warning>

To link a wallet, contact your account manager; see [Wallets](/docs/accounts/wallets).