> For a complete page index, fetch https://docs.conduit.xyz/llms.txt

# eth_callMany

POST https://rpc.plume.org/YOUR_API_KEY
Content-Type: application/json

**Availability:** Supported on Reth-based (op-reth) endpoints only. Geth- and Nitro-based endpoints return `-32601 method not found`.

Runs one or more bundles of `eth_call`-style calls against a chosen block state. Calls run in order and each call sees the state changes of the calls before it, so you can simulate dependent calls (for example, an approval followed by a swap) in one request.

⚡ Compute Units: [100 CU](https://docs.conduit.xyz/rpc-nodes/information/compute-units)

Reference: https://docs.conduit.xyz/rpc-nodes/json-rpc-reference/eth-call-many

## Request

### Body (application/json)

This endpoint expects an object.

- `bundles` (list of EthCallManyParamBundlesItems, required) — Ordered list of bundles of call objects.
- `stateContext` (eth_callMany_Param_stateContext, required) — Block state to execute against.
- `stateOverrides` (StateOverride, optional) — Optional state overrides applied before execution.

## Response

### 200

One array per bundle, with one entry per call. Each entry has `value` (return data) on success or `error` on failure.

- `list of list of EthCallManyResultItemsItems`

## Types

### EthCallManyParamBundlesItems

- `transactions` (list of CallObject, required)
- `blockOverride` (BlockOverride, optional) — Block-header field overrides applied during simulation. All fields optional. Forwarded to the backend as-is; the backend honors them during execution.

### eth_callMany_Param_stateContext

Where to execute the bundles. `blockNumber` selects the block state; `transactionIndex` selects the position within that block (`-1` = after all transactions).

- `blockNumber` (BlockNumberOrTagOrHash, optional)
- `transactionIndex` (integer, optional) — Transaction index within the block to execute after; `-1` executes on top of the full block.

### StateOverride

- `balance` (string, optional) — Override the account's balance (wei, hex-encoded).
- `nonce` (string, optional) — Override the account's nonce.
- `code` (string, optional) — Override the account's contract code (raw bytes, hex-encoded).
- `state` (map from string to string, optional) — Replace the account's storage entirely. Map of 32-byte slot key to 32-byte value (both hex). Any slot not listed reads as zero.
- `stateDiff` (map from string to string, optional) — Overlay specific storage slots without clearing the rest. Map of 32-byte slot key to 32-byte value.

### EthCallManyResultItemsItems

- `value` (string, optional)
- `error` (string, optional)

### CallObject

A transaction call object. All fields are optional. Both `data` and `input` are accepted for backwards compatibility — `input` is the canonical field per the Ethereum execution spec.

- `from` (string, optional) — 20-byte sender address (optional)
- `to` (string, optional) — 20-byte target address (optional for contract creation)
- `gas` (string, optional) — Gas limit as hex-encoded integer (optional)
- `gasPrice` (string, optional) — Legacy gas price in wei as hex-encoded integer (optional)
- `maxFeePerGas` (string, optional) — EIP-1559 max total fee per gas in wei as hex-encoded integer (optional)
- `maxPriorityFeePerGas` (string, optional) — EIP-1559 max miner tip per gas in wei as hex-encoded integer (optional)
- `maxFeePerBlobGas` (string, optional) — EIP-4844 max fee per blob gas in wei as hex-encoded integer (optional)
- `value` (string, optional) — Value in wei as hex-encoded integer (optional)
- `data` (string, optional) — ABI-encoded call data, hex-encoded (optional). Alias for `input`; prefer `input` for new clients.
- `input` (string, optional) — ABI-encoded call data, hex-encoded (optional). Canonical name per Ethereum execution spec; alias of `data`.
- `nonce` (string, optional) — Sender nonce as hex-encoded integer (optional, ignored by `eth_call` but accepted)
- `type` (string, optional) — Transaction type as hex-encoded byte (optional): 0x0 legacy, 0x1 EIP-2930 access list, 0x2 EIP-1559, 0x3 EIP-4844 blob, 0x4 EIP-7702 authorization
- `chainId` (string, optional) — Chain ID as hex-encoded integer (optional)
- `accessList` (list of CallObjectAccessListItems, optional) — EIP-2930 access list (optional). Pre-declaring storage slots the transaction will touch reduces gas cost.
- `blobs` (list of string, optional) — EIP-4844 blob data, raw 128KB blobs as hex-encoded bytes (optional). Typically only used by builder/sequencer code paths.
- `blobVersionedHashes` (list of string, optional) — EIP-4844 versioned hashes of blob commitments (optional). One hash per blob.
- `authorizationList` (list of CallObjectAuthorizationListItems, optional) — EIP-7702 authorization list (optional). Each entry is a signed authorization tuple.

### BlockOverride

Block-header field overrides applied during simulation. All fields optional. Forwarded to the backend as-is; the backend honors them during execution.

- `number` (string, optional) — Override block number.
- `difficulty` (string, optional) — Override block difficulty (pre-Merge concept; ignored on post-Merge chains).
- `time` (string, optional) — Override block timestamp (Unix seconds).
- `gasLimit` (string, optional) — Override block gas limit.
- `feeRecipient` (string, optional) — Override block fee recipient (formerly coinbase / miner).
- `prevRandao` (string, optional) — Override prevRandao (post-Merge replacement for difficulty).
- `baseFeePerGas` (string, optional) — Override block base fee per gas.
- `blobBaseFee` (string, optional) — Override block blob base fee (EIP-4844).
- `beaconRoot` (string, optional) — Override the EIP-4788 parent beacon block root.
- `withdrawals` (list of Withdrawal, optional) — Override the block's withdrawals (EIP-4895).

### BlockNumberOrTagOrHash

- block tag: enum
  - Allowed values: `latest`, `earliest`, `pending`, `finalized`, `safe`
- block number: string
- block hash: string

### CallObjectAccessListItems

- `address` (string, required)
- `storageKeys` (list of string, required)

### CallObjectAuthorizationListItems

- `chainId` (string, required)
- `address` (string, required)
- `nonce` (string, required)
- `yParity` (string, required)
- `r` (string, required)
- `s` (string, required)

### Withdrawal

A validator withdrawal object, as introduced by EIP-4895 (Shanghai)

- `index` (string, required) — Monotonically increasing withdrawal index, hex-encoded
- `validatorIndex` (string, required) — Index of the validator that generated the withdrawal, hex-encoded
- `address` (string, required) — 20-byte recipient address for the withdrawn ether
- `amount` (string, required) — Withdrawal amount in gwei, hex-encoded

## Examples

**Request**

```json
[
  [
    {
      "transactions": [
        {
          "data": "0x70a082310000000000000000000000005950baf9a858e3ea17fd6e753d3ac6f3e9152387",
          "from": "0x5950baf9a858e3ea17fd6e753d3ac6f3e9152387",
          "to": "0x4e742319f6b0fec4afa504fc8ed3ceab0fb751a2"
        }
      ]
    }
  ],
  {
    "blockNumber": "0x1053d01",
    "transactionIndex": -1
  }
]
```

**Response**

```json
{
  "id": "1",
  "jsonrpc": "2.0",
  "result": [
    [
      {
        "value": "0x0000000000000000000000000000000000000000000000000000000000000000"
      }
    ]
  ]
}
```

**SDK Code**

```python
import requests

url = "https://rpc.plume.org/YOUR_API_KEY"

payload = [
    [{ "transactions": [
                {
                    "data": "0x70a082310000000000000000000000005950baf9a858e3ea17fd6e753d3ac6f3e9152387",
                    "from": "0x5950baf9a858e3ea17fd6e753d3ac6f3e9152387",
                    "to": "0x4e742319f6b0fec4afa504fc8ed3ceab0fb751a2"
                }
            ] }],
    {
        "blockNumber": "0x1053d01",
        "transactionIndex": -1
    }
]
headers = {"Content-Type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())
```

```javascript
const url = 'https://rpc.plume.org/YOUR_API_KEY';
const options = {
  method: 'POST',
  headers: {'Content-Type': 'application/json'},
  body: '[[{"transactions":[{"data":"0x70a082310000000000000000000000005950baf9a858e3ea17fd6e753d3ac6f3e9152387","from":"0x5950baf9a858e3ea17fd6e753d3ac6f3e9152387","to":"0x4e742319f6b0fec4afa504fc8ed3ceab0fb751a2"}]}],{"blockNumber":"0x1053d01","transactionIndex":-1}]'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go
package main

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

func main() {

	url := "https://rpc.plume.org/YOUR_API_KEY"

	payload := strings.NewReader("[\n  [\n    {\n      \"transactions\": [\n        {\n          \"data\": \"0x70a082310000000000000000000000005950baf9a858e3ea17fd6e753d3ac6f3e9152387\",\n          \"from\": \"0x5950baf9a858e3ea17fd6e753d3ac6f3e9152387\",\n          \"to\": \"0x4e742319f6b0fec4afa504fc8ed3ceab0fb751a2\"\n        }\n      ]\n    }\n  ],\n  {\n    \"blockNumber\": \"0x1053d01\",\n    \"transactionIndex\": -1\n  }\n]")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("Content-Type", "application/json")

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

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

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby
require 'uri'
require 'net/http'

url = URI("https://rpc.plume.org/YOUR_API_KEY")

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

request = Net::HTTP::Post.new(url)
request["Content-Type"] = 'application/json'
request.body = "[\n  [\n    {\n      \"transactions\": [\n        {\n          \"data\": \"0x70a082310000000000000000000000005950baf9a858e3ea17fd6e753d3ac6f3e9152387\",\n          \"from\": \"0x5950baf9a858e3ea17fd6e753d3ac6f3e9152387\",\n          \"to\": \"0x4e742319f6b0fec4afa504fc8ed3ceab0fb751a2\"\n        }\n      ]\n    }\n  ],\n  {\n    \"blockNumber\": \"0x1053d01\",\n    \"transactionIndex\": -1\n  }\n]"

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

```java
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://rpc.plume.org/YOUR_API_KEY")
  .header("Content-Type", "application/json")
  .body("[\n  [\n    {\n      \"transactions\": [\n        {\n          \"data\": \"0x70a082310000000000000000000000005950baf9a858e3ea17fd6e753d3ac6f3e9152387\",\n          \"from\": \"0x5950baf9a858e3ea17fd6e753d3ac6f3e9152387\",\n          \"to\": \"0x4e742319f6b0fec4afa504fc8ed3ceab0fb751a2\"\n        }\n      ]\n    }\n  ],\n  {\n    \"blockNumber\": \"0x1053d01\",\n    \"transactionIndex\": -1\n  }\n]")
  .asString();
```

```php
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://rpc.plume.org/YOUR_API_KEY', [
  'body' => '[
  [
    {
      "transactions": [
        {
          "data": "0x70a082310000000000000000000000005950baf9a858e3ea17fd6e753d3ac6f3e9152387",
          "from": "0x5950baf9a858e3ea17fd6e753d3ac6f3e9152387",
          "to": "0x4e742319f6b0fec4afa504fc8ed3ceab0fb751a2"
        }
      ]
    }
  ],
  {
    "blockNumber": "0x1053d01",
    "transactionIndex": -1
  }
]',
  'headers' => [
    'Content-Type' => 'application/json',
  ],
]);

