Skip to main content
POST
/
0a9d79d93fb2f4a4b1e04695da2b77a7
debug_traceCallMany
curl --request POST \
  --url https://nd-422-757-666.p2pify.com/0a9d79d93fb2f4a4b1e04695da2b77a7 \
  --header 'Content-Type: application/json' \
  --data '
{
  "jsonrpc": "2.0",
  "method": "debug_traceCallMany",
  "id": 1,
  "params": [
    [
      {
        "transactions": [
          {
            "from": "0x1985EA6E9c68E1C272d8209f3B478AC2Fdb25c87",
            "to": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
            "gas": "0xf4240",
            "gasPrice": "0x7896e72a",
            "data": "0xa9059cbb000000000000000000000000bc0E63965946815d105E7591407704e6e1964E590000000000000000000000000000000000000000000000000000000005f5e100"
          }
        ]
      }
    ],
    {
      "blockNumber": "latest"
    },
    {
      "tracer": "muxTracer",
      "tracerConfig": {
        "callTracer": {
          "onlyTopCall": true,
          "withLog": false
        },
        "prestateTracer": {
          "diffMode": true
        }
      }
    }
  ]
}
'
{
  "jsonrpc": "<string>",
  "id": 123,
  "result": [
    [
      {}
    ]
  ]
}
Ethereum API method that executes one or more bundles—each a list of transactions—against a given block and returns an execution trace for each call, without creating transactions on the blockchain. Calls within a bundle execute in sequence, so each call sees the state changes made by the calls before it. This method is akin to eth_call batched across multiple transactions, but it returns detailed execution traces, making it invaluable for debugging complex multi-transaction interactions.
Learn how to deploy a node with the debug and trace API methods enabled.
Get your own node endpoint todayStart for free and get your app to production levels immediately. No credit card required.You can sign up with your GitHub, X, Google, or Microsoft account.

​
Parameters

debug_traceCallMany takes three positional parameters:
  • array — a list of bundles to execute. Each bundle is an object with:
    • transactions — an array of transaction call objects. Each object accepts the same fields as debug_traceCall: from (optional), to, gas, gasPrice, value, and data.
    • blockOverrides — (optional) an object that overrides fields of the execution block header, such as number, time, or baseFeePerGas.
  • object — the simulation context that pins where the bundles execute:
    • blockNumber — the block number or tag (for example, latest) to execute against.
    • transactionIndex — (optional) the index within the block at which to start; -1 runs after all transactions in the block.
  • object — (optional) the trace configuration. Set tracer to one of the native tracers and pass tracer-specific options in tracerConfig.
Find the complete list of available native tracers in the debug and trace overview.

​
Combining tracers with muxTracer

muxTracer runs several native tracers in a single pass, which is the most efficient way to collect more than one trace type for a bundle. Pass a tracerConfig object keyed by tracer name, and each tracer’s result is returned under its own key:
muxTracer config
{
  "tracer": "muxTracer",
  "tracerConfig": {
    "callTracer": {
      "onlyTopCall": true,
      "withLog": false
    },
    "prestateTracer": {
      "diffMode": true
    }
  }
}

​
Response

  • result — an array with one entry per bundle. Each entry is an array holding one trace per transaction in the bundle, in execution order. When muxTracer is used, each trace is an object keyed by tracer name—for example, callTracer and prestateTracer—each holding that tracer’s output.

​
Use case

debug_traceCallMany is essential for:
  • Simulating a sequence of dependent transactions—such as an approval followed by a swap—and inspecting how each call changes state before committing anything on-chain.
  • Forensic analysis of transaction bundles, where you need both the call tree and the prestate diff in one round trip via muxTracer.
  • MEV and risk tooling that pre-screens bundles against the current chain state.

Body

application/json
​
jsonrpc
string
default:2.0
​
method
string
default:debug_traceCallMany
​
id
integer
default:1
​
params
array

An array with three elements: the bundles to execute, the simulation context, and the trace configuration. The trace configuration below uses muxTracer to run callTracer and prestateTracer in a single pass.

Response

200 - application/json

Detailed execution traces for each call in each bundle. With muxTracer, every trace object is keyed by the name of each sub-tracer.

​
jsonrpc
string
​
id
integer
​
result
object[][]

One array per bundle; each inner array holds one trace object per transaction. With muxTracer, each trace object is keyed by tracer name (for example, callTracer and prestateTracer).

Last modified on June 13, 2026