Transfers

A transfer moves an asset from a source to one or more destinations and is the default operation of the Create a new transaction endpoint. The examples on this page assume an initialised client as described in 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. The full list of fields, enums and limits is in the API reference.

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.

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);

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

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);

POST /v1/transactions

{
  "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.

# 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

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.

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
      },
    },
  },
});

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()

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();

POST /v1/transactions

{
  "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.

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

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 for how these wallets are created and Sources and destinations for the peer types.

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>",
    },
  },
});

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()

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();

POST /v1/transactions

{
  "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.

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

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 explains how to connect the accounts and find their IDs.

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>",
    },
  },
});

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()

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();

POST /v1/transactions

{
  "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.

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

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, which also covers policy setup and reconciliation.

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>" },
  },
});

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()

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();

POST /v1/transactions

{
  "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.

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

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.

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>" },
        },
      },
    ],
  },
});

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()

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();

POST /v1/transactions

{
  "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.

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

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 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. The following example combines several of these fields in one request.

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
  },
});

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()

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();

POST /v1/transactions

{
  "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.

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

Get Started

Transactions

API Co-Signers

Webhooks

Workspace & Security

Identity & Compliance

Manage Wallets

Smart Contracts & Tokenization

Treasury & Trading

Gas Management

Payments

Embedded Wallets

Offchain Signing

Direct Custody Wallets

Integrations

Assets & NFTs

Canton

Key Link

Vault account to vault account

Send to a one-time address

Send to an allowlisted wallet

Send to an exchange account or network connection

Send from a Wallet Pool

Send to multiple destinations

Fees and amounts

​Vault account to vault account

​Send to a one-time address

​Send to an allowlisted wallet

​Send to an exchange account or network connection

​Send from a Wallet Pool

​Send to multiple destinations

​Fees and amounts

Vault account to vault account

Send to a one-time address

Send to an allowlisted wallet

Send to an exchange account or network connection

Send from a Wallet Pool

Send to multiple destinations

Fees and amounts