echo $response->getBody();
```

```csharp
using RestSharp;

var client = new RestClient("https://rpc.plume.org/YOUR_API_KEY");
var request = new RestRequest(Method.POST);
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "[\n  [\n    {\n      \"transactions\": [\n        {\n          \"data\": \"0x70a082310000000000000000000000005950baf9a858e3ea17fd6e753d3ac6f3e9152387\",\n          \"from\": \"0x5950baf9a858e3ea17fd6e753d3ac6f3e9152387\",\n          \"to\": \"0x4e742319f6b0fec4afa504fc8ed3ceab0fb751a2\"\n        }\n      ]\n    }\n  ],\n  {\n    \"blockNumber\": \"0x1053d01\",\n    \"transactionIndex\": -1\n  }\n]", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift
import Foundation

let headers = ["Content-Type": "application/json"]
let parameters = [
  [["transactions": [
        [
          "data": "0x70a082310000000000000000000000005950baf9a858e3ea17fd6e753d3ac6f3e9152387",
          "from": "0x5950baf9a858e3ea17fd6e753d3ac6f3e9152387",
          "to": "0x4e742319f6b0fec4afa504fc8ed3ceab0fb751a2"
        ]
      ]]],
  [
    "blockNumber": "0x1053d01",
    "transactionIndex": -1
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://rpc.plume.org/YOUR_API_KEY")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```