MONAD WSS API

v1.0.0

Base URL

wss://monad.nownodes.io/wss/{apiKey}NOWNodes MONAD (Ethereum L1) WSS endpoint. Replace {apiKey} with your NOWNodes API key - it is passed as the last path segment of the WebSocket URL.

WebSocket (WSS) interface of the NOWNodes MONAD endpoint: wss://monad.nownodes.io/wss/{apiKey}. Connect with your NOWNodes API key as the last path segment of the URL, then send JSON-RPC 2.0 requests as text messages; responses and subscription notifications arrive on the same connection. Every documented method is one operation below (the /wss/{apiKey} (method) paths are mnemonics for the single WebSocket message channel, not separate HTTP routes).

Method set: subscriptions (eth_subscribe / eth_unsubscribe with newHeads, logs, newPendingTransactions and minedTransactions event streams), chain and status, gas and fees (including EIP-1559 fee history and priority fee), blocks, transactions and receipts, account state (balance, code, storage, call, proofs, access lists), filters and logs, transaction signing and broadcast, and node/network introspection (net_*, web3_*).

Authentication

wssApiKeyapiKey

NOWNodes API key passed as the last path segment of the WebSocket URL (wss://monad.nownodes.io/wss/{apiKey}). Modeled as a query-parameter key because OpenAPI has no dedicated path-position API key; on the wire the key is part of the URL path. The key must not be published in shared examples.

API Key: apiKey in query

WSS

Subscriptions

Pub/sub event streams (newHeads, logs, newPendingTransactions, minedTransactions).

Subscribe to event streams (newHeads, logs, newPendingTransactions, minedTransactions).

POST

wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_subscribe)

Authorizations

ApiKeyAuthApiKeyAuth

apiKey string

NOWNodes API key passed in the api-key header.

Starts a subscription to one of the event types: newHeads (new block headers), logs (with an optional filter object {address, topics}), newPendingTransactions (pending transaction hashes) or minedTransactions (transaction objects as they are mined). The server answers with a subscription id and then pushes eth_subscription notifications carrying that id. Only available on WebSocket connections.

Sent as a JSON text message over the WebSocket connection wss://monad.nownodes.io/wss/{apiKey}.

Body

application/json

WebSocket request envelope for eth_subscribe, sent as a JSON text message.

WebSocket text-message request envelope sent over the single WSS connection.

jsonrpcstringrequired

JSON-RPC protocol version.

methodstringrequired

JSON-RPC method name.

paramsarray | object

Method parameters (array or object); omit for parameterless methods.

idinteger | string

Client-chosen request identifier echoed in the response.

Parameters

apiKeystringrequiredpath

NOWNodes API key - the last path segment of the WebSocket URL (wss://monad.nownodes.io/wss/{apiKey}).

Response

200OK

Response delivered on the same WebSocket connection. JSON-RPC errors arrive as regular messages (no HTTP status change); subscription pushes arrive as eth_subscription notifications.

Subscribe to event streams (newHeads, logs, newPendingTransactions, minedTransactions).

curl -X POST 'wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_subscribe)' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_subscribe",
    "id": 2,
    "params": [
      "newHeads"
    ]
  }'

import { JsonRpcProvider } from "ethers";

const provider = new JsonRpcProvider("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_subscribe)");
const result = await provider.send("eth_subscribe", [
  "newHeads"
]);
console.log(result);

require 'eth'
require 'json'
require 'net/http'

uri = URI('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_subscribe)')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
  "jsonrpc": "2.0",
  "method": "eth_subscribe",
  "params": [
    "newHeads"
  ],
  "id": 1
}'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end

puts JSON.parse(response.body)

from web3 import Web3

w3 = Web3(Web3.HTTPProvider("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_subscribe)"))
response = w3.provider.make_request("eth_subscribe", [
  "newHeads"
])
print(response)

import { createPublicClient, http } from "viem";

const client = createPublicClient({
  transport: http("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_subscribe)"),
});

const result = await client.request({
  method: "eth_subscribe",
  params: [
  "newHeads"
],
});

console.log(result);

const endpoint = "wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_subscribe)";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({ jsonrpc: "2.0", method: "eth_subscribe", params: [
  "newHeads"
], id: 1 });
console.log(result);

const response = await fetch('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_subscribe)', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "eth_subscribe",
      "id": 2,
      "params": [
        "newHeads"
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "eth_subscribe",
  "id": 2,
  "params": [
    "newHeads"
  ]
}

response = requests.post('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_subscribe)', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_subscribe)')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "jsonrpc": "2.0",
    "method": "eth_subscribe",
    "id": 2,
    "params": [
      "newHeads"
    ]
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

Request Body

{
  "jsonrpc": "2.0",
  "method": "eth_subscribe",
  "id": 2,
  "params": [
    "newHeads"
  ]
}

200

{
  "jsonrpc": "2.0",
  "id": 2,
  "result": "0x120ac69196e4f4b0aa9fbb251a4addd1"
}

{
  "jsonrpc": "2.0",
  "method": "eth_subscription",
  "params": {
    "subscription": "0x120ac69196e4f4b0aa9fbb251a4addd1",
    "result": {
      "parentHash": "0x36e47e59cd78c9b5d79748e77c79706a0c3fade869d90d2d07a6b1f48f3d0ecf",
      "sha3Uncles": "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347",
      "miner": "0x0000000000000000000000000000000000000000",
      "stateRoot": "0x173d731a33d73bed28b5e46f1f025677706d8805a1f1bd1ea06246106d7b0fe4",
      "transactionsRoot": "0xfd5cbd4b68a0f979bbfa75482c7b99b2ce40bd08025cf569b85338764de6743a",
      "receiptsRoot": "0x6131cb6d400ccbed44e9be6751ad29020b0309c6aa97ace45d4725075eff0d19",
      "logsBloom": "0x413204bc001391c1c922708917002401a300850c00f62404080205021842c02400d200a412a042a6a00048001401401519004335d220d81004bc0a20000690c0882c5182130102106000b1585105844944308dc9ae260230143501080000440186e4c0085248408201101053068488865654078207e94640200010128000300a11010026048048201108000c81088510b2c0dc41bef4a6082600611041849243a411104304a4050000a20003c188016114080209250010258d668801047100489999caa71188010009810136410524441194090d0ce22042250441160a14e1008ae4614a201080244423304020250708060989000410110090305c384410650a",
      "difficulty": "0x0",
      "number": "0x45b3e02",
      "gasLimit": "0x1c9c380",
      "gasUsed": "0x132818f",
      "timestamp": "0x69317b04",
      "extraData": "0x",
      "mixHash": "0x0000000000000000000000000000000000000000000000000000000000000000",
      "nonce": "0x0000000000000000",
      "baseFeePerGas": "0x630e876",
      "blobGasUsed": "0x0",
      "excessBlobGas": "0x0",
      "parentBeaconBlockRoot": "0x0000000000000000000000000000000000000000000000000000000000000000",
      "hash": "0xfb30b8b59f5781e82a23f6031a00533f09c40d569727c868d0725cf90a627369"
    }
  }
}

Cancel an active subscription.

POST

wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_unsubscribe)

Authorizations

ApiKeyAuthApiKeyAuth

apiKey string

NOWNodes API key passed in the api-key header.

Cancels a subscription created with eth_subscribe, passing the subscription id as the first parameter. Returns true when the subscription was active and is now cancelled.

Sent as a JSON text message over the WebSocket connection wss://monad.nownodes.io/wss/{apiKey}.

Body

application/json

WebSocket request envelope for eth_unsubscribe, sent as a JSON text message.

WebSocket text-message request envelope sent over the single WSS connection.

jsonrpcstringrequired

JSON-RPC protocol version.

methodstringrequired

JSON-RPC method name.

paramsarray | object

Method parameters (array or object); omit for parameterless methods.

idinteger | string

Client-chosen request identifier echoed in the response.

Parameters

apiKeystringrequiredpath

NOWNodes API key - the last path segment of the WebSocket URL (wss://monad.nownodes.io/wss/{apiKey}).

Response

200OK

Response delivered on the same WebSocket connection. JSON-RPC errors arrive as regular messages (no HTTP status change); subscription pushes arrive as eth_subscription notifications.

Cancel an active subscription.

curl -X POST 'wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_unsubscribe)' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_unsubscribe",
    "id": 1,
    "params": [
      "0x120ac69196e4f4b0aa9fbb251a4addd1"
    ]
  }'

import { JsonRpcProvider } from "ethers";

const provider = new JsonRpcProvider("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_unsubscribe)");
const result = await provider.send("eth_unsubscribe", [
  "0x120ac69196e4f4b0aa9fbb251a4addd1"
]);
console.log(result);

require 'eth'
require 'json'
require 'net/http'

uri = URI('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_unsubscribe)')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
  "jsonrpc": "2.0",
  "method": "eth_unsubscribe",
  "params": [
    "0x120ac69196e4f4b0aa9fbb251a4addd1"
  ],
  "id": 1
}'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end

puts JSON.parse(response.body)

from web3 import Web3

w3 = Web3(Web3.HTTPProvider("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_unsubscribe)"))
response = w3.provider.make_request("eth_unsubscribe", [
  "0x120ac69196e4f4b0aa9fbb251a4addd1"
])
print(response)

import { createPublicClient, http } from "viem";

const client = createPublicClient({
  transport: http("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_unsubscribe)"),
});

const result = await client.request({
  method: "eth_unsubscribe",
  params: [
  "0x120ac69196e4f4b0aa9fbb251a4addd1"
],
});

console.log(result);

const endpoint = "wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_unsubscribe)";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({ jsonrpc: "2.0", method: "eth_unsubscribe", params: [
  "0x120ac69196e4f4b0aa9fbb251a4addd1"
], id: 1 });
console.log(result);

const response = await fetch('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_unsubscribe)', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "eth_unsubscribe",
      "id": 1,
      "params": [
        "0x120ac69196e4f4b0aa9fbb251a4addd1"
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "eth_unsubscribe",
  "id": 1,
  "params": [
    "0x120ac69196e4f4b0aa9fbb251a4addd1"
  ]
}

response = requests.post('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_unsubscribe)', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_unsubscribe)')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "jsonrpc": "2.0",
    "method": "eth_unsubscribe",
    "id": 1,
    "params": [
      "0x120ac69196e4f4b0aa9fbb251a4addd1"
    ]
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

Request Body

{
  "jsonrpc": "2.0",
  "method": "eth_unsubscribe",
  "id": 1,
  "params": [
    "0x120ac69196e4f4b0aa9fbb251a4addd1"
  ]
}

200

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

Chain & Status

Chain id, block number, sync status.

Returns the configured chain id.

POST

wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_chainId)

Authorizations

ApiKeyAuthApiKeyAuth

apiKey string

NOWNodes API key passed in the api-key header.

Returns the currently configured chain id used in replay-protected (EIP-155) transaction signing. Monad mainnet chain id is 0x8f (143).

Sent as a JSON text message over the WebSocket connection wss://monad.nownodes.io/wss/{apiKey}.

Body

application/json

WebSocket request envelope for eth_chainId, sent as a JSON text message.

WebSocket text-message request envelope sent over the single WSS connection.

jsonrpcstringrequired

JSON-RPC protocol version.

methodstringrequired

JSON-RPC method name.

paramsarray | object

Method parameters (array or object); omit for parameterless methods.

idinteger | string

Client-chosen request identifier echoed in the response.

Parameters

apiKeystringrequiredpath

NOWNodes API key - the last path segment of the WebSocket URL (wss://monad.nownodes.io/wss/{apiKey}).

Response

200OK

Response delivered on the same WebSocket connection. JSON-RPC errors arrive as regular messages (no HTTP status change); subscription pushes arrive as eth_subscription notifications.

Returns the configured chain id.

curl -X POST 'wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_chainId)' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_chainId",
    "id": 1
  }'

import { JsonRpcProvider } from "ethers";

const provider = new JsonRpcProvider("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_chainId)");
const result = await provider.send("eth_chainId", []);
console.log(result);

require 'eth'
require 'json'
require 'net/http'

uri = URI('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_chainId)')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
  "jsonrpc": "2.0",
  "method": "eth_chainId",
  "params": [],
  "id": 1
}'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end

puts JSON.parse(response.body)

from web3 import Web3

w3 = Web3(Web3.HTTPProvider("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_chainId)"))
response = w3.provider.make_request("eth_chainId", [])
print(response)

import { createPublicClient, http } from "viem";

const client = createPublicClient({
  transport: http("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_chainId)"),
});

const result = await client.request({
  method: "eth_chainId",
  params: [],
});

console.log(result);

const endpoint = "wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_chainId)";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({ jsonrpc: "2.0", method: "eth_chainId", params: [], id: 1 });
console.log(result);

const response = await fetch('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_chainId)', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "eth_chainId",
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "eth_chainId",
  "id": 1
}

response = requests.post('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_chainId)', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_chainId)')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "jsonrpc": "2.0",
    "method": "eth_chainId",
    "id": 1
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

Request Body

{
  "jsonrpc": "2.0",
  "method": "eth_chainId",
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": "0x8f"
}

Returns the number of the most recent block.

POST

wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_blockNumber)

Authorizations

ApiKeyAuthApiKeyAuth

apiKey string

NOWNodes API key passed in the api-key header.

Returns the number of the most recent block as a hex string.

Sent as a JSON text message over the WebSocket connection wss://monad.nownodes.io/wss/{apiKey}.

Body

application/json

WebSocket request envelope for eth_blockNumber, sent as a JSON text message.

WebSocket text-message request envelope sent over the single WSS connection.

jsonrpcstringrequired

JSON-RPC protocol version.

methodstringrequired

JSON-RPC method name.

paramsarray | object

Method parameters (array or object); omit for parameterless methods.

idinteger | string

Client-chosen request identifier echoed in the response.

Parameters

apiKeystringrequiredpath

NOWNodes API key - the last path segment of the WebSocket URL (wss://monad.nownodes.io/wss/{apiKey}).

Response

200OK

Response delivered on the same WebSocket connection. JSON-RPC errors arrive as regular messages (no HTTP status change); subscription pushes arrive as eth_subscription notifications.

Returns the number of the most recent block.

curl -X POST 'wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_blockNumber)' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_blockNumber",
    "id": 1,
    "params": []
  }'

import { JsonRpcProvider } from "ethers";

const provider = new JsonRpcProvider("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_blockNumber)");
const result = await provider.send("eth_blockNumber", []);
console.log(result);

require 'eth'
require 'json'
require 'net/http'

uri = URI('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_blockNumber)')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
  "jsonrpc": "2.0",
  "method": "eth_blockNumber",
  "params": [],
  "id": 1
}'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end

puts JSON.parse(response.body)

from web3 import Web3

w3 = Web3(Web3.HTTPProvider("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_blockNumber)"))
response = w3.provider.make_request("eth_blockNumber", [])
print(response)

import { createPublicClient, http } from "viem";

const client = createPublicClient({
  transport: http("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_blockNumber)"),
});

const result = await client.request({
  method: "eth_blockNumber",
  params: [],
});

console.log(result);

const endpoint = "wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_blockNumber)";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({ jsonrpc: "2.0", method: "eth_blockNumber", params: [], id: 1 });
console.log(result);

const response = await fetch('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_blockNumber)', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "eth_blockNumber",
      "id": 1,
      "params": []
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "eth_blockNumber",
  "id": 1,
  "params": []
}

response = requests.post('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_blockNumber)', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_blockNumber)')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "jsonrpc": "2.0",
    "method": "eth_blockNumber",
    "id": 1,
    "params": []
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

Request Body

{
  "jsonrpc": "2.0",
  "method": "eth_blockNumber",
  "id": 1,
  "params": []
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": "0x29d657e"
}

Returns the node sync status.

POST

wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_syncing)

Authorizations

ApiKeyAuthApiKeyAuth

apiKey string

NOWNodes API key passed in the api-key header.

Returns false when the node is fully synced, or a progress object with startingBlock / currentBlock / highestBlock while syncing.

Sent as a JSON text message over the WebSocket connection wss://monad.nownodes.io/wss/{apiKey}.

Body

application/json

WebSocket request envelope for eth_syncing, sent as a JSON text message.

WebSocket text-message request envelope sent over the single WSS connection.

jsonrpcstringrequired

JSON-RPC protocol version.

methodstringrequired

JSON-RPC method name.

paramsarray | object

Method parameters (array or object); omit for parameterless methods.

idinteger | string

Client-chosen request identifier echoed in the response.

Parameters

apiKeystringrequiredpath

NOWNodes API key - the last path segment of the WebSocket URL (wss://monad.nownodes.io/wss/{apiKey}).

Response

200OK

Response delivered on the same WebSocket connection. JSON-RPC errors arrive as regular messages (no HTTP status change); subscription pushes arrive as eth_subscription notifications.

Returns the node sync status.

curl -X POST 'wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_syncing)' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_syncing",
    "id": 1,
    "params": []
  }'

import { JsonRpcProvider } from "ethers";

const provider = new JsonRpcProvider("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_syncing)");
const result = await provider.send("eth_syncing", []);
console.log(result);

require 'eth'
require 'json'
require 'net/http'

uri = URI('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_syncing)')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
  "jsonrpc": "2.0",
  "method": "eth_syncing",
  "params": [],
  "id": 1
}'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end

puts JSON.parse(response.body)

from web3 import Web3

w3 = Web3(Web3.HTTPProvider("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_syncing)"))
response = w3.provider.make_request("eth_syncing", [])
print(response)

import { createPublicClient, http } from "viem";

const client = createPublicClient({
  transport: http("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_syncing)"),
});

const result = await client.request({
  method: "eth_syncing",
  params: [],
});

console.log(result);

const endpoint = "wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_syncing)";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({ jsonrpc: "2.0", method: "eth_syncing", params: [], id: 1 });
console.log(result);

const response = await fetch('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_syncing)', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "eth_syncing",
      "id": 1,
      "params": []
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "eth_syncing",
  "id": 1,
  "params": []
}

response = requests.post('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_syncing)', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_syncing)')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "jsonrpc": "2.0",
    "method": "eth_syncing",
    "id": 1,
    "params": []
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

Request Body

{
  "jsonrpc": "2.0",
  "method": "eth_syncing",
  "id": 1,
  "params": []
}

200

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

Gas & Fees

Gas price, estimates, EIP-1559 fee history.

Returns the current gas price.

POST

wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_gasPrice)

Authorizations

ApiKeyAuthApiKeyAuth

apiKey string

NOWNodes API key passed in the api-key header.

Returns an estimate of the current gas price in wei.

Sent as a JSON text message over the WebSocket connection wss://monad.nownodes.io/wss/{apiKey}.

Body

application/json

WebSocket request envelope for eth_gasPrice, sent as a JSON text message.

WebSocket text-message request envelope sent over the single WSS connection.

jsonrpcstringrequired

JSON-RPC protocol version.

methodstringrequired

JSON-RPC method name.

paramsarray | object

Method parameters (array or object); omit for parameterless methods.

idinteger | string

Client-chosen request identifier echoed in the response.

Parameters

apiKeystringrequiredpath

NOWNodes API key - the last path segment of the WebSocket URL (wss://monad.nownodes.io/wss/{apiKey}).

Response

200OK

Response delivered on the same WebSocket connection. JSON-RPC errors arrive as regular messages (no HTTP status change); subscription pushes arrive as eth_subscription notifications.

Returns the current gas price.

curl -X POST 'wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_gasPrice)' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_gasPrice",
    "id": 1,
    "params": []
  }'

import { JsonRpcProvider } from "ethers";

const provider = new JsonRpcProvider("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_gasPrice)");
const result = await provider.send("eth_gasPrice", []);
console.log(result);

require 'eth'
require 'json'
require 'net/http'

uri = URI('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_gasPrice)')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
  "jsonrpc": "2.0",
  "method": "eth_gasPrice",
  "params": [],
  "id": 1
}'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end

puts JSON.parse(response.body)

from web3 import Web3

w3 = Web3(Web3.HTTPProvider("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_gasPrice)"))
response = w3.provider.make_request("eth_gasPrice", [])
print(response)

import { createPublicClient, http } from "viem";

const client = createPublicClient({
  transport: http("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_gasPrice)"),
});

const result = await client.request({
  method: "eth_gasPrice",
  params: [],
});

console.log(result);

const endpoint = "wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_gasPrice)";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({ jsonrpc: "2.0", method: "eth_gasPrice", params: [], id: 1 });
console.log(result);

const response = await fetch('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_gasPrice)', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "eth_gasPrice",
      "id": 1,
      "params": []
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "eth_gasPrice",
  "id": 1,
  "params": []
}

response = requests.post('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_gasPrice)', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_gasPrice)')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "jsonrpc": "2.0",
    "method": "eth_gasPrice",
    "id": 1,
    "params": []
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

Request Body

{
  "jsonrpc": "2.0",
  "method": "eth_gasPrice",
  "id": 1,
  "params": []
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": "0x5d21dba00"
}

Estimates the gas needed for a transaction.

POST

wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_estimateGas)

Authorizations

ApiKeyAuthApiKeyAuth

apiKey string

NOWNodes API key passed in the api-key header.

Generates and returns an estimate of how much gas is necessary for the transaction to complete. The transaction is not added to the chain; the estimate can exceed the actually used gas.

Sent as a JSON text message over the WebSocket connection wss://monad.nownodes.io/wss/{apiKey}.

Body

application/json

WebSocket request envelope for eth_estimateGas, sent as a JSON text message.

WebSocket text-message request envelope sent over the single WSS connection.

jsonrpcstringrequired

JSON-RPC protocol version.

methodstringrequired

JSON-RPC method name.

paramsarray | object

Method parameters (array or object); omit for parameterless methods.

idinteger | string

Client-chosen request identifier echoed in the response.

Parameters

apiKeystringrequiredpath

NOWNodes API key - the last path segment of the WebSocket URL (wss://monad.nownodes.io/wss/{apiKey}).

Response

200OK

Response delivered on the same WebSocket connection. JSON-RPC errors arrive as regular messages (no HTTP status change); subscription pushes arrive as eth_subscription notifications.

Estimates the gas needed for a transaction.

curl -X POST 'wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_estimateGas)' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_estimateGas",
    "id": 1,
    "params": [
      {
        "to": "0xd46e8dd67c5d32be8058bb8eb970870f07244567"
      },
      "latest"
    ]
  }'

