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

# Transfers

> Send funds with the Create a new transaction endpoint, from a vault account or Wallet Pool to vault accounts, one-time addresses, allowlisted wallets, exchange accounts and Fireblocks Network connections.

A transfer moves an asset from a source to one or more destinations and is the default `operation` of the [Create a new transaction](/api-reference/transactions/create-a-new-transaction) endpoint. The examples on this page assume an initialised client as described in [Choose an interface](/transactions/create-transactions#choose-an-interface) and use the testnet asset `ETH_TEST5` (Ethereum Sepolia), so you can try each one without moving real funds. To protect a request against duplicates, set a unique `externalTxId` on every request, as described in [Transaction idempotency](/reference/api-idempotency#transaction-idempotency). The full list of fields, enums and limits is in the [API reference](/api-reference/transactions/create-a-new-transaction).

## Vault account to vault account

This example sends 0.001 `ETH_TEST5` from one vault account to another, which is the most common transfer. Replace the placeholders with your own vault account IDs.

<Tabs>
  <Tab title="SDK">
    <CodeGroup>
      ```typescript TypeScript theme={"system"}
      import { TransferPeerPathType } from "@fireblocks/ts-sdk";

      const response = await fireblocks.transactions.createTransaction({
        transactionRequest: {
          assetId: "ETH_TEST5",
          amount: "0.001",
          source: {
            type: TransferPeerPathType.VaultAccount,
            id: "<SOURCE_VAULT_ACCOUNT_ID>",
          },
          destination: {
            type: TransferPeerPathType.VaultAccount,
            id: "<DESTINATION_VAULT_ACCOUNT_ID>",
          },
          note: "First transfer", // Optional - Free-text note shown in your workspace, not sent to the blockchain
          externalTxId: "<YOUR_UNIQUE_ID>", // Optional - Your unique ID; Fireblocks rejects later requests with the same value
        },
      });
      console.log(response.data);
      ```

      ```python Python theme={"system"}
      from fireblocks.models.transaction_request import TransactionRequest
      from fireblocks.models.source_transfer_peer_path import SourceTransferPeerPath
      from fireblocks.models.destination_transfer_peer_path import DestinationTransferPeerPath
      from fireblocks.models.transfer_peer_path_type import TransferPeerPathType
      from fireblocks.models.transaction_request_amount import TransactionRequestAmount

      transaction_request = TransactionRequest(
          asset_id="ETH_TEST5",
          amount=TransactionRequestAmount("0.001"),
          source=SourceTransferPeerPath(
              type=TransferPeerPathType.VAULT_ACCOUNT,
              id="<SOURCE_VAULT_ACCOUNT_ID>",
          ),
          destination=DestinationTransferPeerPath(
              type=TransferPeerPathType.VAULT_ACCOUNT,
              id="<DESTINATION_VAULT_ACCOUNT_ID>",
          ),
          note="First transfer",  # Optional - Free-text note shown in your workspace, not sent to the blockchain
          external_tx_id="<YOUR_UNIQUE_ID>",  # Optional - Your unique ID; Fireblocks rejects later requests with the same value
      )

      future = fireblocks.transactions.create_transaction(
          transaction_request=transaction_request,
      )
      print(future.result().data)  # create_transaction returns a Future
      ```

      ```java Java theme={"system"}
      import com.fireblocks.sdk.model.*;

      TransactionRequest transactionRequest = new TransactionRequest()
          .assetId("ETH_TEST5")
          .amount(new TransactionRequestAmount("0.001"))
          .source(new SourceTransferPeerPath()
              .type(TransferPeerPathType.VAULT_ACCOUNT)
              .id("<SOURCE_VAULT_ACCOUNT_ID>"))
          .destination(new DestinationTransferPeerPath()
              .type(TransferPeerPathType.VAULT_ACCOUNT)
              .id("<DESTINATION_VAULT_ACCOUNT_ID>"))
          .note("First transfer") // Optional - Free-text note shown in your workspace, not sent to the blockchain
          .externalTxId("<YOUR_UNIQUE_ID>"); // Optional - Your unique ID; Fireblocks rejects later requests with the same value

      CreateTransactionResponse transaction = fireblocks.transactions()
          .createTransaction(
              transactionRequest,
              null, // Optional - xEndUserWalletId (UUID), only for end-user wallet operations
              null) // Optional - Not used for transactions; use externalTxId in the request body
          .get()
          .getData();
      System.out.println(transaction);
      ```
    </CodeGroup>
  </Tab>

  <Tab title="API">
    ```http theme={"system"}
    POST /v1/transactions
    ```

    ```json theme={"system"}
    {
      "assetId": "ETH_TEST5",
      "amount": "0.001",
      "source": { "type": "VAULT_ACCOUNT", "id": "<SOURCE_VAULT_ACCOUNT_ID>" },
      "destination": { "type": "VAULT_ACCOUNT", "id": "<DESTINATION_VAULT_ACCOUNT_ID>" },
      "note": "First transfer",
      "externalTxId": "<YOUR_UNIQUE_ID>"
    }
    ```

    Sign the request with a JWT as described in [Signing a request](/reference/signing-a-request-jwt-structure).
  </Tab>

  <Tab title="CLI">
    ```bash theme={"system"}
    # Preview the request without sending it
    fireblocks transactions create-transaction \
      --data '{"assetId":"ETH_TEST5","amount":"0.001","source":{"type":"VAULT_ACCOUNT","id":"<SOURCE_VAULT_ACCOUNT_ID>"},"destination":{"type":"VAULT_ACCOUNT","id":"<DESTINATION_VAULT_ACCOUNT_ID>"},"externalTxId":"<YOUR_UNIQUE_ID>"}' \
      --dry-run

    # Execute
    fireblocks transactions create-transaction \
      --data '{"assetId":"ETH_TEST5","amount":"0.001","source":{"type":"VAULT_ACCOUNT","id":"<SOURCE_VAULT_ACCOUNT_ID>"},"destination":{"type":"VAULT_ACCOUNT","id":"<DESTINATION_VAULT_ACCOUNT_ID>"},"externalTxId":"<YOUR_UNIQUE_ID>"}' \
      --no-confirm
    ```
  </Tab>
</Tabs>

The remaining examples on this page change only the source or destination, so they show just the request and the call, and they rely on the same imports as the example above.

## Send to a one-time address

A one-time address sends to a blockchain address that is not saved in your workspace, so it is not covered by your allowlist. Put the address in `oneTimeAddress`, and add a `tag` only for assets that use a memo or destination tag.

<Tabs>
  <Tab title="SDK">
    <CodeGroup>
      ```typescript TypeScript theme={"system"}
      await fireblocks.transactions.createTransaction({
        transactionRequest: {
          assetId: "ETH_TEST5",
          amount: "0.001",
          source: { type: TransferPeerPathType.VaultAccount, id: "<SOURCE_VAULT_ACCOUNT_ID>" },
          destination: {
            type: TransferPeerPathType.OneTimeAddress,
            oneTimeAddress: {
              address: "<DESTINATION_ADDRESS>",
              // tag: "<MEMO_OR_TAG>", // Optional - Memo or destination tag for assets that require one
            },
          },
        },
      });
      ```

      ```python Python theme={"system"}
      from fireblocks.models.one_time_address import OneTimeAddress

      transaction_request = TransactionRequest(
          asset_id="ETH_TEST5",
          amount=TransactionRequestAmount("0.001"),
          source=SourceTransferPeerPath(
              type=TransferPeerPathType.VAULT_ACCOUNT,
              id="<SOURCE_VAULT_ACCOUNT_ID>",
          ),
          destination=DestinationTransferPeerPath(
              type=TransferPeerPathType.ONE_TIME_ADDRESS,
              one_time_address=OneTimeAddress(
                  address="<DESTINATION_ADDRESS>",
                  # tag="<MEMO_OR_TAG>",  # Optional - Memo or destination tag for assets that require one
              ),
          ),
      )
      fireblocks.transactions.create_transaction(transaction_request=transaction_request).result()
      ```

      ```java Java theme={"system"}
      TransactionRequest transactionRequest = new TransactionRequest()
          .assetId("ETH_TEST5")
          .amount(new TransactionRequestAmount("0.001"))
          .source(new SourceTransferPeerPath()
              .type(TransferPeerPathType.VAULT_ACCOUNT)
              .id("<SOURCE_VAULT_ACCOUNT_ID>"))
          .destination(new DestinationTransferPeerPath()
              .type(TransferPeerPathType.ONE_TIME_ADDRESS)
              .oneTimeAddress(new OneTimeAddress()
                  .address("<DESTINATION_ADDRESS>")
                  // .tag("<MEMO_OR_TAG>") // Optional - Memo or destination tag for assets that require one
              ));

      fireblocks.transactions().createTransaction(transactionRequest, null, null).get();
      ```
    </CodeGroup>
  </Tab>

  <Tab title="API">
    ```http theme={"system"}
    POST /v1/transactions
    ```

    ```json theme={"system"}
    {
      "assetId": "ETH_TEST5",
      "amount": "0.001",
      "source": { "type": "VAULT_ACCOUNT", "id": "<SOURCE_VAULT_ACCOUNT_ID>" },
      "destination": {
        "type": "ONE_TIME_ADDRESS",
        "oneTimeAddress": { "address": "<DESTINATION_ADDRESS>" }
      }
    }
    ```

    Sign the request with a JWT as described in [Signing a request](/reference/signing-a-request-jwt-structure).
  </Tab>

  <Tab title="CLI">
    ```bash theme={"system"}
    fireblocks transactions create-transaction \
      --data '{"assetId":"ETH_TEST5","amount":"0.001","source":{"type":"VAULT_ACCOUNT","id":"<SOURCE_VAULT_ACCOUNT_ID>"},"destination":{"type":"ONE_TIME_ADDRESS","oneTimeAddress":{"address":"<DESTINATION_ADDRESS>"}},"externalTxId":"<YOUR_UNIQUE_ID>"}' \
      --dry-run
    ```
  </Tab>
</Tabs>

## Send to an allowlisted wallet

To send to a wallet saved in your workspace, set the destination `type` to `INTERNAL_WALLET`, `EXTERNAL_WALLET` or `CONTRACT` and pass the wallet's `id`. The example uses an external wallet, and the other two wallet types differ only in the `type` value and the ID. See [Allowlist addresses](/docs/whitelist-addresses) for how these wallets are created and [Sources and destinations](/reference/transaction-sources-destinations) for the peer types.

<Tabs>
  <Tab title="SDK">
    <CodeGroup>
      ```typescript TypeScript theme={"system"}
      await fireblocks.transactions.createTransaction({
        transactionRequest: {
          assetId: "ETH_TEST5",
          amount: "0.001",
          source: { type: TransferPeerPathType.VaultAccount, id: "<SOURCE_VAULT_ACCOUNT_ID>" },
          destination: {
            type: TransferPeerPathType.ExternalWallet, // Also TransferPeerPathType.InternalWallet or TransferPeerPathType.Contract
            id: "<EXTERNAL_WALLET_ID>",
          },
        },
      });
      ```

      ```python Python theme={"system"}
      transaction_request = TransactionRequest(
          asset_id="ETH_TEST5",
          amount=TransactionRequestAmount("0.001"),
          source=SourceTransferPeerPath(
              type=TransferPeerPathType.VAULT_ACCOUNT,
              id="<SOURCE_VAULT_ACCOUNT_ID>",
          ),
          destination=DestinationTransferPeerPath(
              type=TransferPeerPathType.EXTERNAL_WALLET,  # Also INTERNAL_WALLET or CONTRACT
              id="<EXTERNAL_WALLET_ID>",
          ),
      )
      fireblocks.transactions.create_transaction(transaction_request=transaction_request).result()
      ```

      ```java Java theme={"system"}
      TransactionRequest transactionRequest = new TransactionRequest()
          .assetId("ETH_TEST5")
          .amount(new TransactionRequestAmount("0.001"))
          .source(new SourceTransferPeerPath()
              .type(TransferPeerPathType.VAULT_ACCOUNT)
              .id("<SOURCE_VAULT_ACCOUNT_ID>"))
          .destination(new DestinationTransferPeerPath()
              .type(TransferPeerPathType.EXTERNAL_WALLET) // Also INTERNAL_WALLET or CONTRACT
              .id("<EXTERNAL_WALLET_ID>"));

      fireblocks.transactions().createTransaction(transactionRequest, null, null).get();
      ```
    </CodeGroup>
  </Tab>

  <Tab title="API">
    ```http theme={"system"}
    POST /v1/transactions
    ```

    ```json theme={"system"}
    {
      "assetId": "ETH_TEST5",
      "amount": "0.001",
      "source": { "type": "VAULT_ACCOUNT", "id": "<SOURCE_VAULT_ACCOUNT_ID>" },
      "destination": { "type": "EXTERNAL_WALLET", "id": "<EXTERNAL_WALLET_ID>" }
    }
    ```

    Sign the request with a JWT as described in [Signing a request](/reference/signing-a-request-jwt-structure).
  </Tab>

  <Tab title="CLI">
    ```bash theme={"system"}
    fireblocks transactions create-transaction \
      --data '{"assetId":"ETH_TEST5","amount":"0.001","source":{"type":"VAULT_ACCOUNT","id":"<SOURCE_VAULT_ACCOUNT_ID>"},"destination":{"type":"EXTERNAL_WALLET","id":"<EXTERNAL_WALLET_ID>"},"externalTxId":"<YOUR_UNIQUE_ID>"}' \
      --dry-run
    ```
  </Tab>
</Tabs>

## Send to an exchange account or network connection

To send to a connected exchange account, use the destination `type` `EXCHANGE_ACCOUNT` with the exchange account's ID. To send to a Fireblocks Network connection, use `NETWORK_CONNECTION` with the connection's ID. The example shows an exchange account, and [Connect to exchanges and fiat providers](/reference/connect-to-exchanges-fiat-providers) explains how to connect the accounts and find their IDs.

<Tabs>
  <Tab title="SDK">
    <CodeGroup>
      ```typescript TypeScript theme={"system"}
      await fireblocks.transactions.createTransaction({
        transactionRequest: {
          assetId: "ETH_TEST5",
          amount: "0.001",
          source: { type: TransferPeerPathType.VaultAccount, id: "<SOURCE_VAULT_ACCOUNT_ID>" },
          destination: {
            type: TransferPeerPathType.ExchangeAccount, // Or TransferPeerPathType.NetworkConnection
            id: "<EXCHANGE_ACCOUNT_ID>",
          },
        },
      });
      ```

      ```python Python theme={"system"}
      transaction_request = TransactionRequest(
          asset_id="ETH_TEST5",
          amount=TransactionRequestAmount("0.001"),
          source=SourceTransferPeerPath(
              type=TransferPeerPathType.VAULT_ACCOUNT,
              id="<SOURCE_VAULT_ACCOUNT_ID>",
          ),
          destination=DestinationTransferPeerPath(
              type=TransferPeerPathType.EXCHANGE_ACCOUNT,  # Or NETWORK_CONNECTION
              id="<EXCHANGE_ACCOUNT_ID>",
          ),
      )
      fireblocks.transactions.create_transaction(transaction_request=transaction_request).result()
      ```

      ```java Java theme={"system"}
      TransactionRequest transactionRequest = new TransactionRequest()
          .assetId("ETH_TEST5")
          .amount(new TransactionRequestAmount("0.001"))
          .source(new SourceTransferPeerPath()
              .type(TransferPeerPathType.VAULT_ACCOUNT)
              .id("<SOURCE_VAULT_ACCOUNT_ID>"))
          .destination(new DestinationTransferPeerPath()
              .type(TransferPeerPathType.EXCHANGE_ACCOUNT) // Or NETWORK_CONNECTION
              .id("<EXCHANGE_ACCOUNT_ID>"));

      fireblocks.transactions().createTransaction(transactionRequest, null, null).get();
      ```
    </CodeGroup>
  </Tab>

  <Tab title="API">
    ```http theme={"system"}
    POST /v1/transactions
    ```

    ```json theme={"system"}
    {
      "assetId": "ETH_TEST5",
      "amount": "0.001",
      "source": { "type": "VAULT_ACCOUNT", "id": "<SOURCE_VAULT_ACCOUNT_ID>" },
      "destination": { "type": "EXCHANGE_ACCOUNT", "id": "<EXCHANGE_ACCOUNT_ID>" }
    }
    ```

    Sign the request with a JWT as described in [Signing a request](/reference/signing-a-request-jwt-structure).
  </Tab>

  <Tab title="CLI">
    ```bash theme={"system"}
    fireblocks transactions create-transaction \
      --data '{"assetId":"ETH_TEST5","amount":"0.001","source":{"type":"VAULT_ACCOUNT","id":"<SOURCE_VAULT_ACCOUNT_ID>"},"destination":{"type":"EXCHANGE_ACCOUNT","id":"<EXCHANGE_ACCOUNT_ID>"},"externalTxId":"<YOUR_UNIQUE_ID>"}' \
      --dry-run
    ```
  </Tab>
</Tabs>

## Send from a Wallet Pool

A Wallet Pool groups vault accounts under one logical source, so you name the pool as the `source` and Fireblocks selects a member vault account to send from. The pool is set up as described in [Wallet Pools](/docs/wallet-pools), which also covers policy setup and reconciliation.

<Tabs>
  <Tab title="SDK">
    <CodeGroup>
      ```typescript TypeScript theme={"system"}
      await fireblocks.transactions.createTransaction({
        transactionRequest: {
          assetId: "ETH_TEST5",
          amount: "0.001",
          source: { type: TransferPeerPathType.WalletPool, id: "<WALLET_POOL_ID>" },
          destination: { type: TransferPeerPathType.VaultAccount, id: "<DESTINATION_VAULT_ACCOUNT_ID>" },
        },
      });
      ```

      ```python Python theme={"system"}
      transaction_request = TransactionRequest(
          asset_id="ETH_TEST5",
          amount=TransactionRequestAmount("0.001"),
          source=SourceTransferPeerPath(
              type=TransferPeerPathType.WALLET_POOL,
              id="<WALLET_POOL_ID>",
          ),
          destination=DestinationTransferPeerPath(
              type=TransferPeerPathType.VAULT_ACCOUNT,
              id="<DESTINATION_VAULT_ACCOUNT_ID>",
          ),
      )
      fireblocks.transactions.create_transaction(transaction_request=transaction_request).result()
      ```

      ```java Java theme={"system"}
      TransactionRequest transactionRequest = new TransactionRequest()
          .assetId("ETH_TEST5")
          .amount(new TransactionRequestAmount("0.001"))
          .source(new SourceTransferPeerPath()
              .type(TransferPeerPathType.WALLET_POOL)
              .id("<WALLET_POOL_ID>"))
          .destination(new DestinationTransferPeerPath()
              .type(TransferPeerPathType.VAULT_ACCOUNT)
              .id("<DESTINATION_VAULT_ACCOUNT_ID>"));

      fireblocks.transactions().createTransaction(transactionRequest, null, null).get();
      ```
    </CodeGroup>
  </Tab>

  <Tab title="API">
    ```http theme={"system"}
    POST /v1/transactions
    ```

    ```json theme={"system"}
    {
      "assetId": "ETH_TEST5",
      "amount": "0.001",
      "source": { "type": "WALLET_POOL", "id": "<WALLET_POOL_ID>" },
      "destination": { "type": "VAULT_ACCOUNT", "id": "<DESTINATION_VAULT_ACCOUNT_ID>" }
    }
    ```

    Sign the request with a JWT as described in [Signing a request](/reference/signing-a-request-jwt-structure).
  </Tab>

  <Tab title="CLI">
    ```bash theme={"system"}
    fireblocks transactions create-transaction \
      --data '{"assetId":"ETH_TEST5","amount":"0.001","source":{"type":"WALLET_POOL","id":"<WALLET_POOL_ID>"},"destination":{"type":"VAULT_ACCOUNT","id":"<DESTINATION_VAULT_ACCOUNT_ID>"},"externalTxId":"<YOUR_UNIQUE_ID>"}' \
      --dry-run
    ```
  </Tab>
</Tabs>

## Send to multiple destinations

UTXO-based blockchains such as Bitcoin can send a single transaction to several destinations. Instead of a single `destination`, pass a `destinations` array in which each entry has its own `amount` and `destination`. The example sends to two one-time addresses on the Bitcoin testnet (`BTC_TEST`). To choose which UTXOs fund the transaction, see [Select UTXOs for a transaction](/reference/select-utxos-for-a-transaction).

<Tabs>
  <Tab title="SDK">
    <CodeGroup>
      ```typescript TypeScript theme={"system"}
      await fireblocks.transactions.createTransaction({
        transactionRequest: {
          assetId: "BTC_TEST",
          source: { type: TransferPeerPathType.VaultAccount, id: "<SOURCE_VAULT_ACCOUNT_ID>" },
          destinations: [
            {
              amount: "0.001",
              destination: {
                type: TransferPeerPathType.OneTimeAddress,
                oneTimeAddress: { address: "<DESTINATION_ADDRESS_1>" },
              },
            },
            {
              amount: "0.002",
              destination: {
                type: TransferPeerPathType.OneTimeAddress,
                oneTimeAddress: { address: "<DESTINATION_ADDRESS_2>" },
              },
            },
          ],
        },
      });
      ```

      ```python Python theme={"system"}
      from fireblocks.models.transaction_request_destination import TransactionRequestDestination

      transaction_request = TransactionRequest(
          asset_id="BTC_TEST",
          source=SourceTransferPeerPath(
              type=TransferPeerPathType.VAULT_ACCOUNT,
              id="<SOURCE_VAULT_ACCOUNT_ID>",
          ),
          destinations=[
              TransactionRequestDestination(
                  amount="0.001",
                  destination=DestinationTransferPeerPath(
                      type=TransferPeerPathType.ONE_TIME_ADDRESS,
                      one_time_address=OneTimeAddress(address="<DESTINATION_ADDRESS_1>"))),
              TransactionRequestDestination(
                  amount="0.002",
                  destination=DestinationTransferPeerPath(
                      type=TransferPeerPathType.ONE_TIME_ADDRESS,
                      one_time_address=OneTimeAddress(address="<DESTINATION_ADDRESS_2>"))),
          ],
      )
      fireblocks.transactions.create_transaction(transaction_request=transaction_request).result()
      ```

      ```java Java theme={"system"}
      TransactionRequest transactionRequest = new TransactionRequest()
          .assetId("BTC_TEST")
          .source(new SourceTransferPeerPath()
              .type(TransferPeerPathType.VAULT_ACCOUNT)
              .id("<SOURCE_VAULT_ACCOUNT_ID>"))
          .addDestinationsItem(new TransactionRequestDestination()
              .amount("0.001")
              .destination(new DestinationTransferPeerPath()
                  .type(TransferPeerPathType.ONE_TIME_ADDRESS)
                  .oneTimeAddress(new OneTimeAddress().address("<DESTINATION_ADDRESS_1>"))))
          .addDestinationsItem(new TransactionRequestDestination()
              .amount("0.002")
              .destination(new DestinationTransferPeerPath()
                  .type(TransferPeerPathType.ONE_TIME_ADDRESS)
                  .oneTimeAddress(new OneTimeAddress().address("<DESTINATION_ADDRESS_2>"))));

      fireblocks.transactions().createTransaction(transactionRequest, null, null).get();
      ```
    </CodeGroup>
  </Tab>

  <Tab title="API">
    ```http theme={"system"}
    POST /v1/transactions
    ```

    ```json theme={"system"}
    {
      "assetId": "BTC_TEST",
      "source": { "type": "VAULT_ACCOUNT", "id": "<SOURCE_VAULT_ACCOUNT_ID>" },
      "destinations": [
        {
          "amount": "0.001",
          "destination": { "type": "ONE_TIME_ADDRESS", "oneTimeAddress": { "address": "<DESTINATION_ADDRESS_1>" } }
        },
        {
          "amount": "0.002",
          "destination": { "type": "ONE_TIME_ADDRESS", "oneTimeAddress": { "address": "<DESTINATION_ADDRESS_2>" } }
        }
      ]
    }
    ```

    Sign the request with a JWT as described in [Signing a request](/reference/signing-a-request-jwt-structure).
  </Tab>

  <Tab title="CLI">
    ```bash theme={"system"}
    fireblocks transactions create-transaction \
      --data '{"assetId":"BTC_TEST","source":{"type":"VAULT_ACCOUNT","id":"<SOURCE_VAULT_ACCOUNT_ID>"},"destinations":[{"amount":"0.001","destination":{"type":"ONE_TIME_ADDRESS","oneTimeAddress":{"address":"<DESTINATION_ADDRESS_1>"}}},{"amount":"0.002","destination":{"type":"ONE_TIME_ADDRESS","oneTimeAddress":{"address":"<DESTINATION_ADDRESS_2>"}}}],"externalTxId":"<YOUR_UNIQUE_ID>"}' \
      --dry-run
    ```
  </Tab>
</Tabs>

## Fees and amounts

These optional fields on the request control the fee and how the amount is treated, and each is described in full on the [Create a new transaction](/api-reference/transactions/create-a-new-transaction) page.

* `feeLevel` applies to UTXO, EVM-based and Solana blockchains and sets the fee level to pay, with the values `LOW`, `MEDIUM` and `HIGH`.
* `fee` is an alternative to `feeLevel` that gives the fee per byte for UTXO-based blockchains, or the transaction fee for Ripple.
* `priorityFee` is an alternative to `feeLevel` for Ethereum-based blockchains and sets the EIP-1559 priority fee in Gwei.
* `maxFee` is the maximum fee (gas price or fee per byte) you are willing to pay when the current `feeLevel` value is higher.
* `failOnLowFee` makes the transaction fail instead of getting stuck without confirmations when the current `MEDIUM` fee level is higher than the fee specified in the transaction.
* `treatAsGrossAmount` deducts the fee from the requested amount, and it is only considered when the asset is a base asset such as ETH, so it is ignored for assets such as USDC.

To see what a transaction will cost before you create it, use [Estimate a transaction fee](/reference/estimate-transaction-fee). The following example combines several of these fields in one request.

<Tabs>
  <Tab title="SDK">
    <CodeGroup>
      ```typescript TypeScript theme={"system"}
      await fireblocks.transactions.createTransaction({
        transactionRequest: {
          assetId: "ETH_TEST5",
          amount: "0.001",
          source: { type: TransferPeerPathType.VaultAccount, id: "<SOURCE_VAULT_ACCOUNT_ID>" },
          destination: { type: TransferPeerPathType.VaultAccount, id: "<DESTINATION_VAULT_ACCOUNT_ID>" },
          feeLevel: TransactionRequestFeeLevelEnum.Medium, // Optional - Also "LOW" or "HIGH"
          maxFee: "<MAX_FEE>", // Optional - Numeric string, caps the fee if the feeLevel value is higher
          failOnLowFee: true, // Optional - Fail instead of getting stuck when the fee is below the MEDIUM level
          treatAsGrossAmount: true, // Optional - Deduct the fee from the amount, base assets only
          // priorityFee: "<GWEI>", // Conditional - Alternative to feeLevel for EIP-1559 chains, in Gwei
          // fee: "<FEE>", // Conditional - Alternative to feeLevel for UTXO fee per byte or Ripple
        },
      });
      ```

      ```python Python theme={"system"}
      transaction_request = TransactionRequest(
          asset_id="ETH_TEST5",
          amount=TransactionRequestAmount("0.001"),
          source=SourceTransferPeerPath(
              type=TransferPeerPathType.VAULT_ACCOUNT,
              id="<SOURCE_VAULT_ACCOUNT_ID>",
          ),
          destination=DestinationTransferPeerPath(
              type=TransferPeerPathType.VAULT_ACCOUNT,
              id="<DESTINATION_VAULT_ACCOUNT_ID>",
          ),
          fee_level="MEDIUM",  # Optional - Also "LOW" or "HIGH"
          max_fee="<MAX_FEE>",  # Optional - Numeric string, caps the fee if the fee_level value is higher
          fail_on_low_fee=True,  # Optional - Fail instead of getting stuck when the fee is below the MEDIUM level
          treat_as_gross_amount=True,  # Optional - Deduct the fee from the amount, base assets only
          # priority_fee=TransactionRequestPriorityFee("<GWEI>"),  # Conditional - Alternative to fee_level for EIP-1559 chains, in Gwei
          # fee=TransactionRequestFee("<FEE>"),  # Conditional - Alternative to fee_level for UTXO fee per byte or Ripple
      )
      fireblocks.transactions.create_transaction(transaction_request=transaction_request).result()
      ```

      ```java Java theme={"system"}
      TransactionRequest transactionRequest = new TransactionRequest()
          .assetId("ETH_TEST5")
          .amount(new TransactionRequestAmount("0.001"))
          .source(new SourceTransferPeerPath()
              .type(TransferPeerPathType.VAULT_ACCOUNT)
              .id("<SOURCE_VAULT_ACCOUNT_ID>"))
          .destination(new DestinationTransferPeerPath()
              .type(TransferPeerPathType.VAULT_ACCOUNT)
              .id("<DESTINATION_VAULT_ACCOUNT_ID>"))
          .feeLevel(TransactionRequest.FeeLevelEnum.MEDIUM) // Optional - Also LOW or HIGH
          .maxFee("<MAX_FEE>") // Optional - Numeric string, caps the fee if the feeLevel value is higher
          .failOnLowFee(true) // Optional - Fail instead of getting stuck when the fee is below the MEDIUM level
          .treatAsGrossAmount(true); // Optional - Deduct the fee from the amount, base assets only
          // .priorityFee(new TransactionRequestPriorityFee("<GWEI>")) // Conditional - Alternative to feeLevel for EIP-1559 chains, in Gwei
          // .fee(new TransactionRequestFee("<FEE>")) // Conditional - Alternative to feeLevel for UTXO fee per byte or Ripple

      fireblocks.transactions().createTransaction(transactionRequest, null, null).get();
      ```
    </CodeGroup>
  </Tab>

  <Tab title="API">
    ```http theme={"system"}
    POST /v1/transactions
    ```

    ```json theme={"system"}
    {
      "assetId": "ETH_TEST5",
      "amount": "0.001",
      "source": { "type": "VAULT_ACCOUNT", "id": "<SOURCE_VAULT_ACCOUNT_ID>" },
      "destination": { "type": "VAULT_ACCOUNT", "id": "<DESTINATION_VAULT_ACCOUNT_ID>" },
      "feeLevel": "MEDIUM",
      "maxFee": "<MAX_FEE>",
      "failOnLowFee": true,
      "treatAsGrossAmount": true
    }
    ```

    Sign the request with a JWT as described in [Signing a request](/reference/signing-a-request-jwt-structure).
  </Tab>

  <Tab title="CLI">
    ```bash theme={"system"}
    fireblocks transactions create-transaction \
      --data '{"assetId":"ETH_TEST5","amount":"0.001","source":{"type":"VAULT_ACCOUNT","id":"<SOURCE_VAULT_ACCOUNT_ID>"},"destination":{"type":"VAULT_ACCOUNT","id":"<DESTINATION_VAULT_ACCOUNT_ID>"},"feeLevel":"MEDIUM","maxFee":"<MAX_FEE>","failOnLowFee":true,"treatAsGrossAmount":true,"externalTxId":"<YOUR_UNIQUE_ID>"}' \
      --dry-run
    ```
  </Tab>
</Tabs>