Get transaction details

curl --request GET \
  --url https://api.yield.xyz/v1/transactions/{transactionId} \
  --header 'x-api-key: <api-key>'

const options = {method: 'GET', headers: {'x-api-key': '<api-key>'}};

fetch('https://api.yield.xyz/v1/transactions/{transactionId}', options)
  .then(res => res.json())
  .then(res => console.log(res))
  .catch(err => console.error(err));

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.yield.xyz/v1/transactions/{transactionId}",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "x-api-key: <api-key>"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://api.yield.xyz/v1/transactions/{transactionId}"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("x-api-key", "<api-key>")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(string(body))

}

require 'uri'
require 'net/http'

url = URI("https://api.yield.xyz/v1/transactions/{transactionId}")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["x-api-key"] = '<api-key>'

response = http.request(request)
puts response.read_body

{
  "id": "tx_123abc",
  "title": "Approve USDC",
  "network": "ethereum",
  "status": "PENDING",
  "type": "STAKE",
  "hash": "0x1234567890abcdef...",
  "createdAt": "2023-11-07T05:31:56Z",
  "broadcastedAt": "2023-11-07T05:31:56Z",
  "signedTransaction": "<string>",
  "unsignedTransaction": "0x02f87082012a022f2f83018000947a250d5630b4cf539739df2c5dacb4c659f2488d880de0b6b3a764000080c080a0ef0de6c7b46fc75dd6cb86dccc3cfd731c2bdf6f3d736557240c3646c6fe01a6a07cd60b58dfe01847249dfdd7950ba0d045dded5bbe410b07a015a0ed34e5e00d",
  "annotatedTransaction": {
    "method": "stake",
    "inputs": {
      "amount": "1000000000000000000"
    }
  },
  "structuredTransaction": {},
  "stepIndex": 0,
  "description": "Approve USDC for staking",
  "error": "<string>",
  "gasEstimate": "21000",
  "explorerUrl": "https://etherscan.io/tx/0x1234...",
  "isMessage": false
}

{
  "message": "Validation failed",
  "error": "Bad Request",
  "statusCode": 400
}

{
  "message": "Invalid API key",
  "error": "Unauthorized",
  "statusCode": 401
}

{
  "message": "Rate limit exceeded",
  "error": "Too Many Requests",
  "statusCode": 429,
  "retryAfter": 30
}

{
  "message": "Internal server error",
  "error": "Internal Server Error",
  "statusCode": 500
}

GET

transactions

{transactionId}

Get transaction details

curl --request GET \
  --url https://api.yield.xyz/v1/transactions/{transactionId} \
  --header 'x-api-key: <api-key>'

const options = {method: 'GET', headers: {'x-api-key': '<api-key>'}};

fetch('https://api.yield.xyz/v1/transactions/{transactionId}', options)
  .then(res => res.json())
  .then(res => console.log(res))
  .catch(err => console.error(err));

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.yield.xyz/v1/transactions/{transactionId}",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "x-api-key: <api-key>"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://api.yield.xyz/v1/transactions/{transactionId}"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("x-api-key", "<api-key>")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(string(body))

}

require 'uri'
require 'net/http'

url = URI("https://api.yield.xyz/v1/transactions/{transactionId}")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["x-api-key"] = '<api-key>'

response = http.request(request)
puts response.read_body

{
  "id": "tx_123abc",
  "title": "Approve USDC",
  "network": "ethereum",
  "status": "PENDING",
  "type": "STAKE",
  "hash": "0x1234567890abcdef...",
  "createdAt": "2023-11-07T05:31:56Z",
  "broadcastedAt": "2023-11-07T05:31:56Z",
  "signedTransaction": "<string>",
  "unsignedTransaction": "0x02f87082012a022f2f83018000947a250d5630b4cf539739df2c5dacb4c659f2488d880de0b6b3a764000080c080a0ef0de6c7b46fc75dd6cb86dccc3cfd731c2bdf6f3d736557240c3646c6fe01a6a07cd60b58dfe01847249dfdd7950ba0d045dded5bbe410b07a015a0ed34e5e00d",
  "annotatedTransaction": {
    "method": "stake",
    "inputs": {
      "amount": "1000000000000000000"
    }
  },
  "structuredTransaction": {},
  "stepIndex": 0,
  "description": "Approve USDC for staking",
  "error": "<string>",
  "gasEstimate": "21000",
  "explorerUrl": "https://etherscan.io/tx/0x1234...",
  "isMessage": false
}

{
  "message": "Validation failed",
  "error": "Bad Request",
  "statusCode": 400
}

{
  "message": "Invalid API key",
  "error": "Unauthorized",
  "statusCode": 401
}

{
  "message": "Rate limit exceeded",
  "error": "Too Many Requests",
  "statusCode": 429,
  "retryAfter": 30
}

{
  "message": "Internal server error",
  "error": "Internal Server Error",
  "statusCode": 500
}

Authorizations

x-api-key

string

header

required

Path Parameters

transactionId

string

required

The unique identifier of the transaction

Response

Transaction details retrieved successfully

string

required

Unique transaction identifier

Example:

"tx_123abc"

title

string

required

Display title for the transaction

Example:

"Approve USDC"

network

enum<string>

required

Network this transaction is for

Available options:

ethereum,

ethereum-goerli,

ethereum-holesky,

ethereum-sepolia,

ethereum-hoodi,

arbitrum,

base,

base-sepolia,

gnosis,

optimism,

polygon,

polygon-amoy,

starknet,

zksync,

linea,

unichain,

monad-testnet,

avalanche-c,

avalanche-c-atomic,

avalanche-p,

binance,

celo,

fantom,

harmony,

moonriver,

okc,

viction,

core,

sonic,

katana,

hyperevm,

agoric,

akash,

axelar,

band-protocol,

bitsong,

canto,

chihuahua,

comdex,

coreum,

cosmos,

crescent,

cronos,

cudos,

desmos,

dydx,

evmos,

fetch-ai,

gravity-bridge,

injective,

irisnet,

juno,

kava,

ki-network,

mars-protocol,

nym,

okex-chain,

onomy,

osmosis,

persistence,

quicksilver,

regen,

secret,

sentinel,

sommelier,

stafi,

stargaze,

stride,

teritori,

tgrade,

umee,

sei,

mantra,

celestia,

saga,

zetachain,

dymension,

humansai,

neutron,

polkadot,

kusama,

westend,

bittensor,

binancebeacon,

cardano,

near,

solana,

solana-devnet,

stellar,

stellar-testnet,

sui,

tezos,

tron,

ton,

ton-testnet

Example:

"ethereum"

status

enum<string>

required

Current status of the transaction

Available options:

NOT_FOUND,

CREATED,

BLOCKED,

WAITING_FOR_SIGNATURE,

SIGNED,

BROADCASTED,

PENDING,

CONFIRMED,

FAILED,

SKIPPED

Example:

"PENDING"

type

enum<string>

required

Type of transaction operation

Available options:

SWAP,

DEPOSIT,

APPROVAL,

STAKE,

CLAIM_UNSTAKED,

CLAIM_REWARDS,

RESTAKE_REWARDS,

UNSTAKE,

SPLIT,

MERGE,

LOCK,

UNLOCK,

SUPPLY,

BRIDGE,

VOTE,

REVOKE,

RESTAKE,

REBOND,

WITHDRAW,

WITHDRAW_ALL,

CREATE_ACCOUNT,

REVEAL,

MIGRATE,

DELEGATE,

UNDELEGATE,

UTXO_P_TO_C_IMPORT,

UTXO_C_TO_P_IMPORT,

WRAP,

UNWRAP,

UNFREEZE_LEGACY,

UNFREEZE_LEGACY_BANDWIDTH,

UNFREEZE_LEGACY_ENERGY,

UNFREEZE_BANDWIDTH,

UNFREEZE_ENERGY,

FREEZE_BANDWIDTH,

FREEZE_ENERGY,

UNDELEGATE_BANDWIDTH,

UNDELEGATE_ENERGY,

P2P_NODE_REQUEST,

CREATE_EIGENPOD,

VERIFY_WITHDRAW_CREDENTIALS,

START_CHECKPOINT,

VERIFY_CHECKPOINT_PROOFS,

QUEUE_WITHDRAWALS,

COMPLETE_QUEUED_WITHDRAWALS,

LUGANODES_PROVISION,

LUGANODES_EXIT_REQUEST,

INFSTONES_PROVISION,

INFSTONES_EXIT_REQUEST,

INFSTONES_CLAIM_REQUEST

Example:

"STAKE"

hash

string | null

required

Transaction hash (available after broadcast)

Example:

"0x1234567890abcdef..."

createdAt

string<date-time>

required

When the transaction was created

broadcastedAt

string<date-time> | null

required

When the transaction was broadcasted to the network

signedTransaction

string | null

required

Signed transaction data (ready for broadcast)

unsignedTransaction

required

The unsigned transaction data to be signed by the wallet

Example:

"0x02f87082012a022f2f83018000947a250d5630b4cf539739df2c5dacb4c659f2488d880de0b6b3a764000080c080a0ef0de6c7b46fc75dd6cb86dccc3cfd731c2bdf6f3d736557240c3646c6fe01a6a07cd60b58dfe01847249dfdd7950ba0d045dded5bbe410b07a015a0ed34e5e00d"

annotatedTransaction

object | null

Human-readable breakdown of the transaction for display purposes

Example:

{
  "method": "stake",
  "inputs": { "amount": "1000000000000000000" }
}

structuredTransaction

object | null

Detailed transaction data for client-side validation or simulation

stepIndex

number

Zero-based index of the step in the action flow

Example:

0

description

string

User-friendly description of what this transaction does

Example:

"Approve USDC for staking"

error

string | null

Error message if the transaction failed

gasEstimate

string

Estimated gas cost for the transaction

Example:

"21000"

explorerUrl

string | null

Link to the blockchain explorer for this transaction

Example:

"https://etherscan.io/tx/0x1234..."

isMessage

boolean

Whether this transaction is a message rather than a value transfer

Example:

false

Getting Started

Yield.xyz API (StakeKit / DeFiKit / DataKit)

Perps API (PerpsKit)

Get transaction details

Authorizations

Path Parameters

Response