import { JsonRpcProvider } from "ethers";

const provider = new JsonRpcProvider("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_estimateGas)");
const result = await provider.send("eth_estimateGas", [
  {
    "to": "0xd46e8dd67c5d32be8058bb8eb970870f07244567"
  },
  "latest"
]);
console.log(result);

require 'eth'
require 'json'
require 'net/http'

uri = URI('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_estimateGas)')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
  "jsonrpc": "2.0",
  "method": "eth_estimateGas",
  "params": [
    {
      "to": "0xd46e8dd67c5d32be8058bb8eb970870f07244567"
    },
    "latest"
  ],
  "id": 1
}'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end

puts JSON.parse(response.body)

from web3 import Web3

w3 = Web3(Web3.HTTPProvider("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_estimateGas)"))
response = w3.provider.make_request("eth_estimateGas", [
  {
    "to": "0xd46e8dd67c5d32be8058bb8eb970870f07244567"
  },
  "latest"
])
print(response)

import { createPublicClient, http } from "viem";

const client = createPublicClient({
  transport: http("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_estimateGas)"),
});

const result = await client.request({
  method: "eth_estimateGas",
  params: [
  {
    "to": "0xd46e8dd67c5d32be8058bb8eb970870f07244567"
  },
  "latest"
],
});

console.log(result);

const endpoint = "wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_estimateGas)";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({ jsonrpc: "2.0", method: "eth_estimateGas", params: [
  {
    "to": "0xd46e8dd67c5d32be8058bb8eb970870f07244567"
  },
  "latest"
], id: 1 });
console.log(result);

const response = await fetch('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_estimateGas)', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "eth_estimateGas",
      "id": 1,
      "params": [
        {
          "to": "0xd46e8dd67c5d32be8058bb8eb970870f07244567"
        },
        "latest"
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "eth_estimateGas",
  "id": 1,
  "params": [
    {
      "to": "0xd46e8dd67c5d32be8058bb8eb970870f07244567"
    },
    "latest"
  ]
}

response = requests.post('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_estimateGas)', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_estimateGas)')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "jsonrpc": "2.0",
    "method": "eth_estimateGas",
    "id": 1,
    "params": [
      {
        "to": "0xd46e8dd67c5d32be8058bb8eb970870f07244567"
      },
      "latest"
    ]
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

Request Body

{
  "jsonrpc": "2.0",
  "method": "eth_estimateGas",
  "id": 1,
  "params": [
    {
      "to": "0xd46e8dd67c5d32be8058bb8eb970870f07244567"
    },
    "latest"
  ]
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": "0x5208"
}

Returns the current priority fee estimate.

POST

wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_maxPriorityFeePerGas)

Authorizations

ApiKeyAuthApiKeyAuth

apiKey string

NOWNodes API key passed in the api-key header.

Returns a fee per gas that is an estimate of how much can be paid as a priority fee (tip) to get a transaction included in the current block.

Sent as a JSON text message over the WebSocket connection wss://monad.nownodes.io/wss/{apiKey}.

Body

application/json

WebSocket request envelope for eth_maxPriorityFeePerGas, sent as a JSON text message.

WebSocket text-message request envelope sent over the single WSS connection.

jsonrpcstringrequired

JSON-RPC protocol version.

methodstringrequired

JSON-RPC method name.

paramsarray | object

Method parameters (array or object); omit for parameterless methods.

idinteger | string

Client-chosen request identifier echoed in the response.

Parameters

apiKeystringrequiredpath

NOWNodes API key - the last path segment of the WebSocket URL (wss://monad.nownodes.io/wss/{apiKey}).

Response

200OK

Response delivered on the same WebSocket connection. JSON-RPC errors arrive as regular messages (no HTTP status change); subscription pushes arrive as eth_subscription notifications.

Returns the current priority fee estimate.

curl -X POST 'wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_maxPriorityFeePerGas)' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_maxPriorityFeePerGas",
    "id": 1
  }'

import { JsonRpcProvider } from "ethers";

const provider = new JsonRpcProvider("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_maxPriorityFeePerGas)");
const result = await provider.send("eth_maxPriorityFeePerGas", []);
console.log(result);

require 'eth'
require 'json'
require 'net/http'

uri = URI('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_maxPriorityFeePerGas)')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
  "jsonrpc": "2.0",
  "method": "eth_maxPriorityFeePerGas",
  "params": [],
  "id": 1
}'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end

puts JSON.parse(response.body)

from web3 import Web3

w3 = Web3(Web3.HTTPProvider("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_maxPriorityFeePerGas)"))
response = w3.provider.make_request("eth_maxPriorityFeePerGas", [])
print(response)

import { createPublicClient, http } from "viem";

const client = createPublicClient({
  transport: http("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_maxPriorityFeePerGas)"),
});

const result = await client.request({
  method: "eth_maxPriorityFeePerGas",
  params: [],
});

console.log(result);

const endpoint = "wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_maxPriorityFeePerGas)";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({ jsonrpc: "2.0", method: "eth_maxPriorityFeePerGas", params: [], id: 1 });
console.log(result);

const response = await fetch('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_maxPriorityFeePerGas)', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "eth_maxPriorityFeePerGas",
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "eth_maxPriorityFeePerGas",
  "id": 1
}

response = requests.post('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_maxPriorityFeePerGas)', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_maxPriorityFeePerGas)')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "jsonrpc": "2.0",
    "method": "eth_maxPriorityFeePerGas",
    "id": 1
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

Request Body

{
  "jsonrpc": "2.0",
  "method": "eth_maxPriorityFeePerGas",
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": "0x0"
}

Returns historical gas fee information.

POST

wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_feeHistory)

Authorizations

ApiKeyAuthApiKeyAuth

apiKey string

NOWNodes API key passed in the api-key header.

Returns the base fee per gas and gas used ratio for a range of blocks, plus priority fee percentiles when requested. Parameters: blockCount (hex), newestBlock (tag or hex), reward percentiles (array of numbers 0-100, optional).

Sent as a JSON text message over the WebSocket connection wss://monad.nownodes.io/wss/{apiKey}.

Body

application/json

WebSocket request envelope for eth_feeHistory, sent as a JSON text message.

WebSocket text-message request envelope sent over the single WSS connection.

jsonrpcstringrequired

JSON-RPC protocol version.

methodstringrequired

JSON-RPC method name.

paramsarray | object

Method parameters (array or object); omit for parameterless methods.

idinteger | string

Client-chosen request identifier echoed in the response.

Parameters

apiKeystringrequiredpath

NOWNodes API key - the last path segment of the WebSocket URL (wss://monad.nownodes.io/wss/{apiKey}).

Response

200OK

Response delivered on the same WebSocket connection. JSON-RPC errors arrive as regular messages (no HTTP status change); subscription pushes arrive as eth_subscription notifications.

Returns historical gas fee information.

curl -X POST 'wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_feeHistory)' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_feeHistory",
    "id": 1,
    "params": [
      "0x4",
      "latest",
      [
        10,
        50
      ]
    ]
  }'

import { JsonRpcProvider } from "ethers";

const provider = new JsonRpcProvider("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_feeHistory)");
const result = await provider.send("eth_feeHistory", [
  "0x4",
  "latest",
  [
    10,
    50
  ]
]);
console.log(result);

require 'eth'
require 'json'
require 'net/http'

uri = URI('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_feeHistory)')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
  "jsonrpc": "2.0",
  "method": "eth_feeHistory",
  "params": [
    "0x4",
    "latest",
    [
      10,
      50
    ]
  ],
  "id": 1
}'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end

puts JSON.parse(response.body)

from web3 import Web3

w3 = Web3(Web3.HTTPProvider("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_feeHistory)"))
response = w3.provider.make_request("eth_feeHistory", [
  "0x4",
  "latest",
  [
    10,
    50
  ]
])
print(response)

import { createPublicClient, http } from "viem";

const client = createPublicClient({
  transport: http("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_feeHistory)"),
});

const result = await client.request({
  method: "eth_feeHistory",
  params: [
  "0x4",
  "latest",
  [
    10,
    50
  ]
],
});

console.log(result);

const endpoint = "wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_feeHistory)";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({ jsonrpc: "2.0", method: "eth_feeHistory", params: [
  "0x4",
  "latest",
  [
    10,
    50
  ]
], id: 1 });
console.log(result);

const response = await fetch('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_feeHistory)', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "eth_feeHistory",
      "id": 1,
      "params": [
        "0x4",
        "latest",
        [
          10,
          50
        ]
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "eth_feeHistory",
  "id": 1,
  "params": [
    "0x4",
    "latest",
    [
      10,
      50
    ]
  ]
}

response = requests.post('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_feeHistory)', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_feeHistory)')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "jsonrpc": "2.0",
    "method": "eth_feeHistory",
    "id": 1,
    "params": [
      "0x4",
      "latest",
      [
        10,
        50
      ]
    ]
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

Request Body

{
  "jsonrpc": "2.0",
  "method": "eth_feeHistory",
  "id": 1,
  "params": [
    "0x4",
    "latest",
    [
      10,
      50
    ]
  ]
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "oldestBlock": "0x13e2c",
    "baseFeePerGas": [
      "0xa",
      "0xa",
      "0xa",
      "0xa",
      "0xa"
    ],
    "gasUsedRatio": [
      0.1,
      0.1,
      0.1,
      0.4
    ],
    "reward": [
      [
        "0x1",
        "0x2"
      ],
      [
        "0x1",
        "0x2"
      ],
      [
        "0x1",
        "0x2"
      ],
      [
        "0x1",
        "0x2"
      ]
    ]
  }
}

{
  "jsonrpc": "2.0",
  "id": 1,
  "error": {
    "code": -32602,
    "message": "invalid argument 1: hex string without 0x prefix"
  }
}

Blocks

Block lookups and counters.

Returns a block by hash.

POST

wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getBlockByHash)

Authorizations

ApiKeyAuthApiKeyAuth

apiKey string

NOWNodes API key passed in the api-key header.

Returns information about a block by hash. The second parameter controls whether transactions are returned as full objects (true) or hashes (false). Returns null for an unknown hash.

Sent as a JSON text message over the WebSocket connection wss://monad.nownodes.io/wss/{apiKey}.

Body

application/json

WebSocket request envelope for eth_getBlockByHash, sent as a JSON text message.

WebSocket text-message request envelope sent over the single WSS connection.

jsonrpcstringrequired

JSON-RPC protocol version.

methodstringrequired

JSON-RPC method name.

paramsarray | object

Method parameters (array or object); omit for parameterless methods.

idinteger | string

Client-chosen request identifier echoed in the response.

Parameters

apiKeystringrequiredpath

NOWNodes API key - the last path segment of the WebSocket URL (wss://monad.nownodes.io/wss/{apiKey}).

Response

200OK

Response delivered on the same WebSocket connection. JSON-RPC errors arrive as regular messages (no HTTP status change); subscription pushes arrive as eth_subscription notifications.

Returns a block by hash.

curl -X POST 'wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getBlockByHash)' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_getBlockByHash",
    "id": 1,
    "params": [
      "0xdc0818cf78f21a8e70579cb46a43643f78291264dda342ae31049421c82d21ae",
      false
    ]
  }'

import { JsonRpcProvider } from "ethers";

const provider = new JsonRpcProvider("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getBlockByHash)");
const result = await provider.send("eth_getBlockByHash", [
  "0xdc0818cf78f21a8e70579cb46a43643f78291264dda342ae31049421c82d21ae",
  false
]);
console.log(result);

require 'eth'
require 'json'
require 'net/http'

uri = URI('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getBlockByHash)')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
  "jsonrpc": "2.0",
  "method": "eth_getBlockByHash",
  "params": [
    "0xdc0818cf78f21a8e70579cb46a43643f78291264dda342ae31049421c82d21ae",
    false
  ],
  "id": 1
}'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end

puts JSON.parse(response.body)

from web3 import Web3

w3 = Web3(Web3.HTTPProvider("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getBlockByHash)"))
response = w3.provider.make_request("eth_getBlockByHash", [
  "0xdc0818cf78f21a8e70579cb46a43643f78291264dda342ae31049421c82d21ae",
  false
])
print(response)

import { createPublicClient, http } from "viem";

const client = createPublicClient({
  transport: http("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getBlockByHash)"),
});

const result = await client.request({
  method: "eth_getBlockByHash",
  params: [
  "0xdc0818cf78f21a8e70579cb46a43643f78291264dda342ae31049421c82d21ae",
  false
],
});

console.log(result);

const endpoint = "wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getBlockByHash)";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({ jsonrpc: "2.0", method: "eth_getBlockByHash", params: [
  "0xdc0818cf78f21a8e70579cb46a43643f78291264dda342ae31049421c82d21ae",
  false
], id: 1 });
console.log(result);

const response = await fetch('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getBlockByHash)', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "eth_getBlockByHash",
      "id": 1,
      "params": [
        "0xdc0818cf78f21a8e70579cb46a43643f78291264dda342ae31049421c82d21ae",
        false
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "eth_getBlockByHash",
  "id": 1,
  "params": [
    "0xdc0818cf78f21a8e70579cb46a43643f78291264dda342ae31049421c82d21ae",
    false
  ]
}

response = requests.post('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getBlockByHash)', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getBlockByHash)')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "jsonrpc": "2.0",
    "method": "eth_getBlockByHash",
    "id": 1,
    "params": [
      "0xdc0818cf78f21a8e70579cb46a43643f78291264dda342ae31049421c82d21ae",
      false
    ]
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

Request Body

{
  "jsonrpc": "2.0",
  "method": "eth_getBlockByHash",
  "id": 1,
  "params": [
    "0xdc0818cf78f21a8e70579cb46a43643f78291264dda342ae31049421c82d21ae",
    false
  ]
}

200

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

Returns a block by number.

POST

wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getBlockByNumber)

Authorizations

ApiKeyAuthApiKeyAuth

apiKey string

NOWNodes API key passed in the api-key header.

Returns information about a block by block number (hex) or tag (latest, earliest, pending, safe, finalized). The second parameter controls full transactions versus hashes.

Sent as a JSON text message over the WebSocket connection wss://monad.nownodes.io/wss/{apiKey}.

Body

application/json

WebSocket request envelope for eth_getBlockByNumber, sent as a JSON text message.

WebSocket text-message request envelope sent over the single WSS connection.

jsonrpcstringrequired

JSON-RPC protocol version.

methodstringrequired

JSON-RPC method name.

paramsarray | object

Method parameters (array or object); omit for parameterless methods.

idinteger | string

Client-chosen request identifier echoed in the response.

Parameters

apiKeystringrequiredpath

NOWNodes API key - the last path segment of the WebSocket URL (wss://monad.nownodes.io/wss/{apiKey}).

Response

200OK

Response delivered on the same WebSocket connection. JSON-RPC errors arrive as regular messages (no HTTP status change); subscription pushes arrive as eth_subscription notifications.

Returns a block by number.

curl -X POST 'wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getBlockByNumber)' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_getBlockByNumber",
    "id": 1,
    "params": [
      "0x1b4",
      true
    ]
  }'

import { JsonRpcProvider } from "ethers";

const provider = new JsonRpcProvider("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getBlockByNumber)");
const result = await provider.send("eth_getBlockByNumber", [
  "0x1b4",
  true
]);
console.log(result);

require 'eth'
require 'json'
require 'net/http'

uri = URI('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getBlockByNumber)')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
  "jsonrpc": "2.0",
  "method": "eth_getBlockByNumber",
  "params": [
    "0x1b4",
    true
  ],
  "id": 1
}'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end

puts JSON.parse(response.body)

from web3 import Web3

w3 = Web3(Web3.HTTPProvider("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getBlockByNumber)"))
response = w3.provider.make_request("eth_getBlockByNumber", [
  "0x1b4",
  true
])
print(response)

import { createPublicClient, http } from "viem";

const client = createPublicClient({
  transport: http("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getBlockByNumber)"),
});

const result = await client.request({
  method: "eth_getBlockByNumber",
  params: [
  "0x1b4",
  true
],
});

console.log(result);

const endpoint = "wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getBlockByNumber)";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({ jsonrpc: "2.0", method: "eth_getBlockByNumber", params: [
  "0x1b4",
  true
], id: 1 });
console.log(result);

const response = await fetch('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getBlockByNumber)', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "eth_getBlockByNumber",
      "id": 1,
      "params": [
        "0x1b4",
        true
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "eth_getBlockByNumber",
  "id": 1,
  "params": [
    "0x1b4",
    true
  ]
}

response = requests.post('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getBlockByNumber)', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getBlockByNumber)')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "jsonrpc": "2.0",
    "method": "eth_getBlockByNumber",
    "id": 1,
    "params": [
      "0x1b4",
      true
    ]
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

Request Body

{
  "jsonrpc": "2.0",
  "method": "eth_getBlockByNumber",
  "id": 1,
  "params": [
    "0x1b4",
    true
  ]
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "difficulty": "0x0",
    "extraData": "0x",
    "gasLimit": "0x3e4985c",
    "gasUsed": "0xcbec",
    "hash": "0x8ba0b60cee01c4a42e687596808b0332e34c7c2371b768641efe58f89e6c41c2",
    "logsBloom": "0x00000000000000000000000000000000400000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000000000000000000000000000008000000000000000010000000000000000000000000000000000008400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000080002000000000000000000000000000000",
    "miner": "0x0000000000000000000000000000000000000000",
    "mixHash": "0x0000000000000000000000000000000000000000000000000000000000000000",
    "nonce": "0x0000000000000000",
    "number": "0x1b4",
    "parentHash": "0x04d1ccba421361c2ac227fef90be045be530b71fe486612a0250d82e40a6d102",
    "receiptsRoot": "0x3982c4136a5bda4bab50002cc86af568e308e48edae4c4705263d511cd78dc0c",
    "sha3Uncles": "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347",
    "size": "0x510",
    "stateRoot": "0x48a171ad566e60dfce51d37f29a10e22222057accd9bd7ba372461773af09b52",
    "timestamp": "0x5f9b2727",
    "totalDifficulty": "0x0",
    "transactions": [
      "0x88df016429689c079f3b2f6ad39fa052532c56795b733da78a91ebe6a713944b"
    ],
    "transactionsRoot": "0x13be6179c3e234a1da1d93748cd8b035d5e638f43a8ee5ea593dce425f1eb9f4",
    "uncles": [],
    "baseFeePerGas": "0x630e876"
  }
}

Returns the transaction count of a block by hash.

POST

wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getBlockTransactionCountByHash)

Authorizations

ApiKeyAuthApiKeyAuth

apiKey string

NOWNodes API key passed in the api-key header.

Returns the number of transactions in the block matching the given hash (null for an unknown hash).

Sent as a JSON text message over the WebSocket connection wss://monad.nownodes.io/wss/{apiKey}.

Body

application/json

WebSocket request envelope for eth_getBlockTransactionCountByHash, sent as a JSON text message.

WebSocket text-message request envelope sent over the single WSS connection.

jsonrpcstringrequired

JSON-RPC protocol version.

methodstringrequired

JSON-RPC method name.

paramsarray | object

Method parameters (array or object); omit for parameterless methods.

idinteger | string

Client-chosen request identifier echoed in the response.

Parameters

apiKeystringrequiredpath

NOWNodes API key - the last path segment of the WebSocket URL (wss://monad.nownodes.io/wss/{apiKey}).

Response

200OK

Response delivered on the same WebSocket connection. JSON-RPC errors arrive as regular messages (no HTTP status change); subscription pushes arrive as eth_subscription notifications.

Returns the transaction count of a block by hash.

curl -X POST 'wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getBlockTransactionCountByHash)' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_getBlockTransactionCountByHash",
    "id": 1,
    "params": [
      "0xb903239f8543d04b5dc1ba6579132b143087c68db1b2168786408fcbce568238"
    ]
  }'

import { JsonRpcProvider } from "ethers";

const provider = new JsonRpcProvider("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getBlockTransactionCountByHash)");
const result = await provider.send("eth_getBlockTransactionCountByHash", [
  "0xb903239f8543d04b5dc1ba6579132b143087c68db1b2168786408fcbce568238"
]);
console.log(result);

require 'eth'
require 'json'
require 'net/http'

uri = URI('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getBlockTransactionCountByHash)')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
  "jsonrpc": "2.0",
  "method": "eth_getBlockTransactionCountByHash",
  "params": [
    "0xb903239f8543d04b5dc1ba6579132b143087c68db1b2168786408fcbce568238"
  ],
  "id": 1
}'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end

puts JSON.parse(response.body)

from web3 import Web3

w3 = Web3(Web3.HTTPProvider("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getBlockTransactionCountByHash)"))
response = w3.provider.make_request("eth_getBlockTransactionCountByHash", [
  "0xb903239f8543d04b5dc1ba6579132b143087c68db1b2168786408fcbce568238"
])
print(response)

import { createPublicClient, http } from "viem";

const client = createPublicClient({
  transport: http("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getBlockTransactionCountByHash)"),
});

const result = await client.request({
  method: "eth_getBlockTransactionCountByHash",
  params: [
  "0xb903239f8543d04b5dc1ba6579132b143087c68db1b2168786408fcbce568238"
],
});

console.log(result);

const endpoint = "wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getBlockTransactionCountByHash)";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({ jsonrpc: "2.0", method: "eth_getBlockTransactionCountByHash", params: [
  "0xb903239f8543d04b5dc1ba6579132b143087c68db1b2168786408fcbce568238"
], id: 1 });
console.log(result);

const response = await fetch('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getBlockTransactionCountByHash)', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "eth_getBlockTransactionCountByHash",
      "id": 1,
      "params": [
        "0xb903239f8543d04b5dc1ba6579132b143087c68db1b2168786408fcbce568238"
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "eth_getBlockTransactionCountByHash",
  "id": 1,
  "params": [
    "0xb903239f8543d04b5dc1ba6579132b143087c68db1b2168786408fcbce568238"
  ]
}

response = requests.post('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getBlockTransactionCountByHash)', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getBlockTransactionCountByHash)')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "jsonrpc": "2.0",
    "method": "eth_getBlockTransactionCountByHash",
    "id": 1,
    "params": [
      "0xb903239f8543d04b5dc1ba6579132b143087c68db1b2168786408fcbce568238"
    ]
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

Request Body

{
  "jsonrpc": "2.0",
  "method": "eth_getBlockTransactionCountByHash",
  "id": 1,
  "params": [
    "0xb903239f8543d04b5dc1ba6579132b143087c68db1b2168786408fcbce568238"
  ]
}

200

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

Returns the transaction count of a block by number.

POST

wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getBlockTransactionCountByNumber)

