trace_transaction

trace_transaction replays one transaction that has already been included in a block and returns its execution as a flat list of Parity-style trace frames — one entry per internal call (call, create, suicide, reward), each tagged with its position in the call tree. It is the most convenient method for single-transaction forensic analysis: MEV path reconstruction, internal token-transfer tracing, and revert diagnosis without having to pull and walk a whole block.

Compared to its siblings, trace_transaction is the lightest of the block-scoped trace methods — it returns only the frames for one transaction, so it is far cheaper than trace_block (the full-block call tree) or trace_replayBlockTransactions (full block replay with state diffs), yet richer than eth_getTransactionReceipt, which gives you only the top-level result and logs.

This is a trace-namespace (Parity) method available on the Pro tier and above. It is rate limited per tier (3 RPS on Pro, 10 RPS on Business) with a short burst allowance; there is no daily quota. If the hash does not correspond to a mined transaction — unknown, or still pending in the mempool — the method returns null rather than an error.

One positional parameter.

The result is an array of trace frames, ordered by traceAddress (execution order). A simple transfer plus one internal call looks like this:

For an unknown or pending transaction, the result is null:

{ "jsonrpc": "2.0", "id": 1, "result": null }

Note that an unknown or pending transaction is not an error — it returns a null result with HTTP 200. See the shared error envelope reference for the full error object shape and handling guidance.

JavaScript (fetch)

const res = await fetch("https://api.triport.io/v1/polygon", {
  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: ["0x3a1f2b9c8d7e6f5a4b3c2d1e0f9a8b7c6d5e4f3a2b1c0d9e8f7a6b5c4d3e2f1a"],
  }),
});


const { result } = await res.json();
if (result === null) {
  console.log("transaction not found (unknown or pending)");
} else {
  console.log(`${result.length} trace frames`);
}

TypeScript SDK (@triport/sdk)

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


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


const frames = await triport.polygon.request("trace_transaction", [
  "0x3a1f2b9c8d7e6f5a4b3c2d1e0f9a8b7c6d5e4f3a2b1c0d9e8f7a6b5c4d3e2f1a",
]);


for (const f of frames ?? []) {
  console.log(f.type, f.traceAddress.join("."), f.action.from, "→", f.action.to);
}

Python (triport-sdk)

import os
from triport import Triport


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


frames = triport.polygon.request(
    "trace_transaction",
    ["0x3a1f2b9c8d7e6f5a4b3c2d1e0f9a8b7c6d5e4f3a2b1c0d9e8f7a6b5c4d3e2f1a"],
)


if frames is None:
    print("transaction not found (unknown or pending)")
else:
    print(f"{len(frames)} trace frames")

• Parity shape, not Geth. trace_transaction returns the flat Parity trace format (frames keyed by traceAddress), which differs from the nested callTracer tree returned by Geth-style debug methods. If your tooling expects the Geth shape, reach for the debug namespace instead; if you index both, normalise one format to the other.
• Bor quirk. Polygon's Bor client can map a frame's callType slightly differently from a vanilla Geth/Parity node (for example call vs delegatecall for proxy dispatch). Handle both when reconstructing call trees.
• null means not found. A null result is the expected answer for a hash that is unknown or still pending — poll again once the transaction is mined rather than treating it as a failure.
• Related methods. For the full call tree of every transaction in a block, use trace_block; for a range query across many blocks, use trace_filter; to simulate a not-yet-sent transaction, use trace_call. See the Polygon RPC overview for the full trace namespace.