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

# eth_call | Monad

> Monad API method that executes a new message call immediately without creating a transaction on the blockchain. Monad via Chainstack.

Monad API method that executes a new message call immediately without creating a transaction on the blockchain. This is useful for reading data from smart contracts or simulating transactions.

<Note>
  **Monad-specific behavior**:

  * State is available only for a rolling window of recent blocks, several days long, on every node including Archive nodes. For a block older than that window, the call returns `-32602` `Block requested not found`. See the Monad note on [Networks](/docs/protocols-networks).
  * Does not accept EIP-4844 (blob) transaction type, as EIP-4844 is not supported on Monad.
</Note>

<Note>
  When called against a block older than the latest \~128 blocks, this method is treated as an archive request (2 RUs instead of 1 RU). See [request units](/docs/request-units#evm-methods-affected-by-block-age).
</Note>

## Parameters

* `object` — the transaction call object:
  * `from` (optional) — address the transaction is sent from
  * `to` — address the transaction is directed to
  * `gas` (optional) — gas provided for the call
  * `gasPrice` (optional) — gas price for the call
  * `value` (optional) — value sent with the call
  * `data` (optional) — hash of the method signature and encoded parameters
* `quantity or tag` — integer block number, or the string `latest`, `earliest`, or `pending`

### State override (optional)

`eth_call` accepts an optional third parameter: a state override set that changes account state for this call only. Nothing is written to the chain. The set is an object keyed by account address, and each address can override:

* `balance` — the account balance in wei, hex-encoded
* `nonce` — the account nonce, hex-encoded
* `code` — the bytecode to run at the address
* `state` — storage slot values that replace the account's entire storage
* `stateDiff` — storage slot values to change, keeping the rest of the storage

This example puts bytecode that returns `42` at an unused address, then calls that address:

```bash theme={"system"}
curl --request POST \
  --url CHAINSTACK_NODE_URL \
  --header 'Content-Type: application/json' \
  --data '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "eth_call",
    "params": [
      { "to": "0x00000000000000000000000000000000c0ffee42", "data": "0x" },
      "latest",
      { "0x00000000000000000000000000000000c0ffee42": { "code": "0x602a60005260206000f3" } }
    ]
  }'
```

```json theme={"system"}
{
  "jsonrpc": "2.0",
  "id": 1,
  "result": "0x000000000000000000000000000000000000000000000000000000000000002a"
}
```

## Response

* `result` — the return value of the executed contract call.

## `eth_call` code examples

<CodeGroup>
  ```javascript ethers.js theme={"system"}
  const { ethers } = require("ethers");

  const provider = new ethers.JsonRpcProvider("CHAINSTACK_NODE_URL");

  async function callContract() {
    // Call name() on Wrapped Monad (WMON) contract
    const result = await provider.call({
      to: "0xFb8bf4c1CC7a94c73D209a149eA2AbEa852BC541",
      data: "0x06fdde03" // name()
    });
    console.log(result);
  }

  callContract();
  ```

  ```python web3.py theme={"system"}
  from web3 import Web3

  node_url = "CHAINSTACK_NODE_URL"

  web3 = Web3(Web3.HTTPProvider(node_url))

  # Call name() on Wrapped Monad (WMON) contract
  result = web3.eth.call({
      'to': '0xFb8bf4c1CC7a94c73D209a149eA2AbEa852BC541',
      'data': '0x06fdde03' # name()
  })
  print(result.hex())
  ```
</CodeGroup>

## Use case

A practical use case for `eth_call` is reading data from smart contracts, such as token balances, contract state variables, or simulating complex transactions before sending them.


## OpenAPI

````yaml openapi/monad_node_api/execute_transactions/eth_call.json POST /
openapi: 3.0.0
info:
  title: Monad Node API
  version: 1.0.0
  description: This is an API for interacting with a Monad node.
servers:
  - url: https://monad-testnet.core.chainstack.com/9c5b265f20b3ea5df4f54f70eb74b800
security: []
paths:
  /:
    post:
      tags:
        - Executing transactions
      summary: eth_call
      operationId: eth_call
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              properties:
                id:
                  type: integer
                  default: 1
                jsonrpc:
                  type: string
                  default: '2.0'
                method:
                  type: string
                  default: eth_call
                params:
                  type: array
                  items:
                    anyOf:
                      - type: object
                        properties:
                          to:
                            type: string
                          data:
                            type: string
                      - type: string
                  default:
                    - to: '0xFb8bf4c1CC7a94c73D209a149eA2AbEa852BC541'
                      data: '0x06fdde03'
                    - latest
      responses:
        '200':
          description: The return value of the executed contract call.
          content:
            application/json:
              schema:
                type: object
                properties:
                  jsonrpc:
                    type: string
                  id:
                    type: integer
                  result:
                    type: string

````