Authorizations

ApiKeyAuthApiKeyAuth

apiKey string

NOWNodes API key passed in the api-key header.

Returns the number of transactions in the block matching the given block number.

Sent as a JSON text message over the WebSocket connection wss://monad.nownodes.io/wss/{apiKey}.

Body

application/json

WebSocket request envelope for eth_getBlockTransactionCountByNumber, sent as a JSON text message.

WebSocket text-message request envelope sent over the single WSS connection.

jsonrpcstringrequired

JSON-RPC protocol version.

methodstringrequired

JSON-RPC method name.

paramsarray | object

Method parameters (array or object); omit for parameterless methods.

idinteger | string

Client-chosen request identifier echoed in the response.

Parameters

apiKeystringrequiredpath

NOWNodes API key - the last path segment of the WebSocket URL (wss://monad.nownodes.io/wss/{apiKey}).

Response

200OK

Response delivered on the same WebSocket connection. JSON-RPC errors arrive as regular messages (no HTTP status change); subscription pushes arrive as eth_subscription notifications.

Returns the transaction count of a block by number.

curl -X POST 'wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getBlockTransactionCountByNumber)' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_getBlockTransactionCountByNumber",
    "id": 1,
    "params": [
      "0xe8"
    ]
  }'

import { JsonRpcProvider } from "ethers";

const provider = new JsonRpcProvider("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getBlockTransactionCountByNumber)");
const result = await provider.send("eth_getBlockTransactionCountByNumber", [
  "0xe8"
]);
console.log(result);

require 'eth'
require 'json'
require 'net/http'

uri = URI('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getBlockTransactionCountByNumber)')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
  "jsonrpc": "2.0",
  "method": "eth_getBlockTransactionCountByNumber",
  "params": [
    "0xe8"
  ],
  "id": 1
}'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end

puts JSON.parse(response.body)

from web3 import Web3

w3 = Web3(Web3.HTTPProvider("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getBlockTransactionCountByNumber)"))
response = w3.provider.make_request("eth_getBlockTransactionCountByNumber", [
  "0xe8"
])
print(response)

import { createPublicClient, http } from "viem";

const client = createPublicClient({
  transport: http("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getBlockTransactionCountByNumber)"),
});

const result = await client.request({
  method: "eth_getBlockTransactionCountByNumber",
  params: [
  "0xe8"
],
});

console.log(result);

const endpoint = "wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getBlockTransactionCountByNumber)";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({ jsonrpc: "2.0", method: "eth_getBlockTransactionCountByNumber", params: [
  "0xe8"
], id: 1 });
console.log(result);

const response = await fetch('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getBlockTransactionCountByNumber)', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "eth_getBlockTransactionCountByNumber",
      "id": 1,
      "params": [
        "0xe8"
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "eth_getBlockTransactionCountByNumber",
  "id": 1,
  "params": [
    "0xe8"
  ]
}

response = requests.post('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getBlockTransactionCountByNumber)', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getBlockTransactionCountByNumber)')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "jsonrpc": "2.0",
    "method": "eth_getBlockTransactionCountByNumber",
    "id": 1,
    "params": [
      "0xe8"
    ]
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

Request Body

{
  "jsonrpc": "2.0",
  "method": "eth_getBlockTransactionCountByNumber",
  "id": 1,
  "params": [
    "0xe8"
  ]
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": "0x1"
}

Returns an uncle block by block hash and index.

POST

wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getUncleByBlockHashAndIndex)

Authorizations

ApiKeyAuthApiKeyAuth

apiKey string

NOWNodes API key passed in the api-key header.

Returns information about an uncle of a block by hash and uncle index position. Proof-of-stake / L2 chains have no uncles; the result is null for any index.

Sent as a JSON text message over the WebSocket connection wss://monad.nownodes.io/wss/{apiKey}.

Body

application/json

WebSocket request envelope for eth_getUncleByBlockHashAndIndex, sent as a JSON text message.

WebSocket text-message request envelope sent over the single WSS connection.

jsonrpcstringrequired

JSON-RPC protocol version.

methodstringrequired

JSON-RPC method name.

paramsarray | object

Method parameters (array or object); omit for parameterless methods.

idinteger | string

Client-chosen request identifier echoed in the response.

Parameters

apiKeystringrequiredpath

NOWNodes API key - the last path segment of the WebSocket URL (wss://monad.nownodes.io/wss/{apiKey}).

Response

200OK

Response delivered on the same WebSocket connection. JSON-RPC errors arrive as regular messages (no HTTP status change); subscription pushes arrive as eth_subscription notifications.

Returns an uncle block by block hash and index.

curl -X POST 'wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getUncleByBlockHashAndIndex)' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_getUncleByBlockHashAndIndex",
    "id": 1,
    "params": [
      "0xc6ef2fc5426d6ad6fd9e2a26abeab0aa2411b7ab17f30a99d3cb96aed1d1055b",
      "0x0"
    ]
  }'

import { JsonRpcProvider } from "ethers";

const provider = new JsonRpcProvider("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getUncleByBlockHashAndIndex)");
const result = await provider.send("eth_getUncleByBlockHashAndIndex", [
  "0xc6ef2fc5426d6ad6fd9e2a26abeab0aa2411b7ab17f30a99d3cb96aed1d1055b",
  "0x0"
]);
console.log(result);

require 'eth'
require 'json'
require 'net/http'

uri = URI('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getUncleByBlockHashAndIndex)')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
  "jsonrpc": "2.0",
  "method": "eth_getUncleByBlockHashAndIndex",
  "params": [
    "0xc6ef2fc5426d6ad6fd9e2a26abeab0aa2411b7ab17f30a99d3cb96aed1d1055b",
    "0x0"
  ],
  "id": 1
}'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end

puts JSON.parse(response.body)

from web3 import Web3

w3 = Web3(Web3.HTTPProvider("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getUncleByBlockHashAndIndex)"))
response = w3.provider.make_request("eth_getUncleByBlockHashAndIndex", [
  "0xc6ef2fc5426d6ad6fd9e2a26abeab0aa2411b7ab17f30a99d3cb96aed1d1055b",
  "0x0"
])
print(response)

import { createPublicClient, http } from "viem";

const client = createPublicClient({
  transport: http("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getUncleByBlockHashAndIndex)"),
});

const result = await client.request({
  method: "eth_getUncleByBlockHashAndIndex",
  params: [
  "0xc6ef2fc5426d6ad6fd9e2a26abeab0aa2411b7ab17f30a99d3cb96aed1d1055b",
  "0x0"
],
});

console.log(result);

const endpoint = "wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getUncleByBlockHashAndIndex)";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({ jsonrpc: "2.0", method: "eth_getUncleByBlockHashAndIndex", params: [
  "0xc6ef2fc5426d6ad6fd9e2a26abeab0aa2411b7ab17f30a99d3cb96aed1d1055b",
  "0x0"
], id: 1 });
console.log(result);

const response = await fetch('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getUncleByBlockHashAndIndex)', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "eth_getUncleByBlockHashAndIndex",
      "id": 1,
      "params": [
        "0xc6ef2fc5426d6ad6fd9e2a26abeab0aa2411b7ab17f30a99d3cb96aed1d1055b",
        "0x0"
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "eth_getUncleByBlockHashAndIndex",
  "id": 1,
  "params": [
    "0xc6ef2fc5426d6ad6fd9e2a26abeab0aa2411b7ab17f30a99d3cb96aed1d1055b",
    "0x0"
  ]
}

response = requests.post('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getUncleByBlockHashAndIndex)', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getUncleByBlockHashAndIndex)')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "jsonrpc": "2.0",
    "method": "eth_getUncleByBlockHashAndIndex",
    "id": 1,
    "params": [
      "0xc6ef2fc5426d6ad6fd9e2a26abeab0aa2411b7ab17f30a99d3cb96aed1d1055b",
      "0x0"
    ]
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

Request Body

{
  "jsonrpc": "2.0",
  "method": "eth_getUncleByBlockHashAndIndex",
  "id": 1,
  "params": [
    "0xc6ef2fc5426d6ad6fd9e2a26abeab0aa2411b7ab17f30a99d3cb96aed1d1055b",
    "0x0"
  ]
}

200

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

Returns an uncle block by number and index.

POST

wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getUncleByBlockNumberAndIndex)

Authorizations

ApiKeyAuthApiKeyAuth

apiKey string

NOWNodes API key passed in the api-key header.

Returns information about an uncle of a block by number and uncle index position; null on Monad.

Sent as a JSON text message over the WebSocket connection wss://monad.nownodes.io/wss/{apiKey}.

Body

application/json

WebSocket request envelope for eth_getUncleByBlockNumberAndIndex, sent as a JSON text message.

WebSocket text-message request envelope sent over the single WSS connection.

jsonrpcstringrequired

JSON-RPC protocol version.

methodstringrequired

JSON-RPC method name.

paramsarray | object

Method parameters (array or object); omit for parameterless methods.

idinteger | string

Client-chosen request identifier echoed in the response.

Parameters

apiKeystringrequiredpath

NOWNodes API key - the last path segment of the WebSocket URL (wss://monad.nownodes.io/wss/{apiKey}).

Response

200OK

Response delivered on the same WebSocket connection. JSON-RPC errors arrive as regular messages (no HTTP status change); subscription pushes arrive as eth_subscription notifications.

Returns an uncle block by number and index.

curl -X POST 'wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getUncleByBlockNumberAndIndex)' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_getUncleByBlockNumberAndIndex",
    "id": 1,
    "params": [
      "0x29c",
      "0x0"
    ]
  }'

import { JsonRpcProvider } from "ethers";

const provider = new JsonRpcProvider("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getUncleByBlockNumberAndIndex)");
const result = await provider.send("eth_getUncleByBlockNumberAndIndex", [
  "0x29c",
  "0x0"
]);
console.log(result);

require 'eth'
require 'json'
require 'net/http'

uri = URI('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getUncleByBlockNumberAndIndex)')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
  "jsonrpc": "2.0",
  "method": "eth_getUncleByBlockNumberAndIndex",
  "params": [
    "0x29c",
    "0x0"
  ],
  "id": 1
}'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end

puts JSON.parse(response.body)

from web3 import Web3

w3 = Web3(Web3.HTTPProvider("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getUncleByBlockNumberAndIndex)"))
response = w3.provider.make_request("eth_getUncleByBlockNumberAndIndex", [
  "0x29c",
  "0x0"
])
print(response)

import { createPublicClient, http } from "viem";

const client = createPublicClient({
  transport: http("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getUncleByBlockNumberAndIndex)"),
});

const result = await client.request({
  method: "eth_getUncleByBlockNumberAndIndex",
  params: [
  "0x29c",
  "0x0"
],
});

console.log(result);

const endpoint = "wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getUncleByBlockNumberAndIndex)";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({ jsonrpc: "2.0", method: "eth_getUncleByBlockNumberAndIndex", params: [
  "0x29c",
  "0x0"
], id: 1 });
console.log(result);

const response = await fetch('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getUncleByBlockNumberAndIndex)', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "eth_getUncleByBlockNumberAndIndex",
      "id": 1,
      "params": [
        "0x29c",
        "0x0"
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "eth_getUncleByBlockNumberAndIndex",
  "id": 1,
  "params": [
    "0x29c",
    "0x0"
  ]
}

response = requests.post('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getUncleByBlockNumberAndIndex)', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getUncleByBlockNumberAndIndex)')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "jsonrpc": "2.0",
    "method": "eth_getUncleByBlockNumberAndIndex",
    "id": 1,
    "params": [
      "0x29c",
      "0x0"
    ]
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

Request Body

{
  "jsonrpc": "2.0",
  "method": "eth_getUncleByBlockNumberAndIndex",
  "id": 1,
  "params": [
    "0x29c",
    "0x0"
  ]
}

200

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

Returns the number of uncles of a block by hash.

POST

wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getUncleCountByBlockHash)

Authorizations

ApiKeyAuthApiKeyAuth

apiKey string

NOWNodes API key passed in the api-key header.

Returns the number of uncles in the block matching the given hash (null for an unknown hash; Monad blocks have no uncles).

Sent as a JSON text message over the WebSocket connection wss://monad.nownodes.io/wss/{apiKey}.

Body

application/json

WebSocket request envelope for eth_getUncleCountByBlockHash, sent as a JSON text message.

WebSocket text-message request envelope sent over the single WSS connection.

jsonrpcstringrequired

JSON-RPC protocol version.

methodstringrequired

JSON-RPC method name.

paramsarray | object

Method parameters (array or object); omit for parameterless methods.

idinteger | string

Client-chosen request identifier echoed in the response.

Parameters

apiKeystringrequiredpath

NOWNodes API key - the last path segment of the WebSocket URL (wss://monad.nownodes.io/wss/{apiKey}).

Response

200OK

Response delivered on the same WebSocket connection. JSON-RPC errors arrive as regular messages (no HTTP status change); subscription pushes arrive as eth_subscription notifications.

Returns the number of uncles of a block by hash.

curl -X POST 'wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getUncleCountByBlockHash)' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_getUncleCountByBlockHash",
    "id": 1,
    "params": [
      "0xc6ef2fc5426d6ad6fd9e2a26abeab0aa2411b7ab17f30a99d3cb96aed1d1055b"
    ]
  }'

import { JsonRpcProvider } from "ethers";

const provider = new JsonRpcProvider("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getUncleCountByBlockHash)");
const result = await provider.send("eth_getUncleCountByBlockHash", [
  "0xc6ef2fc5426d6ad6fd9e2a26abeab0aa2411b7ab17f30a99d3cb96aed1d1055b"
]);
console.log(result);

require 'eth'
require 'json'
require 'net/http'

uri = URI('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getUncleCountByBlockHash)')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
  "jsonrpc": "2.0",
  "method": "eth_getUncleCountByBlockHash",
  "params": [
    "0xc6ef2fc5426d6ad6fd9e2a26abeab0aa2411b7ab17f30a99d3cb96aed1d1055b"
  ],
  "id": 1
}'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end

puts JSON.parse(response.body)

from web3 import Web3

w3 = Web3(Web3.HTTPProvider("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getUncleCountByBlockHash)"))
response = w3.provider.make_request("eth_getUncleCountByBlockHash", [
  "0xc6ef2fc5426d6ad6fd9e2a26abeab0aa2411b7ab17f30a99d3cb96aed1d1055b"
])
print(response)

import { createPublicClient, http } from "viem";

const client = createPublicClient({
  transport: http("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getUncleCountByBlockHash)"),
});

const result = await client.request({
  method: "eth_getUncleCountByBlockHash",
  params: [
  "0xc6ef2fc5426d6ad6fd9e2a26abeab0aa2411b7ab17f30a99d3cb96aed1d1055b"
],
});

console.log(result);

const endpoint = "wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getUncleCountByBlockHash)";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({ jsonrpc: "2.0", method: "eth_getUncleCountByBlockHash", params: [
  "0xc6ef2fc5426d6ad6fd9e2a26abeab0aa2411b7ab17f30a99d3cb96aed1d1055b"
], id: 1 });
console.log(result);

const response = await fetch('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getUncleCountByBlockHash)', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "eth_getUncleCountByBlockHash",
      "id": 1,
      "params": [
        "0xc6ef2fc5426d6ad6fd9e2a26abeab0aa2411b7ab17f30a99d3cb96aed1d1055b"
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "eth_getUncleCountByBlockHash",
  "id": 1,
  "params": [
    "0xc6ef2fc5426d6ad6fd9e2a26abeab0aa2411b7ab17f30a99d3cb96aed1d1055b"
  ]
}

response = requests.post('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getUncleCountByBlockHash)', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getUncleCountByBlockHash)')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "jsonrpc": "2.0",
    "method": "eth_getUncleCountByBlockHash",
    "id": 1,
    "params": [
      "0xc6ef2fc5426d6ad6fd9e2a26abeab0aa2411b7ab17f30a99d3cb96aed1d1055b"
    ]
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

Request Body

{
  "jsonrpc": "2.0",
  "method": "eth_getUncleCountByBlockHash",
  "id": 1,
  "params": [
    "0xc6ef2fc5426d6ad6fd9e2a26abeab0aa2411b7ab17f30a99d3cb96aed1d1055b"
  ]
}

200

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

Returns the number of uncles of a block by number.

POST

wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getUncleCountByBlockNumber)

Authorizations

ApiKeyAuthApiKeyAuth

apiKey string

NOWNodes API key passed in the api-key header.

Returns the number of uncles in the block matching the given number; 0x0 on Monad (no uncles).

Sent as a JSON text message over the WebSocket connection wss://monad.nownodes.io/wss/{apiKey}.

Body

application/json

WebSocket request envelope for eth_getUncleCountByBlockNumber, sent as a JSON text message.

WebSocket text-message request envelope sent over the single WSS connection.

jsonrpcstringrequired

JSON-RPC protocol version.

methodstringrequired

JSON-RPC method name.

paramsarray | object

Method parameters (array or object); omit for parameterless methods.

idinteger | string

Client-chosen request identifier echoed in the response.

Parameters

apiKeystringrequiredpath

NOWNodes API key - the last path segment of the WebSocket URL (wss://monad.nownodes.io/wss/{apiKey}).

Response

200OK

Response delivered on the same WebSocket connection. JSON-RPC errors arrive as regular messages (no HTTP status change); subscription pushes arrive as eth_subscription notifications.

Returns the number of uncles of a block by number.

curl -X POST 'wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getUncleCountByBlockNumber)' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_getUncleCountByBlockNumber",
    "id": 1,
    "params": [
      "0xe8"
    ]
  }'

import { JsonRpcProvider } from "ethers";

const provider = new JsonRpcProvider("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getUncleCountByBlockNumber)");
const result = await provider.send("eth_getUncleCountByBlockNumber", [
  "0xe8"
]);
console.log(result);

require 'eth'
require 'json'
require 'net/http'

uri = URI('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getUncleCountByBlockNumber)')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
  "jsonrpc": "2.0",
  "method": "eth_getUncleCountByBlockNumber",
  "params": [
    "0xe8"
  ],
  "id": 1
}'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end

puts JSON.parse(response.body)

from web3 import Web3

w3 = Web3(Web3.HTTPProvider("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getUncleCountByBlockNumber)"))
response = w3.provider.make_request("eth_getUncleCountByBlockNumber", [
  "0xe8"
])
print(response)

import { createPublicClient, http } from "viem";

const client = createPublicClient({
  transport: http("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getUncleCountByBlockNumber)"),
});

const result = await client.request({
  method: "eth_getUncleCountByBlockNumber",
  params: [
  "0xe8"
],
});

console.log(result);

const endpoint = "wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getUncleCountByBlockNumber)";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({ jsonrpc: "2.0", method: "eth_getUncleCountByBlockNumber", params: [
  "0xe8"
], id: 1 });
console.log(result);

const response = await fetch('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getUncleCountByBlockNumber)', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "eth_getUncleCountByBlockNumber",
      "id": 1,
      "params": [
        "0xe8"
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "eth_getUncleCountByBlockNumber",
  "id": 1,
  "params": [
    "0xe8"
  ]
}

response = requests.post('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getUncleCountByBlockNumber)', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getUncleCountByBlockNumber)')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "jsonrpc": "2.0",
    "method": "eth_getUncleCountByBlockNumber",
    "id": 1,
    "params": [
      "0xe8"
    ]
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

Request Body

{
  "jsonrpc": "2.0",
  "method": "eth_getUncleCountByBlockNumber",
  "id": 1,
  "params": [
    "0xe8"
  ]
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": "0x0"
}

Transactions

Transaction lookups, nonces, receipts, pending pool.

Returns a transaction by hash.

POST

wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getTransactionByHash)

Authorizations

ApiKeyAuthApiKeyAuth

apiKey string

NOWNodes API key passed in the api-key header.

Returns the information about a transaction requested by transaction hash (pending or mined); null for an unknown hash.

Sent as a JSON text message over the WebSocket connection wss://monad.nownodes.io/wss/{apiKey}.

Body

application/json

WebSocket request envelope for eth_getTransactionByHash, sent as a JSON text message.

WebSocket text-message request envelope sent over the single WSS connection.

jsonrpcstringrequired

JSON-RPC protocol version.

methodstringrequired

JSON-RPC method name.

paramsarray | object

Method parameters (array or object); omit for parameterless methods.

idinteger | string

Client-chosen request identifier echoed in the response.

Parameters

apiKeystringrequiredpath

NOWNodes API key - the last path segment of the WebSocket URL (wss://monad.nownodes.io/wss/{apiKey}).

Response

200OK

Response delivered on the same WebSocket connection. JSON-RPC errors arrive as regular messages (no HTTP status change); subscription pushes arrive as eth_subscription notifications.

Returns a transaction by hash.

curl -X POST 'wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getTransactionByHash)' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_getTransactionByHash",
    "id": 1,
    "params": [
      "0x88df016429689c079f3b2f6ad39fa052532c56795b733da78a91ebe6a713944b"
    ]
  }'

import { JsonRpcProvider } from "ethers";

const provider = new JsonRpcProvider("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getTransactionByHash)");
const result = await provider.send("eth_getTransactionByHash", [
  "0x88df016429689c079f3b2f6ad39fa052532c56795b733da78a91ebe6a713944b"
]);
console.log(result);

require 'eth'
require 'json'
require 'net/http'

uri = URI('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getTransactionByHash)')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
  "jsonrpc": "2.0",
  "method": "eth_getTransactionByHash",
  "params": [
    "0x88df016429689c079f3b2f6ad39fa052532c56795b733da78a91ebe6a713944b"
  ],
  "id": 1
}'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end

puts JSON.parse(response.body)

from web3 import Web3

