Skip to main content
GET
Get a transaction

Authorizations

​
x-api-key
string
header
required

Path Parameters

​
transaction_id
string
required

Unique identifier of the transaction. KSUID is a 27-character globally unique ID that combines a timestamp with a random component. Used for all entity identifiers in the Dakota platform.

Required string length: 27
Pattern: ^[0-9A-Za-z]{27}$
Example:

"1NFHrqBHb3cTfLVkFSGmHZqdDPi"

Response

Transaction details.

A one-off transaction response. Used for single-use offramp (crypto-to-fiat) and swap (crypto-to-crypto) transfers; the destination type determines which.

​
id
string
required

KSUID is a 27-character globally unique ID that combines a timestamp with a random component. Used for all entity identifiers in the Dakota platform.

Required string length: 27
Pattern: ^[0-9A-Za-z]{27}$
Example:

"1NFHrqBHb3cTfLVkFSGmHZqdDPi"

​
resource_type
enum<string>
required

Discriminator field. Always "one_off" for one-off transactions.

Available options:
one_off,
wallet,
auto_account
Example:

"one_off"

​
customer_id
string
required

KSUID is a 27-character globally unique ID that combines a timestamp with a random component. Used for all entity identifiers in the Dakota platform.

Required string length: 27
Pattern: ^[0-9A-Za-z]{27}$
Example:

"1NFHrqBHb3cTfLVkFSGmHZqdDPi"

​
crypto_address
string
required

Temporary address where funds should be sent

Example:

"0x1234567890abcdef1234567890abcdef12345678"

​
status
enum<string>
required

Status of a one-off transaction.

failed means the payment stopped and Dakota is not retrying it. A payout Dakota can still retry stays processing, including while Dakota resolves a problem with it, until it is completed, or cancelled or reversed if Dakota stops it. Do not refund your customer or re-send the payment while it is processing. A failed payout moves again only if Dakota operations recover it by hand (for example an on-chain transfer that reverted); it is then reported as processing and later completed. One-off transactions that reported failed before this behaviour shipped may also move on if Dakota retried them.

An international (SWIFT) wire that the receiving bank returns passes through pending_return and returned, and ends as reversed once the returned funds are refunded to the source wallet. reversed therefore also describes a returned SWIFT payout, not only an ACH originator reversal. SWIFT returns are not refunded automatically: the payout stays at returned until the refund is made.

A payout the bank returned carries a failure_code on returned and on the later reversed: the code mapped from the bank's return code when there is one (for example recipient_account_number_invalid), otherwise payment_returned, with return_reason holding Dakota's message for it. reversal_reason stays empty. A reversed payout with a failure_code but no reversal_reason is therefore a bank return that was refunded, not an ACH originator reversal. Payouts returned before this behaviour shipped may carry no failure_code.

A deduction the bank or an intermediary takes from the returned funds is normally borne by the customer. net_recovered_amount is set once the refund is sized, and only when the customer bore a deduction; it is the face amount less that deduction. On pending_return and returned it is absent whatever came back, so its absence there says nothing about the amount. On a reversed payout that was a bank return, its absence means the customer was refunded in full: either nothing was withheld, or Dakota absorbed the deduction because the refund was made before the bank reported what it returned.

Available options:
pending,
processing,
completed,
failed,
cancelled,
reversed,
pending_return,
returned,
pending_reversal
Example:

"pending"

​
source_network_id
enum<string>
required

Identifier for a blockchain network

Available options:
ethereum-mainnet,
ethereum-sepolia,
ethereum-goerli,
ethereum-holesky,
solana-mainnet,
solana-devnet,
solana-testnet,
base-mainnet,
base-sepolia,
arbitrum-mainnet,
arbitrum-sepolia,
optimism-mainnet,
optimism-sepolia,
polygon-mainnet,
polygon-amoy
Required string length: 1 - 30
Example:

"ethereum-mainnet"

​
source_asset
string
required

Source crypto asset symbol

Example:

"USDC"

​
destination_id
string
required

