> ## 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.

# On-ramp

> On-ramp fiat funds to USDC to fund your crypto operations

Convert your fiat balance into USDC and send it to a linked external wallet in two steps:

1. Create a conversion.
2. Create a payout.

## Supported currencies

* **Fiat:** EUR, GBP, USD.
* **Stablecoins:** USDC (Ethereum, Solana, Polygon), USDT (soon).

<Note>
  Minimum on-ramp amount: 10 units of source currency.
</Note>

## Fund your account first

Fund via [Deposits](/docs/payin/deposits), [Open Banking](/docs/payin/instant-bank-transfer/payment-integration), or [Manual Bank Transfer](/docs/payin/mbt/mbt).

## Steps

<Note>
  Account IDs are shown in the Dashboard under **Accounts → Details**.
</Note>

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

        const client = new Augustus()
        const balance = await client.accounts.retrieveBalance('your-eur-account-id')
        ```

        [**GET** `/v1/accounts/{id}/balance` in the API Reference →](/api-reference/accounts/retrieve-account-balance)
      </Tab>

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

        const client = new Ivy()
        const balance = await client.balance.retrieve({ currency: 'EUR' })
        ```

        [**POST** `/api/service/balance/retrieve` in the API Reference →](/api-reference/banking/retrieve-account-balance)
      </Tab>
    </Tabs>
  </Step>

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

        const client = new Augustus()
        const quote = await client.quotes.indicative.retrieve({
          source_currency: 'EUR',
          target_currency: 'USDC',
          source_amount: '100',
        })
        ```

        [**GET** `/v1/quotes/indicative` in the API Reference →](/api-reference/quotes/get-indicative-quote)
      </Tab>

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

        const client = new Ivy()
        const rate = await client.fx.retrieveRate({
          sourceCurrency: 'EUR',
          targetCurrency: 'USDC',
          sourceAmount: '100',
        })
        ```

        [**POST** `/api/service/fx/retrieve-rate` in the API Reference →](/api-reference/fx/retrieve-exchange-rate)
      </Tab>
    </Tabs>
  </Step>

  <Step title="Retrieve account IDs">
    Get `source_account_id` and `target_account_id` for the accounts you want to use from the **Accounts** tab in the Dashboard.
  </Step>

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

        const client = new Augustus()
        const conversion = await client.conversions.create({
          source_account_id: 'your-eur-account-id',
          target_account_id: 'your-usdc-account-id',
          source_amount: '100',
        })
        ```

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

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

        const client = new Ivy()
        const fx = await client.fx.execute({
          sourceAccountId: 'your-eur-account-id',
          targetAccountId: 'your-usdc-account-id',
          sourceAmount: '100',
        })
        ```

        [**POST** `/api/service/fx/execute` in the API Reference →](/api-reference/fx/execute-fx)
      </Tab>
    </Tabs>
  </Step>

  <Step title="Wait for the conversion to complete">
    Conversions are asynchronous. Poll or subscribe to webhooks.

    <Tabs>
      <Tab title="2026-05-01">
        ```ts theme={null}
        const result = await client.conversions.retrieve(conversionId)
        if (result.status !== 'completed') {
          // still pending or failed
        }
        ```

        [**GET** `/v1/conversions/{id}` in the API Reference →](/api-reference/conversions/retrieve-conversion)
      </Tab>

      <Tab title="2023-01-01">
        ```ts theme={null}
        const fx = await client.fx.retrieve({ fxId })
        if (fx.status !== 'succeeded') {
          // still initiated or failed
        }
        ```

        [**POST** `/api/service/fx/retrieve` in the API Reference →](/api-reference/fx/retrieve-fx-details)
      </Tab>
    </Tabs>
  </Step>

  <Step title="Pay out USDC to a linked external wallet">
    <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({
          source_account_id: 'your-usdc-account-id',
          amount: '100',
          currency: 'USDC',
          reference: 'On-ramp payout',
          destination: {
            type: 'crypto_wallet',
            address: 'YourSolanaWalletAddress',
            blockchain: 'solana',
          },
        })
        ```

        [**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: 100,
          currency: 'USDC',
          destination: {
            type: 'beneficiary',
            financialAddress: {
              type: 'wallet',
              wallet: { address: 'YourSolanaWalletAddress', blockchain: 'SOL' },
            },
          },
        })
        ```

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

  <Step title="Track the payout">
    Monitor in the Dashboard or via webhooks. Funds usually arrive within minutes. Finalization on Ethereum can take up to 20 minutes.
  </Step>
</Steps>