w3 = Web3(Web3.HTTPProvider("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getTransactionByHash)"))
response = w3.provider.make_request("eth_getTransactionByHash", [
  "0x88df016429689c079f3b2f6ad39fa052532c56795b733da78a91ebe6a713944b"
])
print(response)

import { createPublicClient, http } from "viem";

const client = createPublicClient({
  transport: http("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getTransactionByHash)"),
});

const result = await client.request({
  method: "eth_getTransactionByHash",
  params: [
  "0x88df016429689c079f3b2f6ad39fa052532c56795b733da78a91ebe6a713944b"
],
});

console.log(result);

const endpoint = "wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getTransactionByHash)";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({ jsonrpc: "2.0", method: "eth_getTransactionByHash", params: [
  "0x88df016429689c079f3b2f6ad39fa052532c56795b733da78a91ebe6a713944b"
], id: 1 });
console.log(result);

const response = await fetch('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getTransactionByHash)', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "eth_getTransactionByHash",
      "id": 1,
      "params": [
        "0x88df016429689c079f3b2f6ad39fa052532c56795b733da78a91ebe6a713944b"
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "eth_getTransactionByHash",
  "id": 1,
  "params": [
    "0x88df016429689c079f3b2f6ad39fa052532c56795b733da78a91ebe6a713944b"
  ]
}

response = requests.post('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getTransactionByHash)', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getTransactionByHash)')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "jsonrpc": "2.0",
    "method": "eth_getTransactionByHash",
    "id": 1,
    "params": [
      "0x88df016429689c079f3b2f6ad39fa052532c56795b733da78a91ebe6a713944b"
    ]
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

Request Body

{
  "jsonrpc": "2.0",
  "method": "eth_getTransactionByHash",
  "id": 1,
  "params": [
    "0x88df016429689c079f3b2f6ad39fa052532c56795b733da78a91ebe6a713944b"
  ]
}

200

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

Returns a transaction by block hash and index.

POST

wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getTransactionByBlockHashAndIndex)

Authorizations

ApiKeyAuthApiKeyAuth

apiKey string

NOWNodes API key passed in the api-key header.

Returns information about a transaction by block hash and transaction index position; null when the block or index is unknown.

Sent as a JSON text message over the WebSocket connection wss://monad.nownodes.io/wss/{apiKey}.

Body

application/json

WebSocket request envelope for eth_getTransactionByBlockHashAndIndex, sent as a JSON text message.

WebSocket text-message request envelope sent over the single WSS connection.

jsonrpcstringrequired

JSON-RPC protocol version.

methodstringrequired

JSON-RPC method name.

paramsarray | object

Method parameters (array or object); omit for parameterless methods.

idinteger | string

Client-chosen request identifier echoed in the response.

Parameters

apiKeystringrequiredpath

NOWNodes API key - the last path segment of the WebSocket URL (wss://monad.nownodes.io/wss/{apiKey}).

Response

200OK

Response delivered on the same WebSocket connection. JSON-RPC errors arrive as regular messages (no HTTP status change); subscription pushes arrive as eth_subscription notifications.

Returns a transaction by block hash and index.

curl -X POST 'wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getTransactionByBlockHashAndIndex)' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_getTransactionByBlockHashAndIndex",
    "id": 1,
    "params": [
      "0xc6ef2fc5426d6ad6fd9e2a26abeab0aa2411b7ab17f30a99d3cb96aed1d1055b",
      "0x0"
    ]
  }'

import { JsonRpcProvider } from "ethers";

const provider = new JsonRpcProvider("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getTransactionByBlockHashAndIndex)");
const result = await provider.send("eth_getTransactionByBlockHashAndIndex", [
  "0xc6ef2fc5426d6ad6fd9e2a26abeab0aa2411b7ab17f30a99d3cb96aed1d1055b",
  "0x0"
]);
console.log(result);

require 'eth'
require 'json'
require 'net/http'

uri = URI('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getTransactionByBlockHashAndIndex)')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
  "jsonrpc": "2.0",
  "method": "eth_getTransactionByBlockHashAndIndex",
  "params": [
    "0xc6ef2fc5426d6ad6fd9e2a26abeab0aa2411b7ab17f30a99d3cb96aed1d1055b",
    "0x0"
  ],
  "id": 1
}'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end

puts JSON.parse(response.body)

from web3 import Web3

w3 = Web3(Web3.HTTPProvider("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getTransactionByBlockHashAndIndex)"))
response = w3.provider.make_request("eth_getTransactionByBlockHashAndIndex", [
  "0xc6ef2fc5426d6ad6fd9e2a26abeab0aa2411b7ab17f30a99d3cb96aed1d1055b",
  "0x0"
])
print(response)

import { createPublicClient, http } from "viem";

const client = createPublicClient({
  transport: http("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getTransactionByBlockHashAndIndex)"),
});

const result = await client.request({
  method: "eth_getTransactionByBlockHashAndIndex",
  params: [
  "0xc6ef2fc5426d6ad6fd9e2a26abeab0aa2411b7ab17f30a99d3cb96aed1d1055b",
  "0x0"
],
});

console.log(result);

const endpoint = "wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getTransactionByBlockHashAndIndex)";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({ jsonrpc: "2.0", method: "eth_getTransactionByBlockHashAndIndex", params: [
  "0xc6ef2fc5426d6ad6fd9e2a26abeab0aa2411b7ab17f30a99d3cb96aed1d1055b",
  "0x0"
], id: 1 });
console.log(result);

const response = await fetch('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getTransactionByBlockHashAndIndex)', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "eth_getTransactionByBlockHashAndIndex",
      "id": 1,
      "params": [
        "0xc6ef2fc5426d6ad6fd9e2a26abeab0aa2411b7ab17f30a99d3cb96aed1d1055b",
        "0x0"
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "eth_getTransactionByBlockHashAndIndex",
  "id": 1,
  "params": [
    "0xc6ef2fc5426d6ad6fd9e2a26abeab0aa2411b7ab17f30a99d3cb96aed1d1055b",
    "0x0"
  ]
}

response = requests.post('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getTransactionByBlockHashAndIndex)', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getTransactionByBlockHashAndIndex)')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "jsonrpc": "2.0",
    "method": "eth_getTransactionByBlockHashAndIndex",
    "id": 1,
    "params": [
      "0xc6ef2fc5426d6ad6fd9e2a26abeab0aa2411b7ab17f30a99d3cb96aed1d1055b",
      "0x0"
    ]
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

Request Body

{
  "jsonrpc": "2.0",
  "method": "eth_getTransactionByBlockHashAndIndex",
  "id": 1,
  "params": [
    "0xc6ef2fc5426d6ad6fd9e2a26abeab0aa2411b7ab17f30a99d3cb96aed1d1055b",
    "0x0"
  ]
}

200

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

Returns a transaction by block number and index.

POST

wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getTransactionByBlockNumberAndIndex)

Authorizations

ApiKeyAuthApiKeyAuth

apiKey string

NOWNodes API key passed in the api-key header.

Returns information about a transaction by block number (or tag) and transaction index position.

Sent as a JSON text message over the WebSocket connection wss://monad.nownodes.io/wss/{apiKey}.

Body

application/json

WebSocket request envelope for eth_getTransactionByBlockNumberAndIndex, sent as a JSON text message.

WebSocket text-message request envelope sent over the single WSS connection.

jsonrpcstringrequired

JSON-RPC protocol version.

methodstringrequired

JSON-RPC method name.

paramsarray | object

Method parameters (array or object); omit for parameterless methods.

idinteger | string

Client-chosen request identifier echoed in the response.

Parameters

apiKeystringrequiredpath

NOWNodes API key - the last path segment of the WebSocket URL (wss://monad.nownodes.io/wss/{apiKey}).

Response

200OK

Response delivered on the same WebSocket connection. JSON-RPC errors arrive as regular messages (no HTTP status change); subscription pushes arrive as eth_subscription notifications.

Returns a transaction by block number and index.

curl -X POST 'wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getTransactionByBlockNumberAndIndex)' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_getTransactionByBlockNumberAndIndex",
    "id": 1,
    "params": [
      "0x29c",
      "0x0"
    ]
  }'

import { JsonRpcProvider } from "ethers";

const provider = new JsonRpcProvider("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getTransactionByBlockNumberAndIndex)");
const result = await provider.send("eth_getTransactionByBlockNumberAndIndex", [
  "0x29c",
  "0x0"
]);
console.log(result);

require 'eth'
require 'json'
require 'net/http'

uri = URI('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getTransactionByBlockNumberAndIndex)')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
  "jsonrpc": "2.0",
  "method": "eth_getTransactionByBlockNumberAndIndex",
  "params": [
    "0x29c",
    "0x0"
  ],
  "id": 1
}'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end

puts JSON.parse(response.body)

from web3 import Web3

w3 = Web3(Web3.HTTPProvider("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getTransactionByBlockNumberAndIndex)"))
response = w3.provider.make_request("eth_getTransactionByBlockNumberAndIndex", [
  "0x29c",
  "0x0"
])
print(response)

import { createPublicClient, http } from "viem";

const client = createPublicClient({
  transport: http("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getTransactionByBlockNumberAndIndex)"),
});

const result = await client.request({
  method: "eth_getTransactionByBlockNumberAndIndex",
  params: [
  "0x29c",
  "0x0"
],
});

console.log(result);

const endpoint = "wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getTransactionByBlockNumberAndIndex)";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({ jsonrpc: "2.0", method: "eth_getTransactionByBlockNumberAndIndex", params: [
  "0x29c",
  "0x0"
], id: 1 });
console.log(result);

const response = await fetch('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getTransactionByBlockNumberAndIndex)', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "eth_getTransactionByBlockNumberAndIndex",
      "id": 1,
      "params": [
        "0x29c",
        "0x0"
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "eth_getTransactionByBlockNumberAndIndex",
  "id": 1,
  "params": [
    "0x29c",
    "0x0"
  ]
}

response = requests.post('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getTransactionByBlockNumberAndIndex)', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getTransactionByBlockNumberAndIndex)')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "jsonrpc": "2.0",
    "method": "eth_getTransactionByBlockNumberAndIndex",
    "id": 1,
    "params": [
      "0x29c",
      "0x0"
    ]
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

Request Body

{
  "jsonrpc": "2.0",
  "method": "eth_getTransactionByBlockNumberAndIndex",
  "id": 1,
  "params": [
    "0x29c",
    "0x0"
  ]
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "blockHash": "0x9f4a279646f77ae46ca7df63b4f31d09ef0d0e9bf33cfba52b21ccf980aa8cfe",
    "blockNumber": "0x29c",
    "from": "0x4abef613822fb2031d897e792f89c896ddafc466",
    "gas": "0x4057e",
    "gasPrice": "0x6d6e2edc00",
    "hash": "0xc1ff83cfe18bda60bc8a867bfe6c1b3a20cf2c59e0cbecdb6360f7a087d56142",
    "input": "0x",
    "nonce": "0xef",
    "to": "0x95042281af6566fc6748f28263ceeecaefb4d2b4",
    "transactionIndex": "0x0",
    "value": "0x0",
    "type": "0x0",
    "chainId": "0x8f",
    "v": "0x142",
    "r": "0xfb4fa8ce6ff4a923856ccd5d66e682bd6383c813e0e6da49be3d260bf40d3245",
    "s": "0x2156e53641c59a1f603b758acc4994472bf15634d912b2153b3a64c849de4e6a"
  }
}

Returns the nonce (transaction count) of an address.

POST

wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getTransactionCount)

Authorizations

ApiKeyAuthApiKeyAuth

apiKey string

NOWNodes API key passed in the api-key header.

Returns the number of transactions sent from an address, optionally filtered by block tag.

Sent as a JSON text message over the WebSocket connection wss://monad.nownodes.io/wss/{apiKey}.

Body

application/json

WebSocket request envelope for eth_getTransactionCount, sent as a JSON text message.

WebSocket text-message request envelope sent over the single WSS connection.

jsonrpcstringrequired

JSON-RPC protocol version.

methodstringrequired

JSON-RPC method name.

paramsarray | object

Method parameters (array or object); omit for parameterless methods.

idinteger | string

Client-chosen request identifier echoed in the response.

Parameters

apiKeystringrequiredpath

NOWNodes API key - the last path segment of the WebSocket URL (wss://monad.nownodes.io/wss/{apiKey}).

Response

200OK

Response delivered on the same WebSocket connection. JSON-RPC errors arrive as regular messages (no HTTP status change); subscription pushes arrive as eth_subscription notifications.

Returns the nonce (transaction count) of an address.

curl -X POST 'wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getTransactionCount)' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_getTransactionCount",
    "id": 1,
    "params": [
      "0x407d73d8a49eeb85d32cf465507dd71d507100c1",
      "latest"
    ]
  }'

import { JsonRpcProvider } from "ethers";

const provider = new JsonRpcProvider("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getTransactionCount)");
const result = await provider.send("eth_getTransactionCount", [
  "0x407d73d8a49eeb85d32cf465507dd71d507100c1",
  "latest"
]);
console.log(result);

require 'eth'
require 'json'
require 'net/http'

uri = URI('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getTransactionCount)')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
  "jsonrpc": "2.0",
  "method": "eth_getTransactionCount",
  "params": [
    "0x407d73d8a49eeb85d32cf465507dd71d507100c1",
    "latest"
  ],
  "id": 1
}'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end

puts JSON.parse(response.body)

from web3 import Web3

w3 = Web3(Web3.HTTPProvider("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getTransactionCount)"))
response = w3.provider.make_request("eth_getTransactionCount", [
  "0x407d73d8a49eeb85d32cf465507dd71d507100c1",
  "latest"
])
print(response)

import { createPublicClient, http } from "viem";

const client = createPublicClient({
  transport: http("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getTransactionCount)"),
});

const result = await client.request({
  method: "eth_getTransactionCount",
  params: [
  "0x407d73d8a49eeb85d32cf465507dd71d507100c1",
  "latest"
],
});

console.log(result);

const endpoint = "wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getTransactionCount)";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({ jsonrpc: "2.0", method: "eth_getTransactionCount", params: [
  "0x407d73d8a49eeb85d32cf465507dd71d507100c1",
  "latest"
], id: 1 });
console.log(result);

const response = await fetch('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getTransactionCount)', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "eth_getTransactionCount",
      "id": 1,
      "params": [
        "0x407d73d8a49eeb85d32cf465507dd71d507100c1",
        "latest"
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "eth_getTransactionCount",
  "id": 1,
  "params": [
    "0x407d73d8a49eeb85d32cf465507dd71d507100c1",
    "latest"
  ]
}

response = requests.post('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getTransactionCount)', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getTransactionCount)')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "jsonrpc": "2.0",
    "method": "eth_getTransactionCount",
    "id": 1,
    "params": [
      "0x407d73d8a49eeb85d32cf465507dd71d507100c1",
      "latest"
    ]
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

Request Body

{
  "jsonrpc": "2.0",
  "method": "eth_getTransactionCount",
  "id": 1,
  "params": [
    "0x407d73d8a49eeb85d32cf465507dd71d507100c1",
    "latest"
  ]
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": "0x0"
}

Returns a transaction receipt by hash.

POST

wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getTransactionReceipt)

Authorizations

ApiKeyAuthApiKeyAuth

apiKey string

NOWNodes API key passed in the api-key header.

Returns the receipt of a mined transaction by transaction hash (null while pending or unknown).

Sent as a JSON text message over the WebSocket connection wss://monad.nownodes.io/wss/{apiKey}.

Body

application/json

WebSocket request envelope for eth_getTransactionReceipt, sent as a JSON text message.

WebSocket text-message request envelope sent over the single WSS connection.

jsonrpcstringrequired

JSON-RPC protocol version.

methodstringrequired

JSON-RPC method name.

paramsarray | object

Method parameters (array or object); omit for parameterless methods.

idinteger | string

Client-chosen request identifier echoed in the response.

Parameters

apiKeystringrequiredpath

NOWNodes API key - the last path segment of the WebSocket URL (wss://monad.nownodes.io/wss/{apiKey}).

Response

200OK

Response delivered on the same WebSocket connection. JSON-RPC errors arrive as regular messages (no HTTP status change); subscription pushes arrive as eth_subscription notifications.

Returns a transaction receipt by hash.

curl -X POST 'wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getTransactionReceipt)' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_getTransactionReceipt",
    "id": 1,
    "params": [
      "0xb903239f8543d04b5dc1ba6579132b143087c68db1b2168786408fcbce568238"
    ]
  }'

import { JsonRpcProvider } from "ethers";

const provider = new JsonRpcProvider("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getTransactionReceipt)");
const result = await provider.send("eth_getTransactionReceipt", [
  "0xb903239f8543d04b5dc1ba6579132b143087c68db1b2168786408fcbce568238"
]);
console.log(result);

require 'eth'
require 'json'
require 'net/http'

uri = URI('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getTransactionReceipt)')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
  "jsonrpc": "2.0",
  "method": "eth_getTransactionReceipt",
  "params": [
    "0xb903239f8543d04b5dc1ba6579132b143087c68db1b2168786408fcbce568238"
  ],
  "id": 1
}'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end

puts JSON.parse(response.body)

from web3 import Web3

w3 = Web3(Web3.HTTPProvider("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getTransactionReceipt)"))
response = w3.provider.make_request("eth_getTransactionReceipt", [
  "0xb903239f8543d04b5dc1ba6579132b143087c68db1b2168786408fcbce568238"
])
print(response)

import { createPublicClient, http } from "viem";

const client = createPublicClient({
  transport: http("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getTransactionReceipt)"),
});

const result = await client.request({
  method: "eth_getTransactionReceipt",
  params: [
  "0xb903239f8543d04b5dc1ba6579132b143087c68db1b2168786408fcbce568238"
],
});

console.log(result);

const endpoint = "wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getTransactionReceipt)";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({ jsonrpc: "2.0", method: "eth_getTransactionReceipt", params: [
  "0xb903239f8543d04b5dc1ba6579132b143087c68db1b2168786408fcbce568238"
], id: 1 });
console.log(result);

const response = await fetch('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getTransactionReceipt)', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "eth_getTransactionReceipt",
      "id": 1,
      "params": [
        "0xb903239f8543d04b5dc1ba6579132b143087c68db1b2168786408fcbce568238"
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "eth_getTransactionReceipt",
  "id": 1,
  "params": [
    "0xb903239f8543d04b5dc1ba6579132b143087c68db1b2168786408fcbce568238"
  ]
}

response = requests.post('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getTransactionReceipt)', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getTransactionReceipt)')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "jsonrpc": "2.0",
    "method": "eth_getTransactionReceipt",
    "id": 1,
    "params": [
      "0xb903239f8543d04b5dc1ba6579132b143087c68db1b2168786408fcbce568238"
    ]
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

Request Body

{
  "jsonrpc": "2.0",
  "method": "eth_getTransactionReceipt",
  "id": 1,
  "params": [
    "0xb903239f8543d04b5dc1ba6579132b143087c68db1b2168786408fcbce568238"
  ]
}

200

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

Returns the pending transactions of the node.

POST

wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_pendingTransactions)

Authorizations

ApiKeyAuthApiKeyAuth

apiKey string

NOWNodes API key passed in the api-key header.

Returns the transactions currently pending in the node transaction pool (empty array when the pool is empty).

Sent as a JSON text message over the WebSocket connection wss://monad.nownodes.io/wss/{apiKey}.

Body

application/json

WebSocket request envelope for eth_pendingTransactions, sent as a JSON text message.

WebSocket text-message request envelope sent over the single WSS connection.

jsonrpcstringrequired

JSON-RPC protocol version.

methodstringrequired

JSON-RPC method name.

paramsarray | object

Method parameters (array or object); omit for parameterless methods.

idinteger | string

Client-chosen request identifier echoed in the response.

Parameters

apiKeystringrequiredpath

NOWNodes API key - the last path segment of the WebSocket URL (wss://monad.nownodes.io/wss/{apiKey}).

Response

200OK

Response delivered on the same WebSocket connection. JSON-RPC errors arrive as regular messages (no HTTP status change); subscription pushes arrive as eth_subscription notifications.

Returns the pending transactions of the node.

curl -X POST 'wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_pendingTransactions)' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_pendingTransactions",
    "id": 1,
    "params": []
  }'

import { JsonRpcProvider } from "ethers";

const provider = new JsonRpcProvider("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_pendingTransactions)");
const result = await provider.send("eth_pendingTransactions", []);
console.log(result);

require 'eth'
require 'json'
require 'net/http'

uri = URI('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_pendingTransactions)')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
  "jsonrpc": "2.0",
  "method": "eth_pendingTransactions",
  "params": [],
  "id": 1
}'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end

puts JSON.parse(response.body)

from web3 import Web3

w3 = Web3(Web3.HTTPProvider("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_pendingTransactions)"))
response = w3.provider.make_request("eth_pendingTransactions", [])
print(response)

import { createPublicClient, http } from "viem";

const client = createPublicClient({
  transport: http("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_pendingTransactions)"),
});

const result = await client.request({
  method: "eth_pendingTransactions",
  params: [],
});

console.log(result);

const endpoint = "wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_pendingTransactions)";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({ jsonrpc: "2.0", method: "eth_pendingTransactions", params: [], id: 1 });
console.log(result);

const response = await fetch('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_pendingTransactions)', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "eth_pendingTransactions",
      "id": 1,
      "params": []
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "eth_pendingTransactions",
  "id": 1,
  "params": []
}

response = requests.post('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_pendingTransactions)', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_pendingTransactions)')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "jsonrpc": "2.0",
    "method": "eth_pendingTransactions",
    "id": 1,
    "params": []
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

Request Body

{
  "jsonrpc": "2.0",
  "method": "eth_pendingTransactions",
  "id": 1,
  "params": []
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": []
}

Accounts & State

Balance, code, storage, calls, proofs, access lists.

Returns the balance of an address.

POST

wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getBalance)

Authorizations

ApiKeyAuthApiKeyAuth

apiKey string

NOWNodes API key passed in the api-key header.

Returns the balance of the account of the given address in wei, optionally at a block tag.

Sent as a JSON text message over the WebSocket connection wss://monad.nownodes.io/wss/{apiKey}.

Body

application/json

WebSocket request envelope for eth_getBalance, sent as a JSON text message.

WebSocket text-message request envelope sent over the single WSS connection.