KSUID is a 27-character globally unique ID that combines a timestamp with a random component. Used for all entity identifiers in the Dakota platform.

Required string length: 27
Pattern: ^[0-9A-Za-z]{27}$
Example:

"1NFHrqBHb3cTfLVkFSGmHZqdDPi"

​
destination_asset
string
required

ISO 4217 symbol representing a fiat asset.

Required string length: 3
Pattern: ^[A-Z]{3}$
Example:

"USD"

​
developer_fee_bps
integer<int32>
required

Developer fee for this transaction in basis points (1 bp = 0.01%), as set by developer_fee_bps on the request. 0 when no developer fee was set. One-off transactions created before this field was introduced also report 0, whatever fee they were created with.

Example:

50

​
created_at
integer
required

Unix timestamp when the transaction was created

Example:

1234567890

​
updated_at
integer
required

Unix timestamp when the transaction was last updated

Example:

1234567890

​
fx_pricing
object

How the FX rate and fee on this transaction were priced. Absent when the transaction has no FX pricing, including every transaction created before it was introduced. Transaction and receipt endpoints omit it when there is none. In events (webhooks, GET /events and webhook history) a transaction.auto.updated or transaction.one_off.updated event carries fx_pricing set to null when the provider withdrew a previously quoted price and nothing replaced it; discard any quoted pricing you hold. The null may also appear when the provider repeats a withdrawal. A final pricing is never withdrawn.

​
fx_outgoing_amounts
object

Version 1 foreign outgoing amount_state unknown, with exact known source amount/currency and destination currency. Not a quote.

​
fx_settlement
object

Version 1 verified outgoing native amounts and bank payout evidence. Absent means settlement amount is unknown.

​
send_amount
string

Exact amount of source_asset to send to crypto_address so that the payout, after the developer fee (developer_fee_bps or developer_fee_fixed), is the amount on the request. Send this value rather than adding the fee yourself: a bps fee is rounded up, so a total you round yourself can pay out a cent less.

Present only when the request set amount and the payout is one to one with the deposit: the same asset on both sides, or two US dollar assets other than USDT (such as USDC paid out as USD). Absent otherwise, because the payout is then priced when the funds arrive (USDT at the market rate, other currencies through FX). Also absent on a USD payout when amount has digits below a cent, which a USD payout cannot carry. With developer_fee_fixed, the deposit must also be a US dollar stablecoin other than USDT.

Example:

"1.24"

​
amount
string

Amount to send to crypto_address. Always equal to send_amount, and present only when it is. This is not the amount on the request, which is the destination amount you expect; the requested amount is not returned here (transaction.one_off.* webhooks carry it as destination_amount).

Example:

"1.24"

​
developer_fee_fixed
string

Fixed developer fee for this transaction, in units of the asset deposited, as set by developer_fee_fixed on the request. Absent when no fixed fee was set.

Example:

"10.00"

​
failure_reason
string

Dakota's explanation of why the transaction failed, present if status is failed. Descriptive text for display; use failure_code for logic.

​
failure_code
enum<string>

Stable, machine-readable reason a transaction failed, was returned, or was reversed. Pair it with the human-readable failure_reason, return_reason or reversal_reason, which carry Dakota's message for this code. Switch on failure_code, not on the message text, which may be reworded.

failure_code is not a status: read status for the outcome. A returned payout keeps its code on returned and on the later reversed (the refund to the source wallet); payouts returned before this behaviour shipped may carry none. payment_returned is the code for a return whose bank reason does not map to a more specific value, including a return that carried no bank code at all. A payout that completes after a return (for example a resent wire) or after a rejected ACH reversal has no failure_code.

The set of values is open: Dakota may add codes without a new API version, so treat any value you do not recognize like processing_error. processing_error is the general code for anything not listed; contact support with the transaction ID.

