> ## Documentation Index
> Fetch the complete documentation index at: https://docs.chainstack.com/llms.txt
> Use this file to discover all available pages before exploring further.

# debug_traceCallMany | Ethereum

> Ethereum API method that executes a list of bundles and returns an execution trace for each call, without creating transactions on the blockchain.

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](/reference/ethereum-ethcall) batched across multiple transactions, but it returns detailed execution traces, making it invaluable for debugging complex multi-transaction interactions.

<Note>
  Learn how to [deploy a node](/docs/debug-and-trace-apis#ethereum) with the debug and trace API methods enabled.
</Note>

## 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](/reference/ethereum-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`.

<Note>
  Find the complete [list of available native tracers](/reference/ethereum-debug-trace-rpc-methods#pre-built-native-tracers) in the debug and trace overview.
</Note>

### 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:

```json muxTracer config theme={"system"}
{
  "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.


## OpenAPI

````yaml openapi/ethereum_node_api/debug_and_trace/debug_traceCallMany.json POST /0a9d79d93fb2f4a4b1e04695da2b77a7
openapi: 3.0.0
info:
  title: Ethereum Node API
  version: 1.0.0
  description: This is an API for interacting with an Ethereum node.
servers:
  - url: https://nd-422-757-666.p2pify.com
security: []
paths:
  /0a9d79d93fb2f4a4b1e04695da2b77a7:
    post:
      tags:
        - Ethereum Operations
      summary: debug_traceCallMany
      operationId: traceCallMany
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              properties:
                jsonrpc:
                  type: string
                  default: '2.0'
                method:
                  type: string
                  default: debug_traceCallMany
                id:
                  type: integer
                  default: 1
                params:
                  type: array
                  description: >-
                    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.
                  default:
                    - - transactions:
                          - from: '0x1985EA6E9c68E1C272d8209f3B478AC2Fdb25c87'
                            to: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48'
                            gas: '0xf4240'
                            gasPrice: '0x7896e72a'
                            data: >-
                              0xa9059cbb000000000000000000000000bc0E63965946815d105E7591407704e6e1964E590000000000000000000000000000000000000000000000000000000005f5e100
                    - blockNumber: latest
                    - tracer: muxTracer
                      tracerConfig:
                        callTracer:
                          onlyTopCall: true
                          withLog: false
                        prestateTracer:
                          diffMode: true
      responses:
        '200':
          description: >-
            Detailed execution traces for each call in each bundle. With
            muxTracer, every trace object is keyed by the name of each
            sub-tracer.
          content:
            application/json:
              schema:
                type: object
                properties:
                  jsonrpc:
                    type: string
                  id:
                    type: integer
                  result:
                    type: array
                    description: >-
                      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).
                    items:
                      type: array
                      items:
                        type: object

````