jsonrpcstringrequired

JSON-RPC protocol version.

methodstringrequired

JSON-RPC method name.

paramsarray | object

Method parameters (array or object); omit for parameterless methods.

idinteger | string

Client-chosen request identifier echoed in the response.

Parameters

apiKeystringrequiredpath

NOWNodes API key - the last path segment of the WebSocket URL (wss://monad.nownodes.io/wss/{apiKey}).

Response

200OK

Response delivered on the same WebSocket connection. JSON-RPC errors arrive as regular messages (no HTTP status change); subscription pushes arrive as eth_subscription notifications.

Returns the balance of an address.

curl -X POST 'wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getBalance)' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_getBalance",
    "id": 1,
    "params": [
      "0x407d73d8a49eeb85d32cf465507dd71d507100c1",
      "latest"
    ]
  }'

import { JsonRpcProvider } from "ethers";

const provider = new JsonRpcProvider("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getBalance)");
const result = await provider.send("eth_getBalance", [
  "0x407d73d8a49eeb85d32cf465507dd71d507100c1",
  "latest"
]);
console.log(result);

require 'eth'
require 'json'
require 'net/http'

uri = URI('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getBalance)')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
  "jsonrpc": "2.0",
  "method": "eth_getBalance",
  "params": [
    "0x407d73d8a49eeb85d32cf465507dd71d507100c1",
    "latest"
  ],
  "id": 1
}'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end

puts JSON.parse(response.body)

from web3 import Web3

w3 = Web3(Web3.HTTPProvider("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getBalance)"))
response = w3.provider.make_request("eth_getBalance", [
  "0x407d73d8a49eeb85d32cf465507dd71d507100c1",
  "latest"
])
print(response)

import { createPublicClient, http } from "viem";

const client = createPublicClient({
  transport: http("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getBalance)"),
});

const result = await client.request({
  method: "eth_getBalance",
  params: [
  "0x407d73d8a49eeb85d32cf465507dd71d507100c1",
  "latest"
],
});

console.log(result);

const endpoint = "wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getBalance)";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({ jsonrpc: "2.0", method: "eth_getBalance", params: [
  "0x407d73d8a49eeb85d32cf465507dd71d507100c1",
  "latest"
], id: 1 });
console.log(result);

const response = await fetch('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getBalance)', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "eth_getBalance",
      "id": 1,
      "params": [
        "0x407d73d8a49eeb85d32cf465507dd71d507100c1",
        "latest"
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "eth_getBalance",
  "id": 1,
  "params": [
    "0x407d73d8a49eeb85d32cf465507dd71d507100c1",
    "latest"
  ]
}

response = requests.post('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getBalance)', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getBalance)')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "jsonrpc": "2.0",
    "method": "eth_getBalance",
    "id": 1,
    "params": [
      "0x407d73d8a49eeb85d32cf465507dd71d507100c1",
      "latest"
    ]
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

Request Body

{
  "jsonrpc": "2.0",
  "method": "eth_getBalance",
  "id": 1,
  "params": [
    "0x407d73d8a49eeb85d32cf465507dd71d507100c1",
    "latest"
  ]
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": "0x0"
}

Returns the contract code at an address.

POST

wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getCode)

Authorizations

ApiKeyAuthApiKeyAuth

apiKey string

NOWNodes API key passed in the api-key header.

Returns the code at a given address (0x for plain accounts), optionally at a block tag.

Sent as a JSON text message over the WebSocket connection wss://monad.nownodes.io/wss/{apiKey}.

Body

application/json

WebSocket request envelope for eth_getCode, sent as a JSON text message.

WebSocket text-message request envelope sent over the single WSS connection.

jsonrpcstringrequired

JSON-RPC protocol version.

methodstringrequired

JSON-RPC method name.

paramsarray | object

Method parameters (array or object); omit for parameterless methods.

idinteger | string

Client-chosen request identifier echoed in the response.

Parameters

apiKeystringrequiredpath

NOWNodes API key - the last path segment of the WebSocket URL (wss://monad.nownodes.io/wss/{apiKey}).

Response

200OK

Response delivered on the same WebSocket connection. JSON-RPC errors arrive as regular messages (no HTTP status change); subscription pushes arrive as eth_subscription notifications.

Returns the contract code at an address.

curl -X POST 'wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getCode)' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_getCode",
    "id": 1,
    "params": [
      "0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b",
      "latest"
    ]
  }'

import { JsonRpcProvider } from "ethers";

const provider = new JsonRpcProvider("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getCode)");
const result = await provider.send("eth_getCode", [
  "0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b",
  "latest"
]);
console.log(result);

require 'eth'
require 'json'
require 'net/http'

uri = URI('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getCode)')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
  "jsonrpc": "2.0",
  "method": "eth_getCode",
  "params": [
    "0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b",
    "latest"
  ],
  "id": 1
}'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end

puts JSON.parse(response.body)

from web3 import Web3

w3 = Web3(Web3.HTTPProvider("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getCode)"))
response = w3.provider.make_request("eth_getCode", [
  "0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b",
  "latest"
])
print(response)

import { createPublicClient, http } from "viem";

const client = createPublicClient({
  transport: http("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getCode)"),
});

const result = await client.request({
  method: "eth_getCode",
  params: [
  "0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b",
  "latest"
],
});

console.log(result);

const endpoint = "wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getCode)";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({ jsonrpc: "2.0", method: "eth_getCode", params: [
  "0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b",
  "latest"
], id: 1 });
console.log(result);

const response = await fetch('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getCode)', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "eth_getCode",
      "id": 1,
      "params": [
        "0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b",
        "latest"
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "eth_getCode",
  "id": 1,
  "params": [
    "0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b",
    "latest"
  ]
}

response = requests.post('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getCode)', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getCode)')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "jsonrpc": "2.0",
    "method": "eth_getCode",
    "id": 1,
    "params": [
      "0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b",
      "latest"
    ]
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

Request Body

{
  "jsonrpc": "2.0",
  "method": "eth_getCode",
  "id": 1,
  "params": [
    "0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b",
    "latest"
  ]
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": "0x"
}

Returns a storage value of a contract.

POST

wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getStorageAt)

Authorizations

ApiKeyAuthApiKeyAuth

apiKey string

NOWNodes API key passed in the api-key header.

Returns the value from a storage position at a given address (32-byte hex word).

Sent as a JSON text message over the WebSocket connection wss://monad.nownodes.io/wss/{apiKey}.

Body

application/json

WebSocket request envelope for eth_getStorageAt, sent as a JSON text message.

WebSocket text-message request envelope sent over the single WSS connection.

jsonrpcstringrequired

JSON-RPC protocol version.

methodstringrequired

JSON-RPC method name.

paramsarray | object

Method parameters (array or object); omit for parameterless methods.

idinteger | string

Client-chosen request identifier echoed in the response.

Parameters

apiKeystringrequiredpath

NOWNodes API key - the last path segment of the WebSocket URL (wss://monad.nownodes.io/wss/{apiKey}).

Response

200OK

Response delivered on the same WebSocket connection. JSON-RPC errors arrive as regular messages (no HTTP status change); subscription pushes arrive as eth_subscription notifications.

Returns a storage value of a contract.

curl -X POST 'wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getStorageAt)' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_getStorageAt",
    "id": 1,
    "params": [
      "0x295a70b2de5e3953354a6a8344e616ed314d7251",
      "0x0",
      "latest"
    ]
  }'

import { JsonRpcProvider } from "ethers";

const provider = new JsonRpcProvider("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getStorageAt)");
const result = await provider.send("eth_getStorageAt", [
  "0x295a70b2de5e3953354a6a8344e616ed314d7251",
  "0x0",
  "latest"
]);
console.log(result);

require 'eth'
require 'json'
require 'net/http'

uri = URI('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getStorageAt)')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
  "jsonrpc": "2.0",
  "method": "eth_getStorageAt",
  "params": [
    "0x295a70b2de5e3953354a6a8344e616ed314d7251",
    "0x0",
    "latest"
  ],
  "id": 1
}'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end

puts JSON.parse(response.body)

from web3 import Web3

w3 = Web3(Web3.HTTPProvider("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getStorageAt)"))
response = w3.provider.make_request("eth_getStorageAt", [
  "0x295a70b2de5e3953354a6a8344e616ed314d7251",
  "0x0",
  "latest"
])
print(response)

import { createPublicClient, http } from "viem";

const client = createPublicClient({
  transport: http("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getStorageAt)"),
});

const result = await client.request({
  method: "eth_getStorageAt",
  params: [
  "0x295a70b2de5e3953354a6a8344e616ed314d7251",
  "0x0",
  "latest"
],
});

console.log(result);

const endpoint = "wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getStorageAt)";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({ jsonrpc: "2.0", method: "eth_getStorageAt", params: [
  "0x295a70b2de5e3953354a6a8344e616ed314d7251",
  "0x0",
  "latest"
], id: 1 });
console.log(result);

const response = await fetch('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getStorageAt)', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "eth_getStorageAt",
      "id": 1,
      "params": [
        "0x295a70b2de5e3953354a6a8344e616ed314d7251",
        "0x0",
        "latest"
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "eth_getStorageAt",
  "id": 1,
  "params": [
    "0x295a70b2de5e3953354a6a8344e616ed314d7251",
    "0x0",
    "latest"
  ]
}

response = requests.post('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getStorageAt)', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getStorageAt)')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "jsonrpc": "2.0",
    "method": "eth_getStorageAt",
    "id": 1,
    "params": [
      "0x295a70b2de5e3953354a6a8344e616ed314d7251",
      "0x0",
      "latest"
    ]
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

Request Body

{
  "jsonrpc": "2.0",
  "method": "eth_getStorageAt",
  "id": 1,
  "params": [
    "0x295a70b2de5e3953354a6a8344e616ed314d7251",
    "0x0",
    "latest"
  ]
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": "0x0000000000000000000000000000000000000000000000000000000000000000"
}

Executes a message call without creating a transaction.

POST

wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_call)

Authorizations

ApiKeyAuthApiKeyAuth

apiKey string

NOWNodes API key passed in the api-key header.

Executes a new message call immediately without creating a transaction on the chain. Parameters: call object {from?, to, gas?, gasPrice?, value?, data?} and a block tag.

Sent as a JSON text message over the WebSocket connection wss://monad.nownodes.io/wss/{apiKey}.

Body

application/json

WebSocket request envelope for eth_call, sent as a JSON text message.

WebSocket text-message request envelope sent over the single WSS connection.

jsonrpcstringrequired

JSON-RPC protocol version.

methodstringrequired

JSON-RPC method name.

paramsarray | object

Method parameters (array or object); omit for parameterless methods.

idinteger | string

Client-chosen request identifier echoed in the response.

Parameters

apiKeystringrequiredpath

NOWNodes API key - the last path segment of the WebSocket URL (wss://monad.nownodes.io/wss/{apiKey}).

Response

200OK

Response delivered on the same WebSocket connection. JSON-RPC errors arrive as regular messages (no HTTP status change); subscription pushes arrive as eth_subscription notifications.

Executes a message call without creating a transaction.

curl -X POST 'wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_call)' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_call",
    "id": 1,
    "params": [
      {
        "to": "0xd46e8dd67c5d32be8058bb8eb970870f07244567"
      },
      "latest"
    ]
  }'

import { JsonRpcProvider } from "ethers";

const provider = new JsonRpcProvider("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_call)");
const result = await provider.send("eth_call", [
  {
    "to": "0xd46e8dd67c5d32be8058bb8eb970870f07244567"
  },
  "latest"
]);
console.log(result);

require 'eth'
require 'json'
require 'net/http'

uri = URI('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_call)')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
  "jsonrpc": "2.0",
  "method": "eth_call",
  "params": [
    {
      "to": "0xd46e8dd67c5d32be8058bb8eb970870f07244567"
    },
    "latest"
  ],
  "id": 1
}'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end

puts JSON.parse(response.body)

from web3 import Web3

w3 = Web3(Web3.HTTPProvider("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_call)"))
response = w3.provider.make_request("eth_call", [
  {
    "to": "0xd46e8dd67c5d32be8058bb8eb970870f07244567"
  },
  "latest"
])
print(response)

import { createPublicClient, http } from "viem";

const client = createPublicClient({
  transport: http("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_call)"),
});

const result = await client.request({
  method: "eth_call",
  params: [
  {
    "to": "0xd46e8dd67c5d32be8058bb8eb970870f07244567"
  },
  "latest"
],
});

console.log(result);

const endpoint = "wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_call)";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({ jsonrpc: "2.0", method: "eth_call", params: [
  {
    "to": "0xd46e8dd67c5d32be8058bb8eb970870f07244567"
  },
  "latest"
], id: 1 });
console.log(result);

const response = await fetch('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_call)', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "eth_call",
      "id": 1,
      "params": [
        {
          "to": "0xd46e8dd67c5d32be8058bb8eb970870f07244567"
        },
        "latest"
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "eth_call",
  "id": 1,
  "params": [
    {
      "to": "0xd46e8dd67c5d32be8058bb8eb970870f07244567"
    },
    "latest"
  ]
}

response = requests.post('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_call)', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_call)')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "jsonrpc": "2.0",
    "method": "eth_call",
    "id": 1,
    "params": [
      {
        "to": "0xd46e8dd67c5d32be8058bb8eb970870f07244567"
      },
      "latest"
    ]
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

Request Body

{
  "jsonrpc": "2.0",
  "method": "eth_call",
  "id": 1,
  "params": [
    {
      "to": "0xd46e8dd67c5d32be8058bb8eb970870f07244567"
    },
    "latest"
  ]
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": "0x"
}

Returns an account and storage Merkle proof.

POST

wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getProof)

Authorizations

ApiKeyAuthApiKeyAuth

apiKey string

NOWNodes API key passed in the api-key header.

Returns the account and storage values of the specified account, including a Merkle proof. Parameters: address, array of storage keys, block tag.

Sent as a JSON text message over the WebSocket connection wss://monad.nownodes.io/wss/{apiKey}.

Body

application/json

WebSocket request envelope for eth_getProof, sent as a JSON text message.

WebSocket text-message request envelope sent over the single WSS connection.

jsonrpcstringrequired

JSON-RPC protocol version.

methodstringrequired

JSON-RPC method name.

paramsarray | object

Method parameters (array or object); omit for parameterless methods.

idinteger | string

Client-chosen request identifier echoed in the response.

Parameters

apiKeystringrequiredpath

NOWNodes API key - the last path segment of the WebSocket URL (wss://monad.nownodes.io/wss/{apiKey}).

Response

200OK

Response delivered on the same WebSocket connection. JSON-RPC errors arrive as regular messages (no HTTP status change); subscription pushes arrive as eth_subscription notifications.

Returns an account and storage Merkle proof.

curl -X POST 'wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getProof)' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_getProof",
    "id": 1,
    "params": [
      "0xe5cB067E90D5Cd1F8052B83562Ae670bA4A211a8",
      [
        "0x0"
      ],
      "latest"
    ]
  }'

import { JsonRpcProvider } from "ethers";

const provider = new JsonRpcProvider("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getProof)");
const result = await provider.send("eth_getProof", [
  "0xe5cB067E90D5Cd1F8052B83562Ae670bA4A211a8",
  [
    "0x0"
  ],
  "latest"
]);
console.log(result);

require 'eth'
require 'json'
require 'net/http'

uri = URI('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getProof)')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
  "jsonrpc": "2.0",
  "method": "eth_getProof",
  "params": [
    "0xe5cB067E90D5Cd1F8052B83562Ae670bA4A211a8",
    [
      "0x0"
    ],
    "latest"
  ],
  "id": 1
}'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end

puts JSON.parse(response.body)

from web3 import Web3

w3 = Web3(Web3.HTTPProvider("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getProof)"))
response = w3.provider.make_request("eth_getProof", [
  "0xe5cB067E90D5Cd1F8052B83562Ae670bA4A211a8",
  [
    "0x0"
  ],
  "latest"
])
print(response)

import { createPublicClient, http } from "viem";

const client = createPublicClient({
  transport: http("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getProof)"),
});

const result = await client.request({
  method: "eth_getProof",
  params: [
  "0xe5cB067E90D5Cd1F8052B83562Ae670bA4A211a8",
  [
    "0x0"
  ],
  "latest"
],
});

console.log(result);

const endpoint = "wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getProof)";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({ jsonrpc: "2.0", method: "eth_getProof", params: [
  "0xe5cB067E90D5Cd1F8052B83562Ae670bA4A211a8",
  [
    "0x0"
  ],
  "latest"
], id: 1 });
console.log(result);

const response = await fetch('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getProof)', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "eth_getProof",
      "id": 1,
      "params": [
        "0xe5cB067E90D5Cd1F8052B83562Ae670bA4A211a8",
        [
          "0x0"
        ],
        "latest"
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "eth_getProof",
  "id": 1,
  "params": [
    "0xe5cB067E90D5Cd1F8052B83562Ae670bA4A211a8",
    [
      "0x0"
    ],
    "latest"
  ]
}

response = requests.post('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getProof)', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getProof)')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "jsonrpc": "2.0",
    "method": "eth_getProof",
    "id": 1,
    "params": [
      "0xe5cB067E90D5Cd1F8052B83562Ae670bA4A211a8",
      [
        "0x0"
      ],
      "latest"
    ]
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

Request Body

{
  "jsonrpc": "2.0",
  "method": "eth_getProof",
  "id": 1,
  "params": [
    "0xe5cB067E90D5Cd1F8052B83562Ae670bA4A211a8",
    [
      "0x0"
    ],
    "latest"
  ]
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "address": "0xe5cb067e90d5cd1f8052b83562ae670ba4a211a8",
    "accountProof": [],
    "balance": "0x0",
    "nonce": "0x0",
    "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470",
    "storageHash": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421",
    "storageProof": [
      {
        "key": "0x0",
        "value": "0x0",
        "proof": []
      }
    ]
  }
}

{
  "jsonrpc": "2.0",
  "id": 1,
  "error": {
    "code": -32602,
    "message": "missing value for required argument 1"
  }
}

Estimates an EIP-2930 access list for a transaction.

POST

wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_createAccessList)

Authorizations

ApiKeyAuthApiKeyAuth

apiKey string

NOWNodes API key passed in the api-key header.

Returns the list of addresses and storage keys read and written by the transaction (except the sender and precompiles), plus the estimated gas consumed when the access list is added.

Sent as a JSON text message over the WebSocket connection wss://monad.nownodes.io/wss/{apiKey}.

Body

application/json

WebSocket request envelope for eth_createAccessList, sent as a JSON text message.

WebSocket text-message request envelope sent over the single WSS connection.

jsonrpcstringrequired

JSON-RPC protocol version.

methodstringrequired

JSON-RPC method name.

paramsarray | object

Method parameters (array or object); omit for parameterless methods.

idinteger | string

Client-chosen request identifier echoed in the response.

Parameters

apiKeystringrequiredpath

NOWNodes API key - the last path segment of the WebSocket URL (wss://monad.nownodes.io/wss/{apiKey}).

Response

200OK

Response delivered on the same WebSocket connection. JSON-RPC errors arrive as regular messages (no HTTP status change); subscription pushes arrive as eth_subscription notifications.

Estimates an EIP-2930 access list for a transaction.

curl -X POST 'wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_createAccessList)' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_createAccessList",
    "id": 1,
    "params": [
      {
        "to": "0xd46e8dd67c5d32be8058bb8eb970870f07244567",
        "gas": "0x0",
        "gasPrice": "0x9184e72a000",
        "value": "0x0",
        "data": "0x"
      }
    ]
  }'

import { JsonRpcProvider } from "ethers";

const provider = new JsonRpcProvider("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_createAccessList)");
const result = await provider.send("eth_createAccessList", [
  {
    "to": "0xd46e8dd67c5d32be8058bb8eb970870f07244567",
    "gas": "0x0",
    "gasPrice": "0x9184e72a000",
    "value": "0x0",
    "data": "0x"
  }
]);
console.log(result);

require 'eth'
require 'json'
require 'net/http'

uri = URI('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_createAccessList)')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
  "jsonrpc": "2.0",
  "method": "eth_createAccessList",
  "params": [
    {
      "to": "0xd46e8dd67c5d32be8058bb8eb970870f07244567",
      "gas": "0x0",
      "gasPrice": "0x9184e72a000",
      "value": "0x0",
      "data": "0x"
    }
  ],
  "id": 1
}'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end

puts JSON.parse(response.body)

from web3 import Web3

w3 = Web3(Web3.HTTPProvider("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_createAccessList)"))
response = w3.provider.make_request("eth_createAccessList", [
  {
    "to": "0xd46e8dd67c5d32be8058bb8eb970870f07244567",
    "gas": "0x0",
    "gasPrice": "0x9184e72a000",
    "value": "0x0",
    "data": "0x"
  }
])
print(response)

import { createPublicClient, http } from "viem";

const client = createPublicClient({
  transport: http("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_createAccessList)"),
});

const result = await client.request({
  method: "eth_createAccessList",
  params: [
  {
    "to": "0xd46e8dd67c5d32be8058bb8eb970870f07244567",
    "gas": "0x0",
    "gasPrice": "0x9184e72a000",
    "value": "0x0",
    "data": "0x"
  }
],
});

console.log(result);

const endpoint = "wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_createAccessList)";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({ jsonrpc: "2.0", method: "eth_createAccessList", params: [
  {
    "to": "0xd46e8dd67c5d32be8058bb8eb970870f07244567",
    "gas": "0x0",
    "gasPrice": "0x9184e72a000",
    "value": "0x0",
    "data": "0x"
  }
], id: 1 });
console.log(result);

