trace_transaction

trace_transaction re-executes a transaction that has already been included in a block and returns a flat list of action traces — one entry per call frame (the top-level call plus every internal CALL, DELEGATECALL, CREATE, and SELFDESTRUCT it triggered). This is the OpenEthereum / Parity trace format: instead of the nested call tree produced by debug_traceTransaction's callTracer, each frame is a separate array element, and its position in the call hierarchy is encoded by the traceAddress path.

Use it when you want a compact, post-hoc accounting of value movement and internal calls — for example reconstructing internal ETH transfers, attributing gas across sub-calls, or finding exactly which frame reverted. Because the output is flat and value-oriented (rather than opcode-level), it is much smaller than a struct log and is the trace format most block explorers and accounting tools expect.

This is a trace-namespace method available on the Pro tier and above. It is rate limited per tier (5 RPS on Pro, 15 RPS on Business) with a short burst allowance; there is no daily quota. The transaction must already be mined — to trace a transaction you have not yet sent, simulate it first.

One positional parameter.

The result is an array of action traces. The first entry (with an empty traceAddress) is the top-level call; subsequent entries are internal frames, ordered by their position in the call tree.

A frame that failed has its result replaced by an error string and omits the result object — for example "error": "Reverted".

See the shared error envelope reference for the full error object shape and handling guidance. An unknown or not-yet-mined txHash returns an empty result array rather than an error.

JavaScript (fetch)

const res = await fetch("https://api.triport.io/v1/eth", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.TRIPORT_API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    jsonrpc: "2.0",
    id: 1,
    method: "trace_transaction",
    params: ["0x5b8d2a3c9f1e7b04c6f2a1d8e3047b9a6c1f0e2d4b8a7c5e9f3a1d2c4b6e8f0a"],
  }),
});


const { result } = await res.json();
for (const t of result) {
  console.log(t.traceAddress.join("."), t.type, t.action.to, t.result?.gasUsed);
}

TypeScript SDK (@triport/sdk)

import { Triport } from "@triport/sdk";


const triport = new Triport({ apiKey: process.env.TRIPORT_API_KEY! });


const traces = await triport.eth.request("trace_transaction", [
  "0x5b8d2a3c9f1e7b04c6f2a1d8e3047b9a6c1f0e2d4b8a7c5e9f3a1d2c4b6e8f0a",
]);


console.log(`${traces.length} frames`);

Python (triport-sdk)

import os
from triport import Triport


triport = Triport(api_key=os.environ["TRIPORT_API_KEY"])


traces = triport.eth.request(
    "trace_transaction",
    ["0x5b8d2a3c9f1e7b04c6f2a1d8e3047b9a6c1f0e2d4b8a7c5e9f3a1d2c4b6e8f0a"],
)
for t in traces:
    print(t["traceAddress"], t["type"], t["action"].get("to"), t.get("error"))

• Flat vs. nested. trace_transaction returns a flat, value-oriented list; if you want a nested call tree or opcode-level detail instead, use debug_traceTransaction with callTracer or the struct logger.
• Reconstructing the tree. Rebuild the hierarchy from traceAddress: an entry with traceAddress: [0, 2] is the third child of the first child of the root. subtraces tells you how many direct children to expect for each frame.
• Internal ETH transfers. Sum the action.value of every frame to account for all ETH movement, including transfers made by internal calls that eth_getTransactionReceipt does not expose.
• To trace every transaction in a block instead of one, use the block-level trace methods; to filter traces across a range of blocks by address, use trace_filter.