Available options:
recipient_account_not_found,
recipient_account_number_invalid,
recipient_account_blocked,
recipient_account_type_unsupported,
recipient_refused,
recipient_name_mismatch,
recipient_details_missing,
recipient_address_invalid,
recipient_bank_routing_invalid,
recipient_bank_bic_invalid,
limit_exceeded,
payment_reversed_duplicate,
payment_reversed_wrong_recipient,
payment_reversed_wrong_amount,
payment_returned,
processing_error
Example:

"recipient_account_not_found"

​
receipt
object | null

Detailed receipt information for a transaction

​
crypto_details
object | null

Blockchain-specific details for crypto transactions

​
sender_details
object

Originating sender details for onramp/offramp/swap transactions. Populated when source-side metadata is available (e.g., from inbound wire/ACH source data).

​
completed_at
integer

Unix timestamp when the transaction was completed

Example:

1234567890

​
destination_payment_rail
enum<string> | null

The payment rail that was selected for this transaction

Available options:
ach,
fedwire,
swift,
us_bank_account,
fednow
Example:

"ach"

​
payment_reference
string | null

Payment reference message for bank transfers (e.g. wire message, SWIFT remittance information, or SEPA reference)

​
external_id
string

Your own label for this one-off transaction in your system, used to look it up with the external_id filter on GET /transactions. Not unique: Dakota does not reject a duplicate, and several one-off transactions can share one value. Omitted when none was set.

Example:

"avenia-ticket-8841"

​
destination_bank_name
string

Name of the destination bank

Example:

"Chase Bank"

​
destination_account_holder_name
string

Name of the account holder at the destination bank

Example:

"Acme Corporation"

​
destination_account_number_last_four
string

Last four digits of the destination account number

Example:

"6789"

​
destination_routing_number
string

ABA routing number for US bank accounts

Example:

"021000021"

​
destination_iban
string

IBAN for international bank accounts

Example:

"GB82WEST12345698765432"

​
destination_bic
string

BIC/SWIFT code for international transfers

Example:

"BARCGB22XXX"

​
return_code
string

Return code (e.g., R01) when the transaction was returned by the receiving bank. NACHA/Fedwire codes for US bank rails; international (SWIFT) wire returns carry no NACHA code and may return a reduced amount after intermediary fees. A return can arrive with no code; failure_code is still set (to payment_returned). Cleared if the transaction later completes.

Example:

"R01"

​
return_reason
string

Dakota's explanation of why the payment was returned. Descriptive text for display; use failure_code for logic.

Example:

"The recipient account could not be found."

​
return_initiated_at
integer

Unix timestamp when the return was initiated.

Example:

1234567890

​
return_deadline
integer

Unix timestamp deadline for return processing.

Example:

1234567890

​
net_recovered_amount
string | null

Decimal amount recovered when a returned payout came back short and the customer bore the deduction, denominated in the transaction's own currency (the same basis as its face amount), so face amount minus this value is what the customer went without. Present only in that case; it never means zero. It is set once the refund to the source wallet has been sized. It is absent on pending_return and returned whatever came back, can first appear on pending_reversal, and stays on reversed. After the refund is sized, absence means the customer was refunded the face amount in full, because the whole amount came back, Dakota absorbed the bank's deduction (a refund made before the bank reported what it returned), or the rail reports no net figure (ACH never does). Cleared, like the other return fields, if the payout later completes (for example a returned wire that was resent and delivered).

Example:

"24955"

​
reversal_reason
string

ACH reversal reason when the originator reverses the transaction (e.g., duplicate, receiver_incorrect). Not set for an international (SWIFT) wire that the receiving bank returned: that payout ends as reversed once the funds are refunded to the source wallet, reversal_reason stays empty, and failure_code (the mapped bank code, or payment_returned) says it was returned. net_recovered_amount carries the face amount less the bank's deduction when the customer bore one, and return_code the bank's code when it sent one. Cleared if the transaction later completes (the bank rejected the reversal).

Example:

"duplicate"

​
reversal_initiated_at
integer

Unix timestamp when the reversal was initiated. Cleared if the transaction later completes (the bank rejected the reversal).

Example:

1234567890

​
customer_name
string

Display name of the customer associated with this transaction.

Example:

"Acme Corp"