const response = await fetch('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_createAccessList)', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "eth_createAccessList",
      "id": 1,
      "params": [
        {
          "to": "0xd46e8dd67c5d32be8058bb8eb970870f07244567",
          "gas": "0x0",
          "gasPrice": "0x9184e72a000",
          "value": "0x0",
          "data": "0x"
        }
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "eth_createAccessList",
  "id": 1,
  "params": [
    {
      "to": "0xd46e8dd67c5d32be8058bb8eb970870f07244567",
      "gas": "0x0",
      "gasPrice": "0x9184e72a000",
      "value": "0x0",
      "data": "0x"
    }
  ]
}

response = requests.post('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_createAccessList)', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_createAccessList)')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "jsonrpc": "2.0",
    "method": "eth_createAccessList",
    "id": 1,
    "params": [
      {
        "to": "0xd46e8dd67c5d32be8058bb8eb970870f07244567",
        "gas": "0x0",
        "gasPrice": "0x9184e72a000",
        "value": "0x0",
        "data": "0x"
      }
    ]
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

Request Body

{
  "jsonrpc": "2.0",
  "method": "eth_createAccessList",
  "id": 1,
  "params": [
    {
      "to": "0xd46e8dd67c5d32be8058bb8eb970870f07244567",
      "gas": "0x0",
      "gasPrice": "0x9184e72a000",
      "value": "0x0",
      "data": "0x"
    }
  ]
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "error": {
    "code": -32000,
    "message": "failed to apply transaction: 0x295daf8de677ee7e46bc6776b7608cb9d9f7b1550145f6228dd636e6e203492c err: intrinsic gas too low: have 0, want 21000"
  }
}

Filters & Logs

Polling filters and log queries.

Creates a log filter.

POST

wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_newFilter)

Authorizations

ApiKeyAuthApiKeyAuth

apiKey string

NOWNodes API key passed in the api-key header.

Creates a filter object based on filter options ({fromBlock, toBlock, address, topics}) to notify when the state changes (logs). Use eth_getFilterChanges to poll it.

Sent as a JSON text message over the WebSocket connection wss://monad.nownodes.io/wss/{apiKey}.

Body

application/json

WebSocket request envelope for eth_newFilter, sent as a JSON text message.

WebSocket text-message request envelope sent over the single WSS connection.

jsonrpcstringrequired

JSON-RPC protocol version.

methodstringrequired

JSON-RPC method name.

paramsarray | object

Method parameters (array or object); omit for parameterless methods.

idinteger | string

Client-chosen request identifier echoed in the response.

Parameters

apiKeystringrequiredpath

NOWNodes API key - the last path segment of the WebSocket URL (wss://monad.nownodes.io/wss/{apiKey}).

Response

200OK

Response delivered on the same WebSocket connection. JSON-RPC errors arrive as regular messages (no HTTP status change); subscription pushes arrive as eth_subscription notifications.

Creates a log filter.

curl -X POST 'wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_newFilter)' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_newFilter",
    "id": 73,
    "params": [
      {
        "fromBlock": "0x1",
        "toBlock": "0x2",
        "address": "0x8888f1f195afa192cfee860698584c030f4c9db1",
        "topics": [
          "0x000000000000000000000000a94f5374fce5edbc8e2a8697c15331677e6ebf0b",
          null,
          [
            "0x000000000000000000000000a94f5374fce5edbc8e2a8697c15331677e6ebf0b",
            "0x0000000000000000000000000aff3454fce5edbc8cca8697c15331677e6ebccc"
          ]
        ]
      }
    ]
  }'

import { JsonRpcProvider } from "ethers";

const provider = new JsonRpcProvider("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_newFilter)");
const result = await provider.send("eth_newFilter", [
  {
    "fromBlock": "0x1",
    "toBlock": "0x2",
    "address": "0x8888f1f195afa192cfee860698584c030f4c9db1",
    "topics": [
      "0x000000000000000000000000a94f5374fce5edbc8e2a8697c15331677e6ebf0b",
      null,
      [
        "0x000000000000000000000000a94f5374fce5edbc8e2a8697c15331677e6ebf0b",
        "0x0000000000000000000000000aff3454fce5edbc8cca8697c15331677e6ebccc"
      ]
    ]
  }
]);
console.log(result);

require 'eth'
require 'json'
require 'net/http'

uri = URI('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_newFilter)')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
  "jsonrpc": "2.0",
  "method": "eth_newFilter",
  "params": [
    {
      "fromBlock": "0x1",
      "toBlock": "0x2",
      "address": "0x8888f1f195afa192cfee860698584c030f4c9db1",
      "topics": [
        "0x000000000000000000000000a94f5374fce5edbc8e2a8697c15331677e6ebf0b",
        null,
        [
          "0x000000000000000000000000a94f5374fce5edbc8e2a8697c15331677e6ebf0b",
          "0x0000000000000000000000000aff3454fce5edbc8cca8697c15331677e6ebccc"
        ]
      ]
    }
  ],
  "id": 1
}'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end

puts JSON.parse(response.body)

from web3 import Web3

w3 = Web3(Web3.HTTPProvider("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_newFilter)"))
response = w3.provider.make_request("eth_newFilter", [
  {
    "fromBlock": "0x1",
    "toBlock": "0x2",
    "address": "0x8888f1f195afa192cfee860698584c030f4c9db1",
    "topics": [
      "0x000000000000000000000000a94f5374fce5edbc8e2a8697c15331677e6ebf0b",
      null,
      [
        "0x000000000000000000000000a94f5374fce5edbc8e2a8697c15331677e6ebf0b",
        "0x0000000000000000000000000aff3454fce5edbc8cca8697c15331677e6ebccc"
      ]
    ]
  }
])
print(response)

import { createPublicClient, http } from "viem";

const client = createPublicClient({
  transport: http("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_newFilter)"),
});

const result = await client.request({
  method: "eth_newFilter",
  params: [
  {
    "fromBlock": "0x1",
    "toBlock": "0x2",
    "address": "0x8888f1f195afa192cfee860698584c030f4c9db1",
    "topics": [
      "0x000000000000000000000000a94f5374fce5edbc8e2a8697c15331677e6ebf0b",
      null,
      [
        "0x000000000000000000000000a94f5374fce5edbc8e2a8697c15331677e6ebf0b",
        "0x0000000000000000000000000aff3454fce5edbc8cca8697c15331677e6ebccc"
      ]
    ]
  }
],
});

console.log(result);

const endpoint = "wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_newFilter)";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({ jsonrpc: "2.0", method: "eth_newFilter", params: [
  {
    "fromBlock": "0x1",
    "toBlock": "0x2",
    "address": "0x8888f1f195afa192cfee860698584c030f4c9db1",
    "topics": [
      "0x000000000000000000000000a94f5374fce5edbc8e2a8697c15331677e6ebf0b",
      null,
      [
        "0x000000000000000000000000a94f5374fce5edbc8e2a8697c15331677e6ebf0b",
        "0x0000000000000000000000000aff3454fce5edbc8cca8697c15331677e6ebccc"
      ]
    ]
  }
], id: 1 });
console.log(result);

const response = await fetch('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_newFilter)', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "eth_newFilter",
      "id": 73,
      "params": [
        {
          "fromBlock": "0x1",
          "toBlock": "0x2",
          "address": "0x8888f1f195afa192cfee860698584c030f4c9db1",
          "topics": [
            "0x000000000000000000000000a94f5374fce5edbc8e2a8697c15331677e6ebf0b",
            null,
            [
              "0x000000000000000000000000a94f5374fce5edbc8e2a8697c15331677e6ebf0b",
              "0x0000000000000000000000000aff3454fce5edbc8cca8697c15331677e6ebccc"
            ]
          ]
        }
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "eth_newFilter",
  "id": 73,
  "params": [
    {
      "fromBlock": "0x1",
      "toBlock": "0x2",
      "address": "0x8888f1f195afa192cfee860698584c030f4c9db1",
      "topics": [
        "0x000000000000000000000000a94f5374fce5edbc8e2a8697c15331677e6ebf0b",
        null,
        [
          "0x000000000000000000000000a94f5374fce5edbc8e2a8697c15331677e6ebf0b",
          "0x0000000000000000000000000aff3454fce5edbc8cca8697c15331677e6ebccc"
        ]
      ]
    }
  ]
}

response = requests.post('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_newFilter)', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_newFilter)')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "jsonrpc": "2.0",
    "method": "eth_newFilter",
    "id": 73,
    "params": [
      {
        "fromBlock": "0x1",
        "toBlock": "0x2",
        "address": "0x8888f1f195afa192cfee860698584c030f4c9db1",
        "topics": [
          "0x000000000000000000000000a94f5374fce5edbc8e2a8697c15331677e6ebf0b",
          null,
          [
            "0x000000000000000000000000a94f5374fce5edbc8e2a8697c15331677e6ebf0b",
            "0x0000000000000000000000000aff3454fce5edbc8cca8697c15331677e6ebccc"
          ]
        ]
      }
    ]
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

Request Body

{
  "jsonrpc": "2.0",
  "method": "eth_newFilter",
  "id": 73,
  "params": [
    {
      "fromBlock": "0x1",
      "toBlock": "0x2",
      "address": "0x8888f1f195afa192cfee860698584c030f4c9db1",
      "topics": [
        "0x000000000000000000000000a94f5374fce5edbc8e2a8697c15331677e6ebf0b",
        null,
        [
          "0x000000000000000000000000a94f5374fce5edbc8e2a8697c15331677e6ebf0b",
          "0x0000000000000000000000000aff3454fce5edbc8cca8697c15331677e6ebccc"
        ]
      ]
    }
  ]
}

200

{
  "jsonrpc": "2.0",
  "id": 73,
  "result": "0xcee1fa075b18c4fd1b8e58fe6bbc9594"
}

Creates a new-block filter.

POST

wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_newBlockFilter)

Authorizations

ApiKeyAuthApiKeyAuth

apiKey string

NOWNodes API key passed in the api-key header.

Creates a filter in the node to notify when a new block arrives; poll it with eth_getFilterChanges.

Sent as a JSON text message over the WebSocket connection wss://monad.nownodes.io/wss/{apiKey}.

Body

application/json

WebSocket request envelope for eth_newBlockFilter, sent as a JSON text message.

WebSocket text-message request envelope sent over the single WSS connection.

jsonrpcstringrequired

JSON-RPC protocol version.

methodstringrequired

JSON-RPC method name.

paramsarray | object

Method parameters (array or object); omit for parameterless methods.

idinteger | string

Client-chosen request identifier echoed in the response.

Parameters

apiKeystringrequiredpath

NOWNodes API key - the last path segment of the WebSocket URL (wss://monad.nownodes.io/wss/{apiKey}).

Response

200OK

Response delivered on the same WebSocket connection. JSON-RPC errors arrive as regular messages (no HTTP status change); subscription pushes arrive as eth_subscription notifications.

Creates a new-block filter.

curl -X POST 'wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_newBlockFilter)' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_newBlockFilter",
    "id": 1,
    "params": []
  }'

import { JsonRpcProvider } from "ethers";

const provider = new JsonRpcProvider("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_newBlockFilter)");
const result = await provider.send("eth_newBlockFilter", []);
console.log(result);

require 'eth'
require 'json'
require 'net/http'

uri = URI('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_newBlockFilter)')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
  "jsonrpc": "2.0",
  "method": "eth_newBlockFilter",
  "params": [],
  "id": 1
}'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end

puts JSON.parse(response.body)

from web3 import Web3

w3 = Web3(Web3.HTTPProvider("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_newBlockFilter)"))
response = w3.provider.make_request("eth_newBlockFilter", [])
print(response)

import { createPublicClient, http } from "viem";

const client = createPublicClient({
  transport: http("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_newBlockFilter)"),
});

const result = await client.request({
  method: "eth_newBlockFilter",
  params: [],
});

console.log(result);

const endpoint = "wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_newBlockFilter)";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({ jsonrpc: "2.0", method: "eth_newBlockFilter", params: [], id: 1 });
console.log(result);

const response = await fetch('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_newBlockFilter)', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "eth_newBlockFilter",
      "id": 1,
      "params": []
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "eth_newBlockFilter",
  "id": 1,
  "params": []
}

response = requests.post('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_newBlockFilter)', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_newBlockFilter)')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "jsonrpc": "2.0",
    "method": "eth_newBlockFilter",
    "id": 1,
    "params": []
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

Request Body

{
  "jsonrpc": "2.0",
  "method": "eth_newBlockFilter",
  "id": 1,
  "params": []
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": "0xaf9a08536d6b7769455bda015537e9e9"
}

Creates a pending-transaction filter.

POST

wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_newPendingTransactionFilter)

Authorizations

ApiKeyAuthApiKeyAuth

apiKey string

NOWNodes API key passed in the api-key header.

Creates a filter in the node to notify when new pending transactions arrive; poll it with eth_getFilterChanges.

Sent as a JSON text message over the WebSocket connection wss://monad.nownodes.io/wss/{apiKey}.

Body

application/json

WebSocket request envelope for eth_newPendingTransactionFilter, sent as a JSON text message.

WebSocket text-message request envelope sent over the single WSS connection.

jsonrpcstringrequired

JSON-RPC protocol version.

methodstringrequired

JSON-RPC method name.

paramsarray | object

Method parameters (array or object); omit for parameterless methods.

idinteger | string

Client-chosen request identifier echoed in the response.

Parameters

apiKeystringrequiredpath

NOWNodes API key - the last path segment of the WebSocket URL (wss://monad.nownodes.io/wss/{apiKey}).

Response

200OK

Response delivered on the same WebSocket connection. JSON-RPC errors arrive as regular messages (no HTTP status change); subscription pushes arrive as eth_subscription notifications.

Creates a pending-transaction filter.

curl -X POST 'wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_newPendingTransactionFilter)' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_newPendingTransactionFilter",
    "id": 1,
    "params": []
  }'

import { JsonRpcProvider } from "ethers";

const provider = new JsonRpcProvider("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_newPendingTransactionFilter)");
const result = await provider.send("eth_newPendingTransactionFilter", []);
console.log(result);

require 'eth'
require 'json'
require 'net/http'

uri = URI('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_newPendingTransactionFilter)')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
  "jsonrpc": "2.0",
  "method": "eth_newPendingTransactionFilter",
  "params": [],
  "id": 1
}'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end

puts JSON.parse(response.body)

from web3 import Web3

w3 = Web3(Web3.HTTPProvider("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_newPendingTransactionFilter)"))
response = w3.provider.make_request("eth_newPendingTransactionFilter", [])
print(response)

import { createPublicClient, http } from "viem";

const client = createPublicClient({
  transport: http("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_newPendingTransactionFilter)"),
});

const result = await client.request({
  method: "eth_newPendingTransactionFilter",
  params: [],
});

console.log(result);

const endpoint = "wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_newPendingTransactionFilter)";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({ jsonrpc: "2.0", method: "eth_newPendingTransactionFilter", params: [], id: 1 });
console.log(result);

const response = await fetch('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_newPendingTransactionFilter)', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "eth_newPendingTransactionFilter",
      "id": 1,
      "params": []
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "eth_newPendingTransactionFilter",
  "id": 1,
  "params": []
}

response = requests.post('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_newPendingTransactionFilter)', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_newPendingTransactionFilter)')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "jsonrpc": "2.0",
    "method": "eth_newPendingTransactionFilter",
    "id": 1,
    "params": []
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

Request Body

{
  "jsonrpc": "2.0",
  "method": "eth_newPendingTransactionFilter",
  "id": 1,
  "params": []
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": "0x3785d8c95d83c935d03bb57f8d7647f7"
}

Removes a filter.

POST

wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_uninstallFilter)

Authorizations

ApiKeyAuthApiKeyAuth

apiKey string

NOWNodes API key passed in the api-key header.

Uninstalls a filter with the given id; should always be called when the filter is no longer needed.

Sent as a JSON text message over the WebSocket connection wss://monad.nownodes.io/wss/{apiKey}.

Body

application/json

WebSocket request envelope for eth_uninstallFilter, sent as a JSON text message.

WebSocket text-message request envelope sent over the single WSS connection.

jsonrpcstringrequired

JSON-RPC protocol version.

methodstringrequired

JSON-RPC method name.

paramsarray | object

Method parameters (array or object); omit for parameterless methods.

idinteger | string

Client-chosen request identifier echoed in the response.

Parameters

apiKeystringrequiredpath

NOWNodes API key - the last path segment of the WebSocket URL (wss://monad.nownodes.io/wss/{apiKey}).

Response

200OK

Response delivered on the same WebSocket connection. JSON-RPC errors arrive as regular messages (no HTTP status change); subscription pushes arrive as eth_subscription notifications.

Removes a filter.

curl -X POST 'wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_uninstallFilter)' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_uninstallFilter",
    "id": 73,
    "params": [
      "0xb"
    ]
  }'

import { JsonRpcProvider } from "ethers";

const provider = new JsonRpcProvider("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_uninstallFilter)");
const result = await provider.send("eth_uninstallFilter", [
  "0xb"
]);
console.log(result);

require 'eth'
require 'json'
require 'net/http'

uri = URI('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_uninstallFilter)')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
  "jsonrpc": "2.0",
  "method": "eth_uninstallFilter",
  "params": [
    "0xb"
  ],
  "id": 1
}'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end

puts JSON.parse(response.body)

from web3 import Web3

w3 = Web3(Web3.HTTPProvider("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_uninstallFilter)"))
response = w3.provider.make_request("eth_uninstallFilter", [
  "0xb"
])
print(response)

import { createPublicClient, http } from "viem";

const client = createPublicClient({
  transport: http("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_uninstallFilter)"),
});

const result = await client.request({
  method: "eth_uninstallFilter",
  params: [
  "0xb"
],
});

console.log(result);

const endpoint = "wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_uninstallFilter)";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({ jsonrpc: "2.0", method: "eth_uninstallFilter", params: [
  "0xb"
], id: 1 });
console.log(result);

const response = await fetch('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_uninstallFilter)', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "eth_uninstallFilter",
      "id": 73,
      "params": [
        "0xb"
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "eth_uninstallFilter",
  "id": 73,
  "params": [
    "0xb"
  ]
}

response = requests.post('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_uninstallFilter)', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_uninstallFilter)')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "jsonrpc": "2.0",
    "method": "eth_uninstallFilter",
    "id": 73,
    "params": [
      "0xb"
    ]
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

Request Body

{
  "jsonrpc": "2.0",
  "method": "eth_uninstallFilter",
  "id": 73,
  "params": [
    "0xb"
  ]
}

200

{
  "jsonrpc": "2.0",
  "id": 73,
  "result": false
}

Polls a filter for changes.

POST

wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getFilterChanges)

Authorizations

ApiKeyAuthApiKeyAuth

apiKey string

NOWNodes API key passed in the api-key header.

Polling method for a filter, returning an array of logs (log filters) or block/transaction hashes (block / pending-transaction filters) which occurred since the last poll.

Sent as a JSON text message over the WebSocket connection wss://monad.nownodes.io/wss/{apiKey}.

Body

application/json

WebSocket request envelope for eth_getFilterChanges, sent as a JSON text message.

WebSocket text-message request envelope sent over the single WSS connection.

jsonrpcstringrequired

JSON-RPC protocol version.

methodstringrequired

JSON-RPC method name.

paramsarray | object

Method parameters (array or object); omit for parameterless methods.

idinteger | string

Client-chosen request identifier echoed in the response.

Parameters

apiKeystringrequiredpath

NOWNodes API key - the last path segment of the WebSocket URL (wss://monad.nownodes.io/wss/{apiKey}).

Response

200OK

Response delivered on the same WebSocket connection. JSON-RPC errors arrive as regular messages (no HTTP status change); subscription pushes arrive as eth_subscription notifications.

Polls a filter for changes.

curl -X POST 'wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getFilterChanges)' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_getFilterChanges",
    "id": 73,
    "params": [
      "0x16"
    ]
  }'

import { JsonRpcProvider } from "ethers";

const provider = new JsonRpcProvider("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getFilterChanges)");
const result = await provider.send("eth_getFilterChanges", [
  "0x16"
]);
console.log(result);

require 'eth'
require 'json'
require 'net/http'

uri = URI('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getFilterChanges)')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
  "jsonrpc": "2.0",
  "method": "eth_getFilterChanges",
  "params": [
    "0x16"
  ],
  "id": 1
}'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end

puts JSON.parse(response.body)

from web3 import Web3

w3 = Web3(Web3.HTTPProvider("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getFilterChanges)"))
response = w3.provider.make_request("eth_getFilterChanges", [
  "0x16"
])
print(response)

import { createPublicClient, http } from "viem";

const client = createPublicClient({
  transport: http("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getFilterChanges)"),
});

const result = await client.request({
  method: "eth_getFilterChanges",
  params: [
  "0x16"
],
});

console.log(result);

const endpoint = "wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getFilterChanges)";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({ jsonrpc: "2.0", method: "eth_getFilterChanges", params: [
  "0x16"
], id: 1 });
console.log(result);

const response = await fetch('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getFilterChanges)', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "eth_getFilterChanges",
      "id": 73,
      "params": [
        "0x16"
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "eth_getFilterChanges",
  "id": 73,
  "params": [
    "0x16"
  ]
}

response = requests.post('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getFilterChanges)', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getFilterChanges)')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "jsonrpc": "2.0",
    "method": "eth_getFilterChanges",
    "id": 73,
    "params": [
      "0x16"
    ]
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

Request Body

{
  "jsonrpc": "2.0",
  "method": "eth_getFilterChanges",
  "id": 73,
  "params": [
    "0x16"
  ]
}

200

{
  "jsonrpc": "2.0",
  "id": 73,
  "error": {
    "code": -32000,
    "message": "filter not found"
  }
}

Returns all logs of a filter.

POST

wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getFilterLogs)

Authorizations

ApiKeyAuthApiKeyAuth

apiKey string

NOWNodes API key passed in the api-key header.

Returns an array of all logs matching the filter with the given id (created with eth_newFilter).

Sent as a JSON text message over the WebSocket connection wss://monad.nownodes.io/wss/{apiKey}.

Body

application/json

WebSocket request envelope for eth_getFilterLogs, sent as a JSON text message.

WebSocket text-message request envelope sent over the single WSS connection.

jsonrpcstringrequired

JSON-RPC protocol version.

methodstringrequired

JSON-RPC method name.

paramsarray | object

Method parameters (array or object); omit for parameterless methods.

idinteger | string

Client-chosen request identifier echoed in the response.

Parameters

apiKeystringrequiredpath

NOWNodes API key - the last path segment of the WebSocket URL (wss://monad.nownodes.io/wss/{apiKey}).

Response

200OK

Response delivered on the same WebSocket connection. JSON-RPC errors arrive as regular messages (no HTTP status change); subscription pushes arrive as eth_subscription notifications.

Returns all logs of a filter.

curl -X POST 'wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getFilterLogs)' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_getFilterLogs",
    "id": 74,
    "params": [
      "0x16"
    ]
  }'

import { JsonRpcProvider } from "ethers";

const provider = new JsonRpcProvider("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getFilterLogs)");
const result = await provider.send("eth_getFilterLogs", [
  "0x16"
]);
console.log(result);

require 'eth'
require 'json'
require 'net/http'

uri = URI('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getFilterLogs)')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
  "jsonrpc": "2.0",
  "method": "eth_getFilterLogs",
  "params": [
    "0x16"
  ],
  "id": 1
}'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end

puts JSON.parse(response.body)

from web3 import Web3

w3 = Web3(Web3.HTTPProvider("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getFilterLogs)"))
response = w3.provider.make_request("eth_getFilterLogs", [
  "0x16"
])
print(response)

import { createPublicClient, http } from "viem";

const client = createPublicClient({
  transport: http("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getFilterLogs)"),
});

const result = await client.request({
  method: "eth_getFilterLogs",
  params: [
  "0x16"
],
});

console.log(result);

const endpoint = "wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getFilterLogs)";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({ jsonrpc: "2.0", method: "eth_getFilterLogs", params: [
  "0x16"
], id: 1 });
console.log(result);

const response = await fetch('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getFilterLogs)', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "eth_getFilterLogs",
      "id": 74,
      "params": [
        "0x16"
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "eth_getFilterLogs",
  "id": 74,
  "params": [
    "0x16"
  ]
}

response = requests.post('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getFilterLogs)', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getFilterLogs)')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "jsonrpc": "2.0",
    "method": "eth_getFilterLogs",
    "id": 74,
    "params": [
      "0x16"
    ]
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

Request Body

{
  "jsonrpc": "2.0",
  "method": "eth_getFilterLogs",
  "id": 74,
  "params": [
    "0x16"
  ]
}

200

{
  "jsonrpc": "2.0",
  "id": 74,
  "error": {
    "code": -32000,
    "message": "filter not found"
  }
}

Returns logs matching a filter object.

POST

wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getLogs)

Authorizations

ApiKeyAuthApiKeyAuth

apiKey string

NOWNodes API key passed in the api-key header.

Returns an array of all logs matching the given filter object ({fromBlock, toBlock, address, topics, blockHash}).

Sent as a JSON text message over the WebSocket connection wss://monad.nownodes.io/wss/{apiKey}.

Body

application/json

WebSocket request envelope for eth_getLogs, sent as a JSON text message.

WebSocket text-message request envelope sent over the single WSS connection.

jsonrpcstringrequired

JSON-RPC protocol version.

methodstringrequired

JSON-RPC method name.

paramsarray | object

Method parameters (array or object); omit for parameterless methods.

idinteger | string

Client-chosen request identifier echoed in the response.

Parameters

apiKeystringrequiredpath

NOWNodes API key - the last path segment of the WebSocket URL (wss://monad.nownodes.io/wss/{apiKey}).

Response

200OK

Response delivered on the same WebSocket connection. JSON-RPC errors arrive as regular messages (no HTTP status change); subscription pushes arrive as eth_subscription notifications.

Returns logs matching a filter object.

curl -X POST 'wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getLogs)' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_getLogs",
    "id": 74,
    "params": [
      {
        "topics": [
          "0x000000000000000000000000a94f5374fce5edbc8e2a8697c15331677e6ebf0b"
        ]
      }
    ]
  }'

import { JsonRpcProvider } from "ethers";

const provider = new JsonRpcProvider("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getLogs)");
const result = await provider.send("eth_getLogs", [
  {
    "topics": [
      "0x000000000000000000000000a94f5374fce5edbc8e2a8697c15331677e6ebf0b"
    ]
  }
]);
console.log(result);

require 'eth'
require 'json'
require 'net/http'

uri = URI('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getLogs)')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
  "jsonrpc": "2.0",
  "method": "eth_getLogs",
  "params": [
    {
      "topics": [
        "0x000000000000000000000000a94f5374fce5edbc8e2a8697c15331677e6ebf0b"
      ]
    }
  ],
  "id": 1
}'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end

puts JSON.parse(response.body)

from web3 import Web3

w3 = Web3(Web3.HTTPProvider("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getLogs)"))
response = w3.provider.make_request("eth_getLogs", [
  {
    "topics": [
      "0x000000000000000000000000a94f5374fce5edbc8e2a8697c15331677e6ebf0b"
    ]
  }
])
print(response)

import { createPublicClient, http } from "viem";

const client = createPublicClient({
  transport: http("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getLogs)"),
});

const result = await client.request({
  method: "eth_getLogs",
  params: [
  {
    "topics": [
      "0x000000000000000000000000a94f5374fce5edbc8e2a8697c15331677e6ebf0b"
    ]
  }
],
});

console.log(result);

const endpoint = "wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getLogs)";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({ jsonrpc: "2.0", method: "eth_getLogs", params: [
  {
    "topics": [
      "0x000000000000000000000000a94f5374fce5edbc8e2a8697c15331677e6ebf0b"
    ]
  }
], id: 1 });
console.log(result);

const response = await fetch('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getLogs)', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "eth_getLogs",
      "id": 74,
      "params": [
        {
          "topics": [
            "0x000000000000000000000000a94f5374fce5edbc8e2a8697c15331677e6ebf0b"
          ]
        }
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "eth_getLogs",
  "id": 74,
  "params": [
    {
      "topics": [
        "0x000000000000000000000000a94f5374fce5edbc8e2a8697c15331677e6ebf0b"
      ]
    }
  ]
}

response = requests.post('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getLogs)', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_getLogs)')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "jsonrpc": "2.0",
    "method": "eth_getLogs",
    "id": 74,
    "params": [
      {
        "topics": [
          "0x000000000000000000000000a94f5374fce5edbc8e2a8697c15331677e6ebf0b"
        ]
      }
    ]
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

Request Body

{
  "jsonrpc": "2.0",
  "method": "eth_getLogs",
  "id": 74,
  "params": [
    {
      "topics": [
        "0x000000000000000000000000a94f5374fce5edbc8e2a8697c15331677e6ebf0b"
      ]
    }
  ]
}

200

{
  "jsonrpc": "2.0",
  "id": 74,
  "result": []
}

Signing & Broadcast

Transaction signing and broadcast (write operations).

Broadcasts a signed raw transaction.

POST

wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_sendRawTransaction)

Authorizations

ApiKeyAuthApiKeyAuth

apiKey string

NOWNodes API key passed in the api-key header.

Creates a new message call transaction or a contract creation for signed transactions. WRITE operation: the error example shows the standard RLP validation failure for a malformed payload.

Sent as a JSON text message over the WebSocket connection wss://monad.nownodes.io/wss/{apiKey}.

Body

application/json

WebSocket request envelope for eth_sendRawTransaction, sent as a JSON text message.

WebSocket text-message request envelope sent over the single WSS connection.

jsonrpcstringrequired

JSON-RPC protocol version.

methodstringrequired

JSON-RPC method name.

paramsarray | object

Method parameters (array or object); omit for parameterless methods.

idinteger | string

Client-chosen request identifier echoed in the response.

Parameters

apiKeystringrequiredpath

NOWNodes API key - the last path segment of the WebSocket URL (wss://monad.nownodes.io/wss/{apiKey}).

Response

200OK

Response delivered on the same WebSocket connection. JSON-RPC errors arrive as regular messages (no HTTP status change); subscription pushes arrive as eth_subscription notifications.

Broadcasts a signed raw transaction.

curl -X POST 'wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_sendRawTransaction)' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_sendRawTransaction",
    "id": 1,
    "params": [
      "0xd46e8dd67c5d32be8d46e8dd67c5d32be8058bb8eb970870f072445675058bb8eb970870f072445675"
    ]
  }'

import { JsonRpcProvider } from "ethers";

const provider = new JsonRpcProvider("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_sendRawTransaction)");
const result = await provider.send("eth_sendRawTransaction", [
  "0xd46e8dd67c5d32be8d46e8dd67c5d32be8058bb8eb970870f072445675058bb8eb970870f072445675"
]);
console.log(result);

require 'eth'
require 'json'
require 'net/http'

uri = URI('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_sendRawTransaction)')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
  "jsonrpc": "2.0",
  "method": "eth_sendRawTransaction",
  "params": [
    "0xd46e8dd67c5d32be8d46e8dd67c5d32be8058bb8eb970870f072445675058bb8eb970870f072445675"
  ],
  "id": 1
}'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end

puts JSON.parse(response.body)

from web3 import Web3

w3 = Web3(Web3.HTTPProvider("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_sendRawTransaction)"))
response = w3.provider.make_request("eth_sendRawTransaction", [
  "0xd46e8dd67c5d32be8d46e8dd67c5d32be8058bb8eb970870f072445675058bb8eb970870f072445675"
])
print(response)

import { createPublicClient, http } from "viem";

const client = createPublicClient({
  transport: http("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_sendRawTransaction)"),
});

const result = await client.request({
  method: "eth_sendRawTransaction",
  params: [
  "0xd46e8dd67c5d32be8d46e8dd67c5d32be8058bb8eb970870f072445675058bb8eb970870f072445675"
],
});

console.log(result);

const endpoint = "wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_sendRawTransaction)";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({ jsonrpc: "2.0", method: "eth_sendRawTransaction", params: [
  "0xd46e8dd67c5d32be8d46e8dd67c5d32be8058bb8eb970870f072445675058bb8eb970870f072445675"
], id: 1 });
console.log(result);

const response = await fetch('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_sendRawTransaction)', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "eth_sendRawTransaction",
      "id": 1,
      "params": [
        "0xd46e8dd67c5d32be8d46e8dd67c5d32be8058bb8eb970870f072445675058bb8eb970870f072445675"
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "eth_sendRawTransaction",
  "id": 1,
  "params": [
    "0xd46e8dd67c5d32be8d46e8dd67c5d32be8058bb8eb970870f072445675058bb8eb970870f072445675"
  ]
}

response = requests.post('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_sendRawTransaction)', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_sendRawTransaction)')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "jsonrpc": "2.0",
    "method": "eth_sendRawTransaction",
    "id": 1,
    "params": [
      "0xd46e8dd67c5d32be8d46e8dd67c5d32be8058bb8eb970870f072445675058bb8eb970870f072445675"
    ]
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

Request Body

{
  "jsonrpc": "2.0",
  "method": "eth_sendRawTransaction",
  "id": 1,
  "params": [
    "0xd46e8dd67c5d32be8d46e8dd67c5d32be8058bb8eb970870f072445675058bb8eb970870f072445675"
  ]
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "error": {
    "code": -32000,
    "message": "rlp: element is larger than containing list"
  }
}

Sends a transaction from a node-managed account.

POST

wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_sendTransaction)

Authorizations

ApiKeyAuthApiKeyAuth

apiKey string

NOWNodes API key passed in the api-key header.

Creates a new message call transaction or a contract creation. Requires the sender account to be managed by the node; NOWNodes endpoints do not manage accounts, so the call answers with the unknown account error. WRITE operation.

Sent as a JSON text message over the WebSocket connection wss://monad.nownodes.io/wss/{apiKey}.

Body

application/json

WebSocket request envelope for eth_sendTransaction, sent as a JSON text message.

WebSocket text-message request envelope sent over the single WSS connection.

jsonrpcstringrequired

JSON-RPC protocol version.

methodstringrequired

JSON-RPC method name.

paramsarray | object

Method parameters (array or object); omit for parameterless methods.

idinteger | string

Client-chosen request identifier echoed in the response.

Parameters

apiKeystringrequiredpath

NOWNodes API key - the last path segment of the WebSocket URL (wss://monad.nownodes.io/wss/{apiKey}).

Response

200OK

Response delivered on the same WebSocket connection. JSON-RPC errors arrive as regular messages (no HTTP status change); subscription pushes arrive as eth_subscription notifications.

Sends a transaction from a node-managed account.

curl -X POST 'wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_sendTransaction)' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_sendTransaction",
    "id": 1,
    "params": [
      {
        "from": "0xb60e8dd61c5d32be8058bb8eb970870f07233155",
        "data": "0xd46e8dd67c5d32be8d46e8dd67c5d32be8058bb8eb970870f072445675058bb8eb970870f072445675"
      }
    ]
  }'

import { JsonRpcProvider } from "ethers";

const provider = new JsonRpcProvider("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_sendTransaction)");
const result = await provider.send("eth_sendTransaction", [
  {
    "from": "0xb60e8dd61c5d32be8058bb8eb970870f07233155",
    "data": "0xd46e8dd67c5d32be8d46e8dd67c5d32be8058bb8eb970870f072445675058bb8eb970870f072445675"
  }
]);
console.log(result);

require 'eth'
require 'json'
require 'net/http'

uri = URI('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_sendTransaction)')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
  "jsonrpc": "2.0",
  "method": "eth_sendTransaction",
  "params": [
    {
      "from": "0xb60e8dd61c5d32be8058bb8eb970870f07233155",
      "data": "0xd46e8dd67c5d32be8d46e8dd67c5d32be8058bb8eb970870f072445675058bb8eb970870f072445675"
    }
  ],
  "id": 1
}'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end

puts JSON.parse(response.body)

from web3 import Web3

w3 = Web3(Web3.HTTPProvider("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_sendTransaction)"))
response = w3.provider.make_request("eth_sendTransaction", [
  {
    "from": "0xb60e8dd61c5d32be8058bb8eb970870f07233155",
    "data": "0xd46e8dd67c5d32be8d46e8dd67c5d32be8058bb8eb970870f072445675058bb8eb970870f072445675"
  }
])
print(response)

import { createPublicClient, http } from "viem";

const client = createPublicClient({
  transport: http("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_sendTransaction)"),
});

const result = await client.request({
  method: "eth_sendTransaction",
  params: [
  {
    "from": "0xb60e8dd61c5d32be8058bb8eb970870f07233155",
    "data": "0xd46e8dd67c5d32be8d46e8dd67c5d32be8058bb8eb970870f072445675058bb8eb970870f072445675"
  }
],
});

console.log(result);

const endpoint = "wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_sendTransaction)";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({ jsonrpc: "2.0", method: "eth_sendTransaction", params: [
  {
    "from": "0xb60e8dd61c5d32be8058bb8eb970870f07233155",
    "data": "0xd46e8dd67c5d32be8d46e8dd67c5d32be8058bb8eb970870f072445675058bb8eb970870f072445675"
  }
], id: 1 });
console.log(result);

const response = await fetch('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_sendTransaction)', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "eth_sendTransaction",
      "id": 1,
      "params": [
        {
          "from": "0xb60e8dd61c5d32be8058bb8eb970870f07233155",
          "data": "0xd46e8dd67c5d32be8d46e8dd67c5d32be8058bb8eb970870f072445675058bb8eb970870f072445675"
        }
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "eth_sendTransaction",
  "id": 1,
  "params": [
    {
      "from": "0xb60e8dd61c5d32be8058bb8eb970870f07233155",
      "data": "0xd46e8dd67c5d32be8d46e8dd67c5d32be8058bb8eb970870f072445675058bb8eb970870f072445675"
    }
  ]
}

response = requests.post('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_sendTransaction)', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_sendTransaction)')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "jsonrpc": "2.0",
    "method": "eth_sendTransaction",
    "id": 1,
    "params": [
      {
        "from": "0xb60e8dd61c5d32be8058bb8eb970870f07233155",
        "data": "0xd46e8dd67c5d32be8d46e8dd67c5d32be8058bb8eb970870f072445675058bb8eb970870f072445675"
      }
    ]
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

Request Body

{
  "jsonrpc": "2.0",
  "method": "eth_sendTransaction",
  "id": 1,
  "params": [
    {
      "from": "0xb60e8dd61c5d32be8058bb8eb970870f07233155",
      "data": "0xd46e8dd67c5d32be8d46e8dd67c5d32be8058bb8eb970870f072445675058bb8eb970870f072445675"
    }
  ]
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "error": {
    "code": -32000,
    "message": "unknown account"
  }
}

Signs a message with a node-managed account.

POST

wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_sign)

Authorizations

ApiKeyAuthApiKeyAuth

apiKey string

NOWNodes API key passed in the api-key header.

Calculates an Ethereum-specific signature: sign(keccak256("\x19Ethereum Signed Message:\n" + len(message) + message)). Requires a node-managed account, so public endpoints answer with the unknown account error.

Sent as a JSON text message over the WebSocket connection wss://monad.nownodes.io/wss/{apiKey}.

Body

application/json

WebSocket request envelope for eth_sign, sent as a JSON text message.

WebSocket text-message request envelope sent over the single WSS connection.

jsonrpcstringrequired

JSON-RPC protocol version.

methodstringrequired

JSON-RPC method name.

paramsarray | object

Method parameters (array or object); omit for parameterless methods.

idinteger | string

Client-chosen request identifier echoed in the response.

Parameters

apiKeystringrequiredpath

NOWNodes API key - the last path segment of the WebSocket URL (wss://monad.nownodes.io/wss/{apiKey}).

Response

200OK

Response delivered on the same WebSocket connection. JSON-RPC errors arrive as regular messages (no HTTP status change); subscription pushes arrive as eth_subscription notifications.

Signs a message with a node-managed account.

curl -X POST 'wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_sign)' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_sign",
    "id": 1,
    "params": [
      "0x9b2055d370f73ec7d8a03e965129118dc8f5bf83",
      "0xdeadbeaf"
    ]
  }'

import { JsonRpcProvider } from "ethers";

const provider = new JsonRpcProvider("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_sign)");
const result = await provider.send("eth_sign", [
  "0x9b2055d370f73ec7d8a03e965129118dc8f5bf83",
  "0xdeadbeaf"
]);
console.log(result);

require 'eth'
require 'json'
require 'net/http'

uri = URI('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_sign)')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
  "jsonrpc": "2.0",
  "method": "eth_sign",
  "params": [
    "0x9b2055d370f73ec7d8a03e965129118dc8f5bf83",
    "0xdeadbeaf"
  ],
  "id": 1
}'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end

puts JSON.parse(response.body)

from web3 import Web3

w3 = Web3(Web3.HTTPProvider("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_sign)"))
response = w3.provider.make_request("eth_sign", [
  "0x9b2055d370f73ec7d8a03e965129118dc8f5bf83",
  "0xdeadbeaf"
])
print(response)

import { createPublicClient, http } from "viem";

const client = createPublicClient({
  transport: http("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_sign)"),
});

const result = await client.request({
  method: "eth_sign",
  params: [
  "0x9b2055d370f73ec7d8a03e965129118dc8f5bf83",
  "0xdeadbeaf"
],
});

console.log(result);

const endpoint = "wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_sign)";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({ jsonrpc: "2.0", method: "eth_sign", params: [
  "0x9b2055d370f73ec7d8a03e965129118dc8f5bf83",
  "0xdeadbeaf"
], id: 1 });
console.log(result);

const response = await fetch('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_sign)', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "eth_sign",
      "id": 1,
      "params": [
        "0x9b2055d370f73ec7d8a03e965129118dc8f5bf83",
        "0xdeadbeaf"
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "eth_sign",
  "id": 1,
  "params": [
    "0x9b2055d370f73ec7d8a03e965129118dc8f5bf83",
    "0xdeadbeaf"
  ]
}

response = requests.post('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_sign)', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_sign)')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "jsonrpc": "2.0",
    "method": "eth_sign",
    "id": 1,
    "params": [
      "0x9b2055d370f73ec7d8a03e965129118dc8f5bf83",
      "0xdeadbeaf"
    ]
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

Request Body

{
  "jsonrpc": "2.0",
  "method": "eth_sign",
  "id": 1,
  "params": [
    "0x9b2055d370f73ec7d8a03e965129118dc8f5bf83",
    "0xdeadbeaf"
  ]
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "error": {
    "code": -32000,
    "message": "unknown account"
  }
}

Signs a transaction with a node-managed account.

POST

wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_signTransaction)

Authorizations

ApiKeyAuthApiKeyAuth

apiKey string

NOWNodes API key passed in the api-key header.

Signs a transaction object with a node-managed account. Public endpoints do not manage accounts; the error example shows the validation error for an incomplete transaction object.

Sent as a JSON text message over the WebSocket connection wss://monad.nownodes.io/wss/{apiKey}.

Body

application/json

WebSocket request envelope for eth_signTransaction, sent as a JSON text message.

WebSocket text-message request envelope sent over the single WSS connection.

jsonrpcstringrequired

JSON-RPC protocol version.

methodstringrequired

JSON-RPC method name.

paramsarray | object

Method parameters (array or object); omit for parameterless methods.

idinteger | string

Client-chosen request identifier echoed in the response.

Parameters

apiKeystringrequiredpath

NOWNodes API key - the last path segment of the WebSocket URL (wss://monad.nownodes.io/wss/{apiKey}).

Response

200OK

Response delivered on the same WebSocket connection. JSON-RPC errors arrive as regular messages (no HTTP status change); subscription pushes arrive as eth_subscription notifications.

Signs a transaction with a node-managed account.

curl -X POST 'wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_signTransaction)' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_signTransaction",
    "id": 1,
    "params": [
      {
        "data": "0xd46e8dd67c5d32be8d46e8dd67c5d32be8058bb8eb970870f072445675058bb8eb970870f072445675",
        "from": "0xb60e8dd61c5d32be8058bb8eb970870f07233155",
        "gas": "0x76c0",
        "gasPrice": "0x9184e72a000",
        "to": "0xd46e8dd67c5d32be8058bb8eb970870f07244567",
        "value": "0x9184e72a"
      }
    ]
  }'

import { JsonRpcProvider } from "ethers";

const provider = new JsonRpcProvider("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_signTransaction)");
const result = await provider.send("eth_signTransaction", [
  {
    "data": "0xd46e8dd67c5d32be8d46e8dd67c5d32be8058bb8eb970870f072445675058bb8eb970870f072445675",
    "from": "0xb60e8dd61c5d32be8058bb8eb970870f07233155",
    "gas": "0x76c0",
    "gasPrice": "0x9184e72a000",
    "to": "0xd46e8dd67c5d32be8058bb8eb970870f07244567",
    "value": "0x9184e72a"
  }
]);
console.log(result);

require 'eth'
require 'json'
require 'net/http'

uri = URI('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_signTransaction)')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
  "jsonrpc": "2.0",
  "method": "eth_signTransaction",
  "params": [
    {
      "data": "0xd46e8dd67c5d32be8d46e8dd67c5d32be8058bb8eb970870f072445675058bb8eb970870f072445675",
      "from": "0xb60e8dd61c5d32be8058bb8eb970870f07233155",
      "gas": "0x76c0",
      "gasPrice": "0x9184e72a000",
      "to": "0xd46e8dd67c5d32be8058bb8eb970870f07244567",
      "value": "0x9184e72a"
    }
  ],
  "id": 1
}'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end

puts JSON.parse(response.body)

from web3 import Web3

w3 = Web3(Web3.HTTPProvider("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_signTransaction)"))
response = w3.provider.make_request("eth_signTransaction", [
  {
    "data": "0xd46e8dd67c5d32be8d46e8dd67c5d32be8058bb8eb970870f072445675058bb8eb970870f072445675",
    "from": "0xb60e8dd61c5d32be8058bb8eb970870f07233155",
    "gas": "0x76c0",
    "gasPrice": "0x9184e72a000",
    "to": "0xd46e8dd67c5d32be8058bb8eb970870f07244567",
    "value": "0x9184e72a"
  }
])
print(response)

import { createPublicClient, http } from "viem";

const client = createPublicClient({
  transport: http("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_signTransaction)"),
});

const result = await client.request({
  method: "eth_signTransaction",
  params: [
  {
    "data": "0xd46e8dd67c5d32be8d46e8dd67c5d32be8058bb8eb970870f072445675058bb8eb970870f072445675",
    "from": "0xb60e8dd61c5d32be8058bb8eb970870f07233155",
    "gas": "0x76c0",
    "gasPrice": "0x9184e72a000",
    "to": "0xd46e8dd67c5d32be8058bb8eb970870f07244567",
    "value": "0x9184e72a"
  }
],
});

console.log(result);

const endpoint = "wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_signTransaction)";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({ jsonrpc: "2.0", method: "eth_signTransaction", params: [
  {
    "data": "0xd46e8dd67c5d32be8d46e8dd67c5d32be8058bb8eb970870f072445675058bb8eb970870f072445675",
    "from": "0xb60e8dd61c5d32be8058bb8eb970870f07233155",
    "gas": "0x76c0",
    "gasPrice": "0x9184e72a000",
    "to": "0xd46e8dd67c5d32be8058bb8eb970870f07244567",
    "value": "0x9184e72a"
  }
], id: 1 });
console.log(result);

const response = await fetch('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_signTransaction)', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "eth_signTransaction",
      "id": 1,
      "params": [
        {
          "data": "0xd46e8dd67c5d32be8d46e8dd67c5d32be8058bb8eb970870f072445675058bb8eb970870f072445675",
          "from": "0xb60e8dd61c5d32be8058bb8eb970870f07233155",
          "gas": "0x76c0",
          "gasPrice": "0x9184e72a000",
          "to": "0xd46e8dd67c5d32be8058bb8eb970870f07244567",
          "value": "0x9184e72a"
        }
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "eth_signTransaction",
  "id": 1,
  "params": [
    {
      "data": "0xd46e8dd67c5d32be8d46e8dd67c5d32be8058bb8eb970870f072445675058bb8eb970870f072445675",
      "from": "0xb60e8dd61c5d32be8058bb8eb970870f07233155",
      "gas": "0x76c0",
      "gasPrice": "0x9184e72a000",
      "to": "0xd46e8dd67c5d32be8058bb8eb970870f07244567",
      "value": "0x9184e72a"
    }
  ]
}

response = requests.post('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_signTransaction)', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_signTransaction)')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "jsonrpc": "2.0",
    "method": "eth_signTransaction",
    "id": 1,
    "params": [
      {
        "data": "0xd46e8dd67c5d32be8d46e8dd67c5d32be8058bb8eb970870f072445675058bb8eb970870f072445675",
        "from": "0xb60e8dd61c5d32be8058bb8eb970870f07233155",
        "gas": "0x76c0",
        "gasPrice": "0x9184e72a000",
        "to": "0xd46e8dd67c5d32be8058bb8eb970870f07244567",
        "value": "0x9184e72a"
      }
    ]
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

Request Body

{
  "jsonrpc": "2.0",
  "method": "eth_signTransaction",
  "id": 1,
  "params": [
    {
      "data": "0xd46e8dd67c5d32be8d46e8dd67c5d32be8058bb8eb970870f072445675058bb8eb970870f072445675",
      "from": "0xb60e8dd61c5d32be8058bb8eb970870f07233155",
      "gas": "0x76c0",
      "gasPrice": "0x9184e72a000",
      "to": "0xd46e8dd67c5d32be8058bb8eb970870f07244567",
      "value": "0x9184e72a"
    }
  ]
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "error": {
    "code": -32000,
    "message": "nonce not specified"
  }
}

Network & Node

Node and network introspection (net_*, web3_*, eth_coinbase).

Returns the node coinbase / fee recipient.

POST

wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_coinbase)

Authorizations

ApiKeyAuthApiKeyAuth

apiKey string

NOWNodes API key passed in the api-key header.

Returns the coinbase address (fee recipient; on the PoS L1 the validator block proposer) of the node.

Sent as a JSON text message over the WebSocket connection wss://monad.nownodes.io/wss/{apiKey}.

Body

application/json

WebSocket request envelope for eth_coinbase, sent as a JSON text message.

WebSocket text-message request envelope sent over the single WSS connection.

jsonrpcstringrequired

JSON-RPC protocol version.

methodstringrequired

JSON-RPC method name.

paramsarray | object

Method parameters (array or object); omit for parameterless methods.

idinteger | string

Client-chosen request identifier echoed in the response.

Parameters

apiKeystringrequiredpath

NOWNodes API key - the last path segment of the WebSocket URL (wss://monad.nownodes.io/wss/{apiKey}).

Response

200OK

Response delivered on the same WebSocket connection. JSON-RPC errors arrive as regular messages (no HTTP status change); subscription pushes arrive as eth_subscription notifications.

Returns the node coinbase / fee recipient.

curl -X POST 'wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_coinbase)' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_coinbase",
    "id": 64,
    "params": []
  }'

import { JsonRpcProvider } from "ethers";

const provider = new JsonRpcProvider("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_coinbase)");
const result = await provider.send("eth_coinbase", []);
console.log(result);

require 'eth'
require 'json'
require 'net/http'

uri = URI('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_coinbase)')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
  "jsonrpc": "2.0",
  "method": "eth_coinbase",
  "params": [],
  "id": 1
}'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end

puts JSON.parse(response.body)

from web3 import Web3

w3 = Web3(Web3.HTTPProvider("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_coinbase)"))
response = w3.provider.make_request("eth_coinbase", [])
print(response)

import { createPublicClient, http } from "viem";

const client = createPublicClient({
  transport: http("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_coinbase)"),
});

const result = await client.request({
  method: "eth_coinbase",
  params: [],
});

console.log(result);

const endpoint = "wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_coinbase)";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({ jsonrpc: "2.0", method: "eth_coinbase", params: [], id: 1 });
console.log(result);

const response = await fetch('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_coinbase)', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "eth_coinbase",
      "id": 64,
      "params": []
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "eth_coinbase",
  "id": 64,
  "params": []
}

response = requests.post('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_coinbase)', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (eth_coinbase)')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "jsonrpc": "2.0",
    "method": "eth_coinbase",
    "id": 64,
    "params": []
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

Request Body

{
  "jsonrpc": "2.0",
  "method": "eth_coinbase",
  "id": 64,
  "params": []
}

200

{
  "jsonrpc": "2.0",
  "id": 64,
  "result": "0x0000000000000000000000000000000000000000"
}

Returns the network id.

POST

wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (net_version)

Authorizations

ApiKeyAuthApiKeyAuth

apiKey string

NOWNodes API key passed in the api-key header.

Returns the current network id. Monad mainnet network id is 143 (decimal string).

Sent as a JSON text message over the WebSocket connection wss://monad.nownodes.io/wss/{apiKey}.

Body

application/json

WebSocket request envelope for net_version, sent as a JSON text message.

WebSocket text-message request envelope sent over the single WSS connection.

jsonrpcstringrequired

JSON-RPC protocol version.

methodstringrequired

JSON-RPC method name.

paramsarray | object

Method parameters (array or object); omit for parameterless methods.

idinteger | string

Client-chosen request identifier echoed in the response.

Parameters

apiKeystringrequiredpath

NOWNodes API key - the last path segment of the WebSocket URL (wss://monad.nownodes.io/wss/{apiKey}).

Response

200OK

Response delivered on the same WebSocket connection. JSON-RPC errors arrive as regular messages (no HTTP status change); subscription pushes arrive as eth_subscription notifications.

Returns the network id.

curl -X POST 'wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (net_version)' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "net_version",
    "id": 1,
    "params": []
  }'

import { JsonRpcProvider } from "ethers";

const provider = new JsonRpcProvider("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (net_version)");
const result = await provider.send("net_version", []);
console.log(result);

require 'eth'
require 'json'
require 'net/http'

uri = URI('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (net_version)')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
  "jsonrpc": "2.0",
  "method": "net_version",
  "params": [],
  "id": 1
}'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end

puts JSON.parse(response.body)

from web3 import Web3

w3 = Web3(Web3.HTTPProvider("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (net_version)"))
response = w3.provider.make_request("net_version", [])
print(response)

import { createPublicClient, http } from "viem";

const client = createPublicClient({
  transport: http("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (net_version)"),
});

const result = await client.request({
  method: "net_version",
  params: [],
});

console.log(result);

const endpoint = "wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (net_version)";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({ jsonrpc: "2.0", method: "net_version", params: [], id: 1 });
console.log(result);

const response = await fetch('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (net_version)', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "net_version",
      "id": 1,
      "params": []
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "net_version",
  "id": 1,
  "params": []
}

response = requests.post('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (net_version)', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (net_version)')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "jsonrpc": "2.0",
    "method": "net_version",
    "id": 1,
    "params": []
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

Request Body

{
  "jsonrpc": "2.0",
  "method": "net_version",
  "id": 1,
  "params": []
}

200

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

Returns whether the client is listening.

POST

wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (net_listening)

Authorizations

ApiKeyAuthApiKeyAuth

apiKey string

NOWNodes API key passed in the api-key header.

Returns true if the client is actively listening for network connections.

Sent as a JSON text message over the WebSocket connection wss://monad.nownodes.io/wss/{apiKey}.

Body

application/json

WebSocket request envelope for net_listening, sent as a JSON text message.

WebSocket text-message request envelope sent over the single WSS connection.

jsonrpcstringrequired

JSON-RPC protocol version.

methodstringrequired

JSON-RPC method name.

paramsarray | object

Method parameters (array or object); omit for parameterless methods.

idinteger | string

Client-chosen request identifier echoed in the response.

Parameters

apiKeystringrequiredpath

NOWNodes API key - the last path segment of the WebSocket URL (wss://monad.nownodes.io/wss/{apiKey}).

Response

200OK

Response delivered on the same WebSocket connection. JSON-RPC errors arrive as regular messages (no HTTP status change); subscription pushes arrive as eth_subscription notifications.

Returns whether the client is listening.

curl -X POST 'wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (net_listening)' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "net_listening",
    "id": 1
  }'

import { JsonRpcProvider } from "ethers";

const provider = new JsonRpcProvider("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (net_listening)");
const result = await provider.send("net_listening", []);
console.log(result);

require 'eth'
require 'json'
require 'net/http'

uri = URI('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (net_listening)')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
  "jsonrpc": "2.0",
  "method": "net_listening",
  "params": [],
  "id": 1
}'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end

puts JSON.parse(response.body)

from web3 import Web3

w3 = Web3(Web3.HTTPProvider("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (net_listening)"))
response = w3.provider.make_request("net_listening", [])
print(response)

import { createPublicClient, http } from "viem";

const client = createPublicClient({
  transport: http("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (net_listening)"),
});

const result = await client.request({
  method: "net_listening",
  params: [],
});

console.log(result);

const endpoint = "wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (net_listening)";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({ jsonrpc: "2.0", method: "net_listening", params: [], id: 1 });
console.log(result);

const response = await fetch('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (net_listening)', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "net_listening",
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "net_listening",
  "id": 1
}

response = requests.post('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (net_listening)', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (net_listening)')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "jsonrpc": "2.0",
    "method": "net_listening",
    "id": 1
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

Request Body

{
  "jsonrpc": "2.0",
  "method": "net_listening",
  "id": 1
}

200

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

Returns the number of connected peers.

POST

wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (net_peerCount)

Authorizations

ApiKeyAuthApiKeyAuth

apiKey string

NOWNodes API key passed in the api-key header.

Returns the number of peers currently connected to the client, as a hex string.

Sent as a JSON text message over the WebSocket connection wss://monad.nownodes.io/wss/{apiKey}.

Body

application/json

WebSocket request envelope for net_peerCount, sent as a JSON text message.

WebSocket text-message request envelope sent over the single WSS connection.

jsonrpcstringrequired

JSON-RPC protocol version.

methodstringrequired

JSON-RPC method name.

paramsarray | object

Method parameters (array or object); omit for parameterless methods.

idinteger | string

Client-chosen request identifier echoed in the response.

Parameters

apiKeystringrequiredpath

NOWNodes API key - the last path segment of the WebSocket URL (wss://monad.nownodes.io/wss/{apiKey}).

Response

200OK

Response delivered on the same WebSocket connection. JSON-RPC errors arrive as regular messages (no HTTP status change); subscription pushes arrive as eth_subscription notifications.

Returns the number of connected peers.

curl -X POST 'wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (net_peerCount)' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "net_peerCount",
    "id": 74,
    "params": []
  }'

import { JsonRpcProvider } from "ethers";

const provider = new JsonRpcProvider("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (net_peerCount)");
const result = await provider.send("net_peerCount", []);
console.log(result);

require 'eth'
require 'json'
require 'net/http'

uri = URI('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (net_peerCount)')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
  "jsonrpc": "2.0",
  "method": "net_peerCount",
  "params": [],
  "id": 1
}'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end

puts JSON.parse(response.body)

from web3 import Web3

w3 = Web3(Web3.HTTPProvider("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (net_peerCount)"))
response = w3.provider.make_request("net_peerCount", [])
print(response)

import { createPublicClient, http } from "viem";

const client = createPublicClient({
  transport: http("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (net_peerCount)"),
});

const result = await client.request({
  method: "net_peerCount",
  params: [],
});

console.log(result);

const endpoint = "wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (net_peerCount)";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({ jsonrpc: "2.0", method: "net_peerCount", params: [], id: 1 });
console.log(result);

const response = await fetch('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (net_peerCount)', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "net_peerCount",
      "id": 74,
      "params": []
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "net_peerCount",
  "id": 74,
  "params": []
}

response = requests.post('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (net_peerCount)', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (net_peerCount)')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "jsonrpc": "2.0",
    "method": "net_peerCount",
    "id": 74,
    "params": []
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

Request Body

{
  "jsonrpc": "2.0",
  "method": "net_peerCount",
  "id": 74,
  "params": []
}

200

{
  "jsonrpc": "2.0",
  "id": 74,
  "result": "0x0"
}

Returns the client version.

POST

wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (web3_clientVersion)

Authorizations

ApiKeyAuthApiKeyAuth

apiKey string

NOWNodes API key passed in the api-key header.

Returns the web3 client version string of the node.

Sent as a JSON text message over the WebSocket connection wss://monad.nownodes.io/wss/{apiKey}.

Body

application/json

WebSocket request envelope for web3_clientVersion, sent as a JSON text message.

WebSocket text-message request envelope sent over the single WSS connection.

jsonrpcstringrequired

JSON-RPC protocol version.

methodstringrequired

JSON-RPC method name.

paramsarray | object

Method parameters (array or object); omit for parameterless methods.

idinteger | string

Client-chosen request identifier echoed in the response.

Parameters

apiKeystringrequiredpath

NOWNodes API key - the last path segment of the WebSocket URL (wss://monad.nownodes.io/wss/{apiKey}).

Response

200OK

Response delivered on the same WebSocket connection. JSON-RPC errors arrive as regular messages (no HTTP status change); subscription pushes arrive as eth_subscription notifications.

Returns the client version.

curl -X POST 'wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (web3_clientVersion)' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "web3_clientVersion",
    "id": 1,
    "params": []
  }'

import { JsonRpcProvider } from "ethers";

const provider = new JsonRpcProvider("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (web3_clientVersion)");
const result = await provider.send("web3_clientVersion", []);
console.log(result);

require 'eth'
require 'json'
require 'net/http'

uri = URI('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (web3_clientVersion)')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
  "jsonrpc": "2.0",
  "method": "web3_clientVersion",
  "params": [],
  "id": 1
}'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end

puts JSON.parse(response.body)

from web3 import Web3

w3 = Web3(Web3.HTTPProvider("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (web3_clientVersion)"))
response = w3.provider.make_request("web3_clientVersion", [])
print(response)

import { createPublicClient, http } from "viem";

const client = createPublicClient({
  transport: http("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (web3_clientVersion)"),
});

const result = await client.request({
  method: "web3_clientVersion",
  params: [],
});

console.log(result);

const endpoint = "wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (web3_clientVersion)";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({ jsonrpc: "2.0", method: "web3_clientVersion", params: [], id: 1 });
console.log(result);

const response = await fetch('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (web3_clientVersion)', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "web3_clientVersion",
      "id": 1,
      "params": []
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "web3_clientVersion",
  "id": 1,
  "params": []
}

response = requests.post('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (web3_clientVersion)', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (web3_clientVersion)')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "jsonrpc": "2.0",
    "method": "web3_clientVersion",
    "id": 1,
    "params": []
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

Request Body

{
  "jsonrpc": "2.0",
  "method": "web3_clientVersion",
  "id": 1,
  "params": []
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": "v0.13.2"
}

Returns Keccak-256 of the given data.

POST

wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (web3_sha3)

Authorizations

ApiKeyAuthApiKeyAuth

apiKey string

NOWNodes API key passed in the api-key header.

Returns Keccak-256 (not the standardized SHA3-256) of the given data.

Sent as a JSON text message over the WebSocket connection wss://monad.nownodes.io/wss/{apiKey}.

Body

application/json

WebSocket request envelope for web3_sha3, sent as a JSON text message.

WebSocket text-message request envelope sent over the single WSS connection.

jsonrpcstringrequired

JSON-RPC protocol version.

methodstringrequired

JSON-RPC method name.

paramsarray | object

Method parameters (array or object); omit for parameterless methods.

idinteger | string

Client-chosen request identifier echoed in the response.

Parameters

apiKeystringrequiredpath

NOWNodes API key - the last path segment of the WebSocket URL (wss://monad.nownodes.io/wss/{apiKey}).

Response

200OK

Response delivered on the same WebSocket connection. JSON-RPC errors arrive as regular messages (no HTTP status change); subscription pushes arrive as eth_subscription notifications.

Returns Keccak-256 of the given data.

curl -X POST 'wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (web3_sha3)' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "web3_sha3",
    "id": 1,
    "params": [
      "0x67656c6c6f20776f726c64"
    ]
  }'

import { JsonRpcProvider } from "ethers";

const provider = new JsonRpcProvider("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (web3_sha3)");
const result = await provider.send("web3_sha3", [
  "0x67656c6c6f20776f726c64"
]);
console.log(result);

require 'eth'
require 'json'
require 'net/http'

uri = URI('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (web3_sha3)')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
  "jsonrpc": "2.0",
  "method": "web3_sha3",
  "params": [
    "0x67656c6c6f20776f726c64"
  ],
  "id": 1
}'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end

puts JSON.parse(response.body)

from web3 import Web3

w3 = Web3(Web3.HTTPProvider("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (web3_sha3)"))
response = w3.provider.make_request("web3_sha3", [
  "0x67656c6c6f20776f726c64"
])
print(response)

import { createPublicClient, http } from "viem";

const client = createPublicClient({
  transport: http("wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (web3_sha3)"),
});

const result = await client.request({
  method: "web3_sha3",
  params: [
  "0x67656c6c6f20776f726c64"
],
});

console.log(result);

const endpoint = "wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (web3_sha3)";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({ jsonrpc: "2.0", method: "web3_sha3", params: [
  "0x67656c6c6f20776f726c64"
], id: 1 });
console.log(result);

const response = await fetch('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (web3_sha3)', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "web3_sha3",
      "id": 1,
      "params": [
        "0x67656c6c6f20776f726c64"
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "web3_sha3",
  "id": 1,
  "params": [
    "0x67656c6c6f20776f726c64"
  ]
}

response = requests.post('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (web3_sha3)', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('wss://monad.nownodes.io/wss/{apiKey}/wss/{apiKey} (web3_sha3)')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "jsonrpc": "2.0",
    "method": "web3_sha3",
    "id": 1,
    "params": [
      "0x67656c6c6f20776f726c64"
    ]
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

Request Body

{
  "jsonrpc": "2.0",
  "method": "web3_sha3",
  "id": 1,
  "params": [
    "0x67656c6c6f20776f726c64"
  ]
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": "0x1b84adea42d5b7d192fd8a61a85b25abe0757e9a65cab1da470258914053823f"
}

Documentation

How to migrate to NOWNodes

Authentication

WSS

Subscriptions

Authorizations

Body

Parameters

Response

Authorizations

Body

Parameters

Response

Chain & Status

Authorizations

Body

Parameters

Response

Authorizations

Body

Parameters

Response

Authorizations

Body

Parameters

Response

Gas & Fees

Authorizations

Body

Parameters

Response

Authorizations

Body

Parameters

Response

Authorizations

Body

Parameters

Response

Authorizations

Body

Parameters

Response

Blocks

Authorizations

Body

Parameters

Response

Authorizations

Body

Parameters

Response

Authorizations

Body

Parameters

Response

Authorizations

Body

Parameters

Response

Authorizations

Body

Parameters

Response

Authorizations

Body

Parameters

Response

Authorizations

Body

Parameters

Response

Authorizations

Body

Parameters

Response

Transactions

Authorizations

Body

Parameters