Flare avax.getAtomicTx API

v1.0.0

Base URLs

https://flr.nownodes.io/ext/bc/C/avaxNOWNodes Flare mainnet endpoint

https://flr.nownodes.io/ext/bc/C/rpcNOWNodes Flare mainnet endpoint

https://flr.nownodes.io/ext/bc/PNOWNodes Flare mainnet endpoint

OpenAPI specification for the avax.getAtomicTx JSON-RPC method on the Flare network.

Authentication

api-keyAuthapiKey

NOWNodes API key passed in the api-key header.

API Key: api-key in header

MAINNET / C-Chain / Avalanche-API

C-Chain Avalanche API

Flare C-Chain Avalanche API methods

avax.getAtomicTx

POST

https://flr.nownodes.io/ext/bc/C/avax/

Body

application/json

jsonrpcstring2.0required

methodstringavax.getAtomicTxrequired

paramsobjectrequired

idinteger | stringrequired

Response

200OK

JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or gateway error

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

avax.getAtomicTx

curl -X POST 'https://flr.nownodes.io/ext/bc/C/avax/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "avax.getAtomicTx",
    "params": {
      "txID": "11111111111111111111111111111111LpoYY",
      "encoding": "hex"
    },
    "id": 1
  }'

const response = await fetch('https://flr.nownodes.io/ext/bc/C/avax/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "avax.getAtomicTx",
      "params": {
        "txID": "11111111111111111111111111111111LpoYY",
        "encoding": "hex"
      },
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "avax.getAtomicTx",
  "params": {
    "txID": "11111111111111111111111111111111LpoYY",
    "encoding": "hex"
  },
  "id": 1
}

response = requests.post('https://flr.nownodes.io/ext/bc/C/avax/', json=payload)
data = response.json()

Request Body

{
  "jsonrpc": "2.0",
  "method": "avax.getAtomicTx",
  "params": {
    "txID": "11111111111111111111111111111111LpoYY",
    "encoding": "hex"
  },
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "result": {
    "tx": "0x00",
    "encoding": "hex"
  },
  "id": 1
}

avax.getAtomicTxStatus

POST

https://flr.nownodes.io/ext/bc/C/avax/

Body

application/json

jsonrpcstring2.0required

methodstringavax.getAtomicTxStatusrequired

paramsobjectrequired

idinteger | stringrequired

Response

200OK

JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or gateway error

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

avax.getAtomicTxStatus

curl -X POST 'https://flr.nownodes.io/ext/bc/C/avax/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "avax.getAtomicTxStatus",
    "params": {
      "txID": "11111111111111111111111111111111LpoYY"
    },
    "id": 1
  }'

const response = await fetch('https://flr.nownodes.io/ext/bc/C/avax/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "avax.getAtomicTxStatus",
      "params": {
        "txID": "11111111111111111111111111111111LpoYY"
      },
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "avax.getAtomicTxStatus",
  "params": {
    "txID": "11111111111111111111111111111111LpoYY"
  },
  "id": 1
}

response = requests.post('https://flr.nownodes.io/ext/bc/C/avax/', json=payload)
data = response.json()

Request Body

{
  "jsonrpc": "2.0",
  "method": "avax.getAtomicTxStatus",
  "params": {
    "txID": "11111111111111111111111111111111LpoYY"
  },
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "result": {
    "status": "Accepted",
    "blockHeight": "1"
  },
  "id": 1
}

avax.getUTXOs

POST

https://flr.nownodes.io/ext/bc/C/avax/

Body

application/json

jsonrpcstring2.0required

methodstringavax.getUTXOsrequired

paramsobjectrequired

idinteger | stringrequired

Response

200OK

JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or gateway error

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

avax.getUTXOs

curl -X POST 'https://flr.nownodes.io/ext/bc/C/avax/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "avax.getUTXOs",
    "params": {
      "addresses": [
        "C-flare1exampleaddress"
      ],
      "limit": 1024,
      "sourceChain": "P",
      "encoding": "hex"
    },
    "id": 1
  }'

const response = await fetch('https://flr.nownodes.io/ext/bc/C/avax/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "avax.getUTXOs",
      "params": {
        "addresses": [
          "C-flare1exampleaddress"
        ],
        "limit": 1024,
        "sourceChain": "P",
        "encoding": "hex"
      },
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "avax.getUTXOs",
  "params": {
    "addresses": [
      "C-flare1exampleaddress"
    ],
    "limit": 1024,
    "sourceChain": "P",
    "encoding": "hex"
  },
  "id": 1
}

response = requests.post('https://flr.nownodes.io/ext/bc/C/avax/', json=payload)
data = response.json()

Request Body

{
  "jsonrpc": "2.0",
  "method": "avax.getUTXOs",
  "params": {
    "addresses": [
      "C-flare1exampleaddress"
    ],
    "limit": 1024,
    "sourceChain": "P",
    "encoding": "hex"
  },
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "result": {
    "numFetched": "0",
    "utxos": [],
    "endIndex": {
      "address": "C-flare1exampleaddress",
      "utxo": "11111111111111111111111111111111LpoYY"
    },
    "encoding": "hex"
  },
  "id": 1
}

MAINNET / C-Chain / EVM

C-Chain EVM

Flare C-Chain EVM methods

eth_accounts

POST

https://flr.nownodes.io/ext/bc/C/avax/

Body

application/json

jsonrpcstring2.0required

methodstringeth_accountsrequired

paramsArray<any>required

idinteger | stringrequired

Response

200OK

JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or gateway error

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

eth_accounts

curl -X POST 'https://flr.nownodes.io/ext/bc/C/avax/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_accounts",
    "params": [],
    "id": 1
  }'

const response = await fetch('https://flr.nownodes.io/ext/bc/C/avax/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "eth_accounts",
      "params": [],
      "id": 1
    }),
});

const data = await response.json();

import requests

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

response = requests.post('https://flr.nownodes.io/ext/bc/C/avax/', json=payload)
data = response.json()

Request Body

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

200

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

eth_blockNumber

POST

https://flr.nownodes.io/ext/bc/C/avax/

Body

application/json

jsonrpcstring2.0required

methodstringeth_blockNumberrequired

paramsArray<any>required

idinteger | stringrequired

Response

200OK

JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or gateway error

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

eth_blockNumber

curl -X POST 'https://flr.nownodes.io/ext/bc/C/avax/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_blockNumber",
    "params": [],
    "id": 1
  }'

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

const data = await response.json();

import requests

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

response = requests.post('https://flr.nownodes.io/ext/bc/C/avax/', json=payload)
data = response.json()

Request Body

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

200

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

eth_call

POST

https://flr.nownodes.io/ext/bc/C/avax/

Body

application/json

jsonrpcstring2.0required

methodstringeth_callrequired

paramsArray<any>required

idinteger | stringrequired

Response

200OK

JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or gateway error

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

eth_call

curl -X POST 'https://flr.nownodes.io/ext/bc/C/avax/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_call",
    "params": [
      {
        "to": "0x0000000000000000000000000000000000000000",
        "data": "0x"
      },
      "latest"
    ],
    "id": 1
  }'

const response = await fetch('https://flr.nownodes.io/ext/bc/C/avax/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "eth_call",
      "params": [
        {
          "to": "0x0000000000000000000000000000000000000000",
          "data": "0x"
        },
        "latest"
      ],
      "id": 1
    }),
});

const data = await response.json();

import requests

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

response = requests.post('https://flr.nownodes.io/ext/bc/C/avax/', json=payload)
data = response.json()

Request Body

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

200

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

eth_chainId

POST

https://flr.nownodes.io/ext/bc/C/avax/

Body

application/json

jsonrpcstring2.0required

methodstringeth_chainIdrequired

paramsArray<any>required

idinteger | stringrequired

Response

200OK

JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or gateway error

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

eth_chainId

curl -X POST 'https://flr.nownodes.io/ext/bc/C/avax/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_chainId",
    "params": [],
    "id": 1
  }'

const response = await fetch('https://flr.nownodes.io/ext/bc/C/avax/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "eth_chainId",
      "params": [],
      "id": 1
    }),
});

const data = await response.json();

import requests

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

response = requests.post('https://flr.nownodes.io/ext/bc/C/avax/', json=payload)
data = response.json()

Request Body

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

200

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

eth_coinbase

POST

https://flr.nownodes.io/ext/bc/C/avax/

Body

application/json

jsonrpcstring2.0required

methodstringeth_coinbaserequired

paramsArray<any>required

idinteger | stringrequired

Response

200OK

JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or gateway error

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

eth_coinbase

curl -X POST 'https://flr.nownodes.io/ext/bc/C/avax/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_coinbase",
    "params": [],
    "id": 1
  }'

const response = await fetch('https://flr.nownodes.io/ext/bc/C/avax/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "eth_coinbase",
      "params": [],
      "id": 1
    }),
});

const data = await response.json();

import requests

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

response = requests.post('https://flr.nownodes.io/ext/bc/C/avax/', json=payload)
data = response.json()

Request Body

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

200

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

eth_estimateGas

POST

https://flr.nownodes.io/ext/bc/C/avax/

Body

application/json

jsonrpcstring2.0required

methodstringeth_estimateGasrequired

paramsArray<any>required

idinteger | stringrequired

Response

200OK

JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or gateway error

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

eth_estimateGas

curl -X POST 'https://flr.nownodes.io/ext/bc/C/avax/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_estimateGas",
    "params": [
      {
        "to": "0x0000000000000000000000000000000000000000",
        "value": "0x0"
      }
    ],
    "id": 1
  }'

const response = await fetch('https://flr.nownodes.io/ext/bc/C/avax/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "eth_estimateGas",
      "params": [
        {
          "to": "0x0000000000000000000000000000000000000000",
          "value": "0x0"
        }
      ],
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "eth_estimateGas",
  "params": [
    {
      "to": "0x0000000000000000000000000000000000000000",
      "value": "0x0"
    }
  ],
  "id": 1
}

response = requests.post('https://flr.nownodes.io/ext/bc/C/avax/', json=payload)
data = response.json()

Request Body

{
  "jsonrpc": "2.0",
  "method": "eth_estimateGas",
  "params": [
    {
      "to": "0x0000000000000000000000000000000000000000",
      "value": "0x0"
    }
  ],
  "id": 1
}

200

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

eth_feeHistory

POST

https://flr.nownodes.io/ext/bc/C/avax/

Body

application/json

jsonrpcstring2.0required

methodstringeth_feeHistoryrequired

paramsArray<any>required

idinteger | stringrequired

Response

200OK

JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or gateway error

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

eth_feeHistory

curl -X POST 'https://flr.nownodes.io/ext/bc/C/avax/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_feeHistory",
    "params": [
      "0x4",
      "latest",
      [
        25,
        50,
        75
      ]
    ],
    "id": 1
  }'

const response = await fetch('https://flr.nownodes.io/ext/bc/C/avax/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "eth_feeHistory",
      "params": [
        "0x4",
        "latest",
        [
          25,
          50,
          75
        ]
      ],
      "id": 1
    }),
});

const data = await response.json();

import requests

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

response = requests.post('https://flr.nownodes.io/ext/bc/C/avax/', json=payload)
data = response.json()

Request Body

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

200

{
  "jsonrpc": "2.0",
  "result": {
    "oldestBlock": "0x1",
    "baseFeePerGas": [
      "0x1"
    ],
    "gasUsedRatio": [
      0.5
    ],
    "reward": [
      [
        "0x0"
      ]
    ]
  },
  "id": 1
}

eth_gasPrice

POST

https://flr.nownodes.io/ext/bc/C/avax/

Body

application/json

jsonrpcstring2.0required

methodstringeth_gasPricerequired

paramsArray<any>required

idinteger | stringrequired

Response

200OK

JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or gateway error

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

eth_gasPrice

curl -X POST 'https://flr.nownodes.io/ext/bc/C/avax/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_gasPrice",
    "params": [],
    "id": 1
  }'

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

const data = await response.json();

import requests

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

response = requests.post('https://flr.nownodes.io/ext/bc/C/avax/', json=payload)
data = response.json()

Request Body

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

200

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

eth_getAssetBalance

POST

https://flr.nownodes.io/ext/bc/C/avax/

Body

application/json

jsonrpcstring2.0required

methodstringeth_getAssetBalancerequired

paramsArray<any>required

idinteger | stringrequired

Response

200OK

JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or gateway error

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

eth_getAssetBalance

curl -X POST 'https://flr.nownodes.io/ext/bc/C/avax/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_getAssetBalance",
    "params": [
      "0x0000000000000000000000000000000000000000",
      "0x0000000000000000000000000000000000000000000000000000000000000000",
      "latest"
    ],
    "id": 1
  }'

const response = await fetch('https://flr.nownodes.io/ext/bc/C/avax/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "eth_getAssetBalance",
      "params": [
        "0x0000000000000000000000000000000000000000",
        "0x0000000000000000000000000000000000000000000000000000000000000000",
        "latest"
      ],
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "eth_getAssetBalance",
  "params": [
    "0x0000000000000000000000000000000000000000",
    "0x0000000000000000000000000000000000000000000000000000000000000000",
    "latest"
  ],
  "id": 1
}

response = requests.post('https://flr.nownodes.io/ext/bc/C/avax/', json=payload)
data = response.json()

Request Body

{
  "jsonrpc": "2.0",
  "method": "eth_getAssetBalance",
  "params": [
    "0x0000000000000000000000000000000000000000",
    "0x0000000000000000000000000000000000000000000000000000000000000000",
    "latest"
  ],
  "id": 1
}

200

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

eth_getBalance

POST

https://flr.nownodes.io/ext/bc/C/avax/

Body

application/json

jsonrpcstring2.0required

methodstringeth_getBalancerequired

paramsArray<any>required

idinteger | stringrequired

Response

200OK

JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or gateway error

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

eth_getBalance

curl -X POST 'https://flr.nownodes.io/ext/bc/C/avax/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_getBalance",
    "params": [
      "0x0000000000000000000000000000000000000000",
      "latest"
    ],
    "id": 1
  }'

const response = await fetch('https://flr.nownodes.io/ext/bc/C/avax/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "eth_getBalance",
      "params": [
        "0x0000000000000000000000000000000000000000",
        "latest"
      ],
      "id": 1
    }),
});

const data = await response.json();

import requests

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

response = requests.post('https://flr.nownodes.io/ext/bc/C/avax/', json=payload)
data = response.json()

Request Body

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

200

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

eth_getBlockByHash

POST

https://flr.nownodes.io/ext/bc/C/avax/

Body

application/json

jsonrpcstring2.0required

methodstringeth_getBlockByHashrequired

paramsArray<any>required

idinteger | stringrequired

Response

200OK

JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or gateway error

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

eth_getBlockByHash

curl -X POST 'https://flr.nownodes.io/ext/bc/C/avax/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_getBlockByHash",
    "params": [
      "0x0000000000000000000000000000000000000000000000000000000000000000",
      false
    ],
    "id": 1
  }'

const response = await fetch('https://flr.nownodes.io/ext/bc/C/avax/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "eth_getBlockByHash",
      "params": [
        "0x0000000000000000000000000000000000000000000000000000000000000000",
        false
      ],
      "id": 1
    }),
});

const data = await response.json();

import requests

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

response = requests.post('https://flr.nownodes.io/ext/bc/C/avax/', json=payload)
data = response.json()

Request Body

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

200

{
  "jsonrpc": "2.0",
  "result": {
    "number": "0x1",
    "hash": "0x0000000000000000000000000000000000000000000000000000000000000000",
    "transactions": []
  },
  "id": 1
}

eth_getBlockByNumber

POST

https://flr.nownodes.io/ext/bc/C/avax/

Body

application/json

jsonrpcstring2.0required

methodstringeth_getBlockByNumberrequired

paramsArray<any>required

idinteger | stringrequired

Response

200OK

JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or gateway error

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

eth_getBlockByNumber

curl -X POST 'https://flr.nownodes.io/ext/bc/C/avax/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_getBlockByNumber",
    "params": [
      "latest",
      false
    ],
    "id": 1
  }'

const response = await fetch('https://flr.nownodes.io/ext/bc/C/avax/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "eth_getBlockByNumber",
      "params": [
        "latest",
        false
      ],
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "eth_getBlockByNumber",
  "params": [
    "latest",
    false
  ],
  "id": 1
}

response = requests.post('https://flr.nownodes.io/ext/bc/C/avax/', json=payload)
data = response.json()

Request Body

{
  "jsonrpc": "2.0",
  "method": "eth_getBlockByNumber",
  "params": [
    "latest",
    false
  ],
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "result": {
    "number": "0x3ed1a80",
    "hash": "0x0000000000000000000000000000000000000000000000000000000000000000",
    "transactions": []
  },
  "id": 1
}

eth_getBlockTransactionCountByHash

POST

https://flr.nownodes.io/ext/bc/C/avax/

Body

application/json

jsonrpcstring2.0required

methodstringeth_getBlockTransactionCountByHashrequired

paramsArray<any>required

idinteger | stringrequired

Response

200OK

JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or gateway error

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

eth_getBlockTransactionCountByHash

curl -X POST 'https://flr.nownodes.io/ext/bc/C/avax/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_getBlockTransactionCountByHash",
    "params": [
      "0x0000000000000000000000000000000000000000000000000000000000000000"
    ],
    "id": 1
  }'

const response = await fetch('https://flr.nownodes.io/ext/bc/C/avax/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "eth_getBlockTransactionCountByHash",
      "params": [
        "0x0000000000000000000000000000000000000000000000000000000000000000"
      ],
      "id": 1
    }),
});

const data = await response.json();

import requests

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

response = requests.post('https://flr.nownodes.io/ext/bc/C/avax/', json=payload)
data = response.json()

Request Body

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

200

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

eth_getBlockTransactionCountByNumber

POST

https://flr.nownodes.io/ext/bc/C/avax/

Body

application/json

jsonrpcstring2.0required

methodstringeth_getBlockTransactionCountByNumberrequired

paramsArray<any>required

idinteger | stringrequired

Response

200OK

JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or gateway error

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

eth_getBlockTransactionCountByNumber

curl -X POST 'https://flr.nownodes.io/ext/bc/C/avax/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_getBlockTransactionCountByNumber",
    "params": [
      "latest"
    ],
    "id": 1
  }'

const response = await fetch('https://flr.nownodes.io/ext/bc/C/avax/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "eth_getBlockTransactionCountByNumber",
      "params": [
        "latest"
      ],
      "id": 1
    }),
});

const data = await response.json();

import requests

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

response = requests.post('https://flr.nownodes.io/ext/bc/C/avax/', json=payload)
data = response.json()

Request Body

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

200

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

eth_getCode

POST

https://flr.nownodes.io/ext/bc/C/avax/

Body

application/json

jsonrpcstring2.0required

methodstringeth_getCoderequired

paramsArray<any>required

idinteger | stringrequired

Response

200OK

JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or gateway error

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

eth_getCode

curl -X POST 'https://flr.nownodes.io/ext/bc/C/avax/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_getCode",
    "params": [
      "0x0000000000000000000000000000000000000000",
      "latest"
    ],
    "id": 1
  }'

const response = await fetch('https://flr.nownodes.io/ext/bc/C/avax/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "eth_getCode",
      "params": [
        "0x0000000000000000000000000000000000000000",
        "latest"
      ],
      "id": 1
    }),
});

const data = await response.json();

import requests

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

response = requests.post('https://flr.nownodes.io/ext/bc/C/avax/', json=payload)
data = response.json()

Request Body

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

200

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

eth_getFilterChanges

POST

https://flr.nownodes.io/ext/bc/C/avax/

Body

application/json

jsonrpcstring2.0required

methodstringeth_getFilterChangesrequired

paramsArray<any>required

idinteger | stringrequired

Response

200OK

JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or gateway error

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

eth_getFilterChanges

curl -X POST 'https://flr.nownodes.io/ext/bc/C/avax/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_getFilterChanges",
    "params": [
      "0x1"
    ],
    "id": 1
  }'

const response = await fetch('https://flr.nownodes.io/ext/bc/C/avax/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "eth_getFilterChanges",
      "params": [
        "0x1"
      ],
      "id": 1
    }),
});

const data = await response.json();

import requests

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

response = requests.post('https://flr.nownodes.io/ext/bc/C/avax/', json=payload)
data = response.json()

Request Body

{
  "jsonrpc": "2.0",
  "method": "eth_getFilterChanges",
  "params": [
    "0x1"
  ],
  "id": 1
}

200

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

eth_getFilterLogs

POST

https://flr.nownodes.io/ext/bc/C/avax/

Body

application/json

jsonrpcstring2.0required

methodstringeth_getFilterLogsrequired

paramsArray<any>required

idinteger | stringrequired

Response

200OK

JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or gateway error

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

eth_getFilterLogs

curl -X POST 'https://flr.nownodes.io/ext/bc/C/avax/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_getFilterLogs",
    "params": [
      "0x1"
    ],
    "id": 1
  }'

const response = await fetch('https://flr.nownodes.io/ext/bc/C/avax/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "eth_getFilterLogs",
      "params": [
        "0x1"
      ],
      "id": 1
    }),
});

const data = await response.json();

import requests

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

response = requests.post('https://flr.nownodes.io/ext/bc/C/avax/', json=payload)
data = response.json()

Request Body

{
  "jsonrpc": "2.0",
  "method": "eth_getFilterLogs",
  "params": [
    "0x1"
  ],
  "id": 1
}

200

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

eth_getLogs

POST

https://flr.nownodes.io/ext/bc/C/avax/

Body

application/json

jsonrpcstring2.0required

methodstringeth_getLogsrequired

paramsArray<any>required

idinteger | stringrequired

Response

200OK

JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or gateway error

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

eth_getLogs

curl -X POST 'https://flr.nownodes.io/ext/bc/C/avax/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_getLogs",
    "params": [
      {
        "fromBlock": "latest",
        "toBlock": "latest"
      }
    ],
    "id": 1
  }'

const response = await fetch('https://flr.nownodes.io/ext/bc/C/avax/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "eth_getLogs",
      "params": [
        {
          "fromBlock": "latest",
          "toBlock": "latest"
        }
      ],
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "eth_getLogs",
  "params": [
    {
      "fromBlock": "latest",
      "toBlock": "latest"
    }
  ],
  "id": 1
}

response = requests.post('https://flr.nownodes.io/ext/bc/C/avax/', json=payload)
data = response.json()

Request Body

{
  "jsonrpc": "2.0",
  "method": "eth_getLogs",
  "params": [
    {
      "fromBlock": "latest",
      "toBlock": "latest"
    }
  ],
  "id": 1
}

200

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

eth_getStorageAt

POST

https://flr.nownodes.io/ext/bc/C/avax/

Body

application/json

jsonrpcstring2.0required

methodstringeth_getStorageAtrequired

paramsArray<any>required

idinteger | stringrequired

Response

200OK

JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or gateway error

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

eth_getStorageAt

curl -X POST 'https://flr.nownodes.io/ext/bc/C/avax/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_getStorageAt",
    "params": [
      "0x0000000000000000000000000000000000000000",
      "0x0",
      "latest"
    ],
    "id": 1
  }'

const response = await fetch('https://flr.nownodes.io/ext/bc/C/avax/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "eth_getStorageAt",
      "params": [
        "0x0000000000000000000000000000000000000000",
        "0x0",
        "latest"
      ],
      "id": 1
    }),
});

const data = await response.json();

import requests

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

response = requests.post('https://flr.nownodes.io/ext/bc/C/avax/', json=payload)
data = response.json()

Request Body

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

200

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

eth_getTransactionByBlockHashAndIndex

POST

https://flr.nownodes.io/ext/bc/C/avax/

Body

application/json

jsonrpcstring2.0required

methodstringeth_getTransactionByBlockHashAndIndexrequired

paramsArray<any>required

idinteger | stringrequired

Response

200OK

JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or gateway error

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

eth_getTransactionByBlockHashAndIndex

curl -X POST 'https://flr.nownodes.io/ext/bc/C/avax/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_getTransactionByBlockHashAndIndex",
    "params": [
      "0x0000000000000000000000000000000000000000000000000000000000000000",
      "0x0"
    ],
    "id": 1
  }'

const response = await fetch('https://flr.nownodes.io/ext/bc/C/avax/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "eth_getTransactionByBlockHashAndIndex",
      "params": [
        "0x0000000000000000000000000000000000000000000000000000000000000000",
        "0x0"
      ],
      "id": 1
    }),
});

const data = await response.json();

import requests

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

response = requests.post('https://flr.nownodes.io/ext/bc/C/avax/', json=payload)
data = response.json()

Request Body

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

200

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

eth_getTransactionByBlockNumberAndIndex

POST

https://flr.nownodes.io/ext/bc/C/avax/

Body

application/json

jsonrpcstring2.0required

methodstringeth_getTransactionByBlockNumberAndIndexrequired

paramsArray<any>required

idinteger | stringrequired

Response

200OK

JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or gateway error

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

eth_getTransactionByBlockNumberAndIndex

curl -X POST 'https://flr.nownodes.io/ext/bc/C/avax/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_getTransactionByBlockNumberAndIndex",
    "params": [
      "latest",
      "0x0"
    ],
    "id": 1
  }'

const response = await fetch('https://flr.nownodes.io/ext/bc/C/avax/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "eth_getTransactionByBlockNumberAndIndex",
      "params": [
        "latest",
        "0x0"
      ],
      "id": 1
    }),
});

const data = await response.json();

import requests

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

response = requests.post('https://flr.nownodes.io/ext/bc/C/avax/', json=payload)
data = response.json()

Request Body

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

200

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

eth_getTransactionByHash

POST

https://flr.nownodes.io/ext/bc/C/avax/

Body

application/json

jsonrpcstring2.0required

methodstringeth_getTransactionByHashrequired

paramsArray<any>required

idinteger | stringrequired

Response

200OK

JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or gateway error

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

eth_getTransactionByHash

curl -X POST 'https://flr.nownodes.io/ext/bc/C/avax/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_getTransactionByHash",
    "params": [
      "0x0000000000000000000000000000000000000000000000000000000000000000"
    ],
    "id": 1
  }'

const response = await fetch('https://flr.nownodes.io/ext/bc/C/avax/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "eth_getTransactionByHash",
      "params": [
        "0x0000000000000000000000000000000000000000000000000000000000000000"
      ],
      "id": 1
    }),
});

const data = await response.json();

import requests

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

response = requests.post('https://flr.nownodes.io/ext/bc/C/avax/', json=payload)
data = response.json()

Request Body

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

200

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

eth_getTransactionCount

POST

https://flr.nownodes.io/ext/bc/C/avax/

Body

application/json

jsonrpcstring2.0required

methodstringeth_getTransactionCountrequired

paramsArray<any>required

idinteger | stringrequired

Response

200OK

JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or gateway error

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

eth_getTransactionCount

curl -X POST 'https://flr.nownodes.io/ext/bc/C/avax/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_getTransactionCount",
    "params": [
      "0x0000000000000000000000000000000000000000",
      "latest"
    ],
    "id": 1
  }'

const response = await fetch('https://flr.nownodes.io/ext/bc/C/avax/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "eth_getTransactionCount",
      "params": [
        "0x0000000000000000000000000000000000000000",
        "latest"
      ],
      "id": 1
    }),
});

const data = await response.json();

import requests

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

response = requests.post('https://flr.nownodes.io/ext/bc/C/avax/', json=payload)
data = response.json()

Request Body

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

200

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

eth_getTransactionReceipt

POST

https://flr.nownodes.io/ext/bc/C/avax/

Body

application/json

jsonrpcstring2.0required

methodstringeth_getTransactionReceiptrequired

paramsArray<any>required

idinteger | stringrequired

Response

200OK

JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or gateway error

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

eth_getTransactionReceipt

curl -X POST 'https://flr.nownodes.io/ext/bc/C/avax/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_getTransactionReceipt",
    "params": [
      "0x0000000000000000000000000000000000000000000000000000000000000000"
    ],
    "id": 1
  }'

const response = await fetch('https://flr.nownodes.io/ext/bc/C/avax/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "eth_getTransactionReceipt",
      "params": [
        "0x0000000000000000000000000000000000000000000000000000000000000000"
      ],
      "id": 1
    }),
});

const data = await response.json();

import requests

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

response = requests.post('https://flr.nownodes.io/ext/bc/C/avax/', json=payload)
data = response.json()

Request Body

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

200

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

eth_getUncleByBlockHashAndIndex

POST

https://flr.nownodes.io/ext/bc/C/avax/

Body

application/json

jsonrpcstring2.0required

methodstringeth_getUncleByBlockHashAndIndexrequired

paramsArray<any>required

idinteger | stringrequired

Response

200OK

JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or gateway error

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

eth_getUncleByBlockHashAndIndex

curl -X POST 'https://flr.nownodes.io/ext/bc/C/avax/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_getUncleByBlockHashAndIndex",
    "params": [
      "0x0000000000000000000000000000000000000000000000000000000000000000",
      "0x0"
    ],
    "id": 1
  }'

const response = await fetch('https://flr.nownodes.io/ext/bc/C/avax/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "eth_getUncleByBlockHashAndIndex",
      "params": [
        "0x0000000000000000000000000000000000000000000000000000000000000000",
        "0x0"
      ],
      "id": 1
    }),
});

const data = await response.json();

import requests

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

response = requests.post('https://flr.nownodes.io/ext/bc/C/avax/', json=payload)
data = response.json()

Request Body

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

200

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

eth_getUncleByBlockNumberAndIndex

POST

https://flr.nownodes.io/ext/bc/C/avax/

Body

application/json

jsonrpcstring2.0required

methodstringeth_getUncleByBlockNumberAndIndexrequired

paramsArray<any>required

idinteger | stringrequired

Response

200OK

JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or gateway error

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

eth_getUncleByBlockNumberAndIndex

curl -X POST 'https://flr.nownodes.io/ext/bc/C/avax/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_getUncleByBlockNumberAndIndex",
    "params": [
      "latest",
      "0x0"
    ],
    "id": 1
  }'

const response = await fetch('https://flr.nownodes.io/ext/bc/C/avax/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "eth_getUncleByBlockNumberAndIndex",
      "params": [
        "latest",
        "0x0"
      ],
      "id": 1
    }),
});

const data = await response.json();

import requests

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

response = requests.post('https://flr.nownodes.io/ext/bc/C/avax/', json=payload)
data = response.json()

Request Body

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

200

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

eth_getUncleCountByBlockHash

POST

https://flr.nownodes.io/ext/bc/C/avax/

Body

application/json

jsonrpcstring2.0required

methodstringeth_getUncleCountByBlockHashrequired

paramsArray<any>required

idinteger | stringrequired

Response

200OK

JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or gateway error

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

eth_getUncleCountByBlockHash

curl -X POST 'https://flr.nownodes.io/ext/bc/C/avax/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_getUncleCountByBlockHash",
    "params": [
      "0x0000000000000000000000000000000000000000000000000000000000000000"
    ],
    "id": 1
  }'

const response = await fetch('https://flr.nownodes.io/ext/bc/C/avax/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "eth_getUncleCountByBlockHash",
      "params": [
        "0x0000000000000000000000000000000000000000000000000000000000000000"
      ],
      "id": 1
    }),
});

const data = await response.json();

import requests

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

response = requests.post('https://flr.nownodes.io/ext/bc/C/avax/', json=payload)
data = response.json()

Request Body

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

200

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

eth_getUncleCountByBlockNumber

POST

https://flr.nownodes.io/ext/bc/C/avax/

Body

application/json

jsonrpcstring2.0required

methodstringeth_getUncleCountByBlockNumberrequired

paramsArray<any>required

idinteger | stringrequired

Response

200OK

JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or gateway error

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

eth_getUncleCountByBlockNumber

curl -X POST 'https://flr.nownodes.io/ext/bc/C/avax/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_getUncleCountByBlockNumber",
    "params": [
      "latest"
    ],
    "id": 1
  }'

const response = await fetch('https://flr.nownodes.io/ext/bc/C/avax/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "eth_getUncleCountByBlockNumber",
      "params": [
        "latest"
      ],
      "id": 1
    }),
});

const data = await response.json();

import requests

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

response = requests.post('https://flr.nownodes.io/ext/bc/C/avax/', json=payload)
data = response.json()

Request Body

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

200

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

eth_hashrate

POST

https://flr.nownodes.io/ext/bc/C/avax/

Body

application/json

jsonrpcstring2.0required

methodstringeth_hashraterequired

paramsArray<any>required

idinteger | stringrequired

Response

200OK

JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or gateway error

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

eth_hashrate

curl -X POST 'https://flr.nownodes.io/ext/bc/C/avax/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_hashrate",
    "params": [],
    "id": 1
  }'

const response = await fetch('https://flr.nownodes.io/ext/bc/C/avax/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "eth_hashrate",
      "params": [],
      "id": 1
    }),
});

const data = await response.json();

import requests

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

response = requests.post('https://flr.nownodes.io/ext/bc/C/avax/', json=payload)
data = response.json()

Request Body

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

200

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

eth_maxPriorityFeePerGas

POST

https://flr.nownodes.io/ext/bc/C/avax/

Body

application/json

jsonrpcstring2.0required

methodstringeth_maxPriorityFeePerGasrequired

paramsArray<any>required

idinteger | stringrequired

Response

200OK

JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or gateway error

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

eth_maxPriorityFeePerGas

curl -X POST 'https://flr.nownodes.io/ext/bc/C/avax/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_maxPriorityFeePerGas",
    "params": [],
    "id": 1
  }'

const response = await fetch('https://flr.nownodes.io/ext/bc/C/avax/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "eth_maxPriorityFeePerGas",
      "params": [],
      "id": 1
    }),
});

const data = await response.json();

import requests

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

response = requests.post('https://flr.nownodes.io/ext/bc/C/avax/', json=payload)
data = response.json()

Request Body

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

200

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

eth_mining

POST

https://flr.nownodes.io/ext/bc/C/avax/

Body

application/json

jsonrpcstring2.0required

methodstringeth_miningrequired

paramsArray<any>required

idinteger | stringrequired

Response

200OK

JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or gateway error

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

eth_mining

curl -X POST 'https://flr.nownodes.io/ext/bc/C/avax/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_mining",
    "params": [],
    "id": 1
  }'

const response = await fetch('https://flr.nownodes.io/ext/bc/C/avax/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "eth_mining",
      "params": [],
      "id": 1
    }),
});

const data = await response.json();

import requests

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

response = requests.post('https://flr.nownodes.io/ext/bc/C/avax/', json=payload)
data = response.json()

Request Body

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

200

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

eth_newBlockFilter

POST

https://flr.nownodes.io/ext/bc/C/avax/

Body

application/json

jsonrpcstring2.0required

methodstringeth_newBlockFilterrequired

paramsArray<any>required

idinteger | stringrequired

Response

200OK

JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or gateway error

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

eth_newBlockFilter

curl -X POST 'https://flr.nownodes.io/ext/bc/C/avax/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_newBlockFilter",
    "params": [],
    "id": 1
  }'

const response = await fetch('https://flr.nownodes.io/ext/bc/C/avax/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "eth_newBlockFilter",
      "params": [],
      "id": 1
    }),
});

const data = await response.json();

import requests

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

response = requests.post('https://flr.nownodes.io/ext/bc/C/avax/', json=payload)
data = response.json()

Request Body

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

200

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

eth_newFilter

POST

https://flr.nownodes.io/ext/bc/C/avax/

Body

application/json

jsonrpcstring2.0required

methodstringeth_newFilterrequired

paramsArray<any>required

idinteger | stringrequired

Response

200OK

JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or gateway error

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

eth_newFilter

curl -X POST 'https://flr.nownodes.io/ext/bc/C/avax/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_newFilter",
    "params": [
      {
        "fromBlock": "latest",
        "toBlock": "latest"
      }
    ],
    "id": 1
  }'

const response = await fetch('https://flr.nownodes.io/ext/bc/C/avax/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "eth_newFilter",
      "params": [
        {
          "fromBlock": "latest",
          "toBlock": "latest"
        }
      ],
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "eth_newFilter",
  "params": [
    {
      "fromBlock": "latest",
      "toBlock": "latest"
    }
  ],
  "id": 1
}

response = requests.post('https://flr.nownodes.io/ext/bc/C/avax/', json=payload)
data = response.json()

Request Body

{
  "jsonrpc": "2.0",
  "method": "eth_newFilter",
  "params": [
    {
      "fromBlock": "latest",
      "toBlock": "latest"
    }
  ],
  "id": 1
}

200

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

eth_newPendingTransactionFilter

POST

https://flr.nownodes.io/ext/bc/C/avax/

Body

application/json

jsonrpcstring2.0required

methodstringeth_newPendingTransactionFilterrequired

paramsArray<any>required

idinteger | stringrequired

Response

200OK

JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or gateway error

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

eth_newPendingTransactionFilter

curl -X POST 'https://flr.nownodes.io/ext/bc/C/avax/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_newPendingTransactionFilter",
    "params": [],
    "id": 1
  }'

const response = await fetch('https://flr.nownodes.io/ext/bc/C/avax/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "eth_newPendingTransactionFilter",
      "params": [],
      "id": 1
    }),
});

const data = await response.json();

import requests

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

response = requests.post('https://flr.nownodes.io/ext/bc/C/avax/', json=payload)
data = response.json()

Request Body

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

200

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

eth_protocolVersion

POST

https://flr.nownodes.io/ext/bc/C/avax/

Body

application/json

jsonrpcstring2.0required

methodstringeth_protocolVersionrequired

paramsArray<any>required

idinteger | stringrequired

Response

200OK

JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or gateway error

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

eth_protocolVersion

curl -X POST 'https://flr.nownodes.io/ext/bc/C/avax/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_protocolVersion",
    "params": [],
    "id": 1
  }'

const response = await fetch('https://flr.nownodes.io/ext/bc/C/avax/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "eth_protocolVersion",
      "params": [],
      "id": 1
    }),
});

const data = await response.json();

import requests

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

response = requests.post('https://flr.nownodes.io/ext/bc/C/avax/', json=payload)
data = response.json()

Request Body

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

200

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

eth_sendRawTransaction

POST

https://flr.nownodes.io/ext/bc/C/avax/

Body

application/json

jsonrpcstring2.0required

methodstringeth_sendRawTransactionrequired

paramsArray<any>required

idinteger | stringrequired

Response

200OK

JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or gateway error

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

eth_sendRawTransaction

curl -X POST 'https://flr.nownodes.io/ext/bc/C/avax/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_sendRawTransaction",
    "params": [
      "0x02f8..."
    ],
    "id": 1
  }'

const response = await fetch('https://flr.nownodes.io/ext/bc/C/avax/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "eth_sendRawTransaction",
      "params": [
        "0x02f8..."
      ],
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "eth_sendRawTransaction",
  "params": [
    "0x02f8..."
  ],
  "id": 1
}

response = requests.post('https://flr.nownodes.io/ext/bc/C/avax/', json=payload)
data = response.json()

Request Body

{
  "jsonrpc": "2.0",
  "method": "eth_sendRawTransaction",
  "params": [
    "0x02f8..."
  ],
  "id": 1
}

200

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

eth_sendTransaction

POST

https://flr.nownodes.io/ext/bc/C/avax/

Body

application/json

jsonrpcstring2.0required

methodstringeth_sendTransactionrequired

paramsArray<any>required

idinteger | stringrequired

Response

200OK

JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or gateway error

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

eth_sendTransaction

curl -X POST 'https://flr.nownodes.io/ext/bc/C/avax/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_sendTransaction",
    "params": [
      {
        "from": "0x0000000000000000000000000000000000000000",
        "to": "0x0000000000000000000000000000000000000001",
        "value": "0x0"
      }
    ],
    "id": 1
  }'

const response = await fetch('https://flr.nownodes.io/ext/bc/C/avax/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "eth_sendTransaction",
      "params": [
        {
          "from": "0x0000000000000000000000000000000000000000",
          "to": "0x0000000000000000000000000000000000000001",
          "value": "0x0"
        }
      ],
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "eth_sendTransaction",
  "params": [
    {
      "from": "0x0000000000000000000000000000000000000000",
      "to": "0x0000000000000000000000000000000000000001",
      "value": "0x0"
    }
  ],
  "id": 1
}

response = requests.post('https://flr.nownodes.io/ext/bc/C/avax/', json=payload)
data = response.json()

Request Body

{
  "jsonrpc": "2.0",
  "method": "eth_sendTransaction",
  "params": [
    {
      "from": "0x0000000000000000000000000000000000000000",
      "to": "0x0000000000000000000000000000000000000001",
      "value": "0x0"
    }
  ],
  "id": 1
}

200

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

eth_sign

POST

https://flr.nownodes.io/ext/bc/C/avax/

Body

application/json

jsonrpcstring2.0required

methodstringeth_signrequired

paramsArray<any>required

idinteger | stringrequired

Response

200OK

JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or gateway error

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

eth_sign

curl -X POST 'https://flr.nownodes.io/ext/bc/C/avax/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_sign",
    "params": [
      "0x0000000000000000000000000000000000000000",
      "0x68656c6c6f"
    ],
    "id": 1
  }'

const response = await fetch('https://flr.nownodes.io/ext/bc/C/avax/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "eth_sign",
      "params": [
        "0x0000000000000000000000000000000000000000",
        "0x68656c6c6f"
      ],
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "eth_sign",
  "params": [
    "0x0000000000000000000000000000000000000000",
    "0x68656c6c6f"
  ],
  "id": 1
}

response = requests.post('https://flr.nownodes.io/ext/bc/C/avax/', json=payload)
data = response.json()

Request Body

{
  "jsonrpc": "2.0",
  "method": "eth_sign",
  "params": [
    "0x0000000000000000000000000000000000000000",
    "0x68656c6c6f"
  ],
  "id": 1
}

200

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

eth_syncing

POST

https://flr.nownodes.io/ext/bc/C/avax/

Body

application/json

jsonrpcstring2.0required

methodstringeth_syncingrequired

paramsArray<any>required

idinteger | stringrequired

Response

200OK

JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or gateway error

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

eth_syncing

curl -X POST 'https://flr.nownodes.io/ext/bc/C/avax/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_syncing",
    "params": [],
    "id": 1
  }'

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

const data = await response.json();

import requests

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

response = requests.post('https://flr.nownodes.io/ext/bc/C/avax/', json=payload)
data = response.json()

Request Body

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

200

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

eth_uninstallFilter

POST

https://flr.nownodes.io/ext/bc/C/avax/

Body

application/json

jsonrpcstring2.0required

methodstringeth_uninstallFilterrequired

paramsArray<any>required

idinteger | stringrequired

Response

200OK

JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or gateway error

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

eth_uninstallFilter

curl -X POST 'https://flr.nownodes.io/ext/bc/C/avax/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_uninstallFilter",
    "params": [
      "0x1"
    ],
    "id": 1
  }'

const response = await fetch('https://flr.nownodes.io/ext/bc/C/avax/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "eth_uninstallFilter",
      "params": [
        "0x1"
      ],
      "id": 1
    }),
});

const data = await response.json();

import requests

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

response = requests.post('https://flr.nownodes.io/ext/bc/C/avax/', json=payload)
data = response.json()

Request Body

{
  "jsonrpc": "2.0",
  "method": "eth_uninstallFilter",
  "params": [
    "0x1"
  ],
  "id": 1
}

200

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

net_listening

POST

https://flr.nownodes.io/ext/bc/C/avax/

Body

application/json

jsonrpcstring2.0required

methodstringnet_listeningrequired

paramsArray<any>required

idinteger | stringrequired

Response

200OK

JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or gateway error

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

net_listening

curl -X POST 'https://flr.nownodes.io/ext/bc/C/avax/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "net_listening",
    "params": [],
    "id": 1
  }'

const response = await fetch('https://flr.nownodes.io/ext/bc/C/avax/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "net_listening",
      "params": [],
      "id": 1
    }),
});

const data = await response.json();

import requests

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

response = requests.post('https://flr.nownodes.io/ext/bc/C/avax/', json=payload)
data = response.json()

Request Body

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

200

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

net_peerCount

POST

https://flr.nownodes.io/ext/bc/C/avax/

Body

application/json

jsonrpcstring2.0required

methodstringnet_peerCountrequired

paramsArray<any>required

idinteger | stringrequired

Response

200OK

JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or gateway error

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

net_peerCount

curl -X POST 'https://flr.nownodes.io/ext/bc/C/avax/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "net_peerCount",
    "params": [],
    "id": 1
  }'

const response = await fetch('https://flr.nownodes.io/ext/bc/C/avax/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "net_peerCount",
      "params": [],
      "id": 1
    }),
});

const data = await response.json();

import requests

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

response = requests.post('https://flr.nownodes.io/ext/bc/C/avax/', json=payload)
data = response.json()

Request Body

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

200

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

net_version

POST

https://flr.nownodes.io/ext/bc/C/avax/

Body

application/json

jsonrpcstring2.0required

methodstringnet_versionrequired

paramsArray<any>required

idinteger | stringrequired

Response

200OK

JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or gateway error

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

net_version

curl -X POST 'https://flr.nownodes.io/ext/bc/C/avax/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "net_version",
    "params": [],
    "id": 1
  }'

const response = await fetch('https://flr.nownodes.io/ext/bc/C/avax/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "net_version",
      "params": [],
      "id": 1
    }),
});

const data = await response.json();

import requests

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

response = requests.post('https://flr.nownodes.io/ext/bc/C/avax/', json=payload)
data = response.json()

Request Body

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

200

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

web3_clientVersion

POST

https://flr.nownodes.io/ext/bc/C/avax/

Body

application/json

jsonrpcstring2.0required

methodstringweb3_clientVersionrequired

paramsArray<any>required

idinteger | stringrequired

Response

200OK

JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or gateway error

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

web3_clientVersion

curl -X POST 'https://flr.nownodes.io/ext/bc/C/avax/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "web3_clientVersion",
    "params": [],
    "id": 1
  }'

const response = await fetch('https://flr.nownodes.io/ext/bc/C/avax/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "web3_clientVersion",
      "params": [],
      "id": 1
    }),
});

const data = await response.json();

import requests

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

response = requests.post('https://flr.nownodes.io/ext/bc/C/avax/', json=payload)
data = response.json()

Request Body

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

200

{
  "jsonrpc": "2.0",
  "result": "flarego/v1.11.0",
  "id": 1
}

web3_sha3

POST

https://flr.nownodes.io/ext/bc/C/avax/

Body

application/json

jsonrpcstring2.0required

methodstringweb3_sha3required

paramsArray<any>required

idinteger | stringrequired

Response

200OK

JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or gateway error

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

web3_sha3

curl -X POST 'https://flr.nownodes.io/ext/bc/C/avax/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "web3_sha3",
    "params": [
      "0x68656c6c6f"
    ],
    "id": 1
  }'

const response = await fetch('https://flr.nownodes.io/ext/bc/C/avax/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "web3_sha3",
      "params": [
        "0x68656c6c6f"
      ],
      "id": 1
    }),
});

const data = await response.json();

import requests

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

response = requests.post('https://flr.nownodes.io/ext/bc/C/avax/', json=payload)
data = response.json()

Request Body

{
  "jsonrpc": "2.0",
  "method": "web3_sha3",
  "params": [
    "0x68656c6c6f"
  ],
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "result": "0x1c8aff...",
  "id": 1
}

MAINNET / P-Chain

P-Chain

Flare P-Chain methods

platform.getBalance

POST

https://flr.nownodes.io/ext/bc/C/avax/

Body

application/json

jsonrpcstring2.0required

methodstringplatform.getBalancerequired

paramsobjectrequired

idinteger | stringrequired

Response

200OK

JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or gateway error

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

platform.getBalance

curl -X POST 'https://flr.nownodes.io/ext/bc/C/avax/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "platform.getBalance",
    "params": {
      "address": "P-flare1exampleaddress"
    },
    "id": 1
  }'

const response = await fetch('https://flr.nownodes.io/ext/bc/C/avax/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "platform.getBalance",
      "params": {
        "address": "P-flare1exampleaddress"
      },
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "platform.getBalance",
  "params": {
    "address": "P-flare1exampleaddress"
  },
  "id": 1
}

response = requests.post('https://flr.nownodes.io/ext/bc/C/avax/', json=payload)
data = response.json()

Request Body

{
  "jsonrpc": "2.0",
  "method": "platform.getBalance",
  "params": {
    "address": "P-flare1exampleaddress"
  },
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "result": {
    "balance": "1000000000",
    "unlocked": "1000000000",
    "lockedStakeable": "0",
    "lockedNotStakeable": "0",
    "utxoIDs": []
  },
  "id": 1
}

platform.getBlock

POST

https://flr.nownodes.io/ext/bc/C/avax/

Body

application/json

jsonrpcstring2.0required

methodstringplatform.getBlockrequired

paramsobjectrequired

idinteger | stringrequired

Response

200OK

JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or gateway error

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

platform.getBlock

curl -X POST 'https://flr.nownodes.io/ext/bc/C/avax/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "platform.getBlock",
    "params": {
      "blockID": "11111111111111111111111111111111LpoYY",
      "encoding": "hex"
    },
    "id": 1
  }'

const response = await fetch('https://flr.nownodes.io/ext/bc/C/avax/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "platform.getBlock",
      "params": {
        "blockID": "11111111111111111111111111111111LpoYY",
        "encoding": "hex"
      },
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "platform.getBlock",
  "params": {
    "blockID": "11111111111111111111111111111111LpoYY",
    "encoding": "hex"
  },
  "id": 1
}

response = requests.post('https://flr.nownodes.io/ext/bc/C/avax/', json=payload)
data = response.json()

Request Body

{
  "jsonrpc": "2.0",
  "method": "platform.getBlock",
  "params": {
    "blockID": "11111111111111111111111111111111LpoYY",
    "encoding": "hex"
  },
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "result": {
    "block": "0x00",
    "encoding": "hex"
  },
  "id": 1
}

platform.getBlockByHeight

POST

https://flr.nownodes.io/ext/bc/C/avax/

Body

application/json

jsonrpcstring2.0required

methodstringplatform.getBlockByHeightrequired

paramsobjectrequired

idinteger | stringrequired

Response

200OK

JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or gateway error

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

platform.getBlockByHeight

curl -X POST 'https://flr.nownodes.io/ext/bc/C/avax/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "platform.getBlockByHeight",
    "params": {
      "height": "1",
      "encoding": "hex"
    },
    "id": 1
  }'

const response = await fetch('https://flr.nownodes.io/ext/bc/C/avax/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "platform.getBlockByHeight",
      "params": {
        "height": "1",
        "encoding": "hex"
      },
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "platform.getBlockByHeight",
  "params": {
    "height": "1",
    "encoding": "hex"
  },
  "id": 1
}

response = requests.post('https://flr.nownodes.io/ext/bc/C/avax/', json=payload)
data = response.json()

Request Body

{
  "jsonrpc": "2.0",
  "method": "platform.getBlockByHeight",
  "params": {
    "height": "1",
    "encoding": "hex"
  },
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "result": {
    "block": "0x00",
    "encoding": "hex"
  },
  "id": 1
}

platform.getBlockchainStatus

POST

https://flr.nownodes.io/ext/bc/C/avax/

Body

application/json

jsonrpcstring2.0required

methodstringplatform.getBlockchainStatusrequired

paramsobjectrequired

idinteger | stringrequired

Response

200OK

JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or gateway error

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

platform.getBlockchainStatus

curl -X POST 'https://flr.nownodes.io/ext/bc/C/avax/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "platform.getBlockchainStatus",
    "params": {
      "blockchainID": "C"
    },
    "id": 1
  }'

const response = await fetch('https://flr.nownodes.io/ext/bc/C/avax/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "platform.getBlockchainStatus",
      "params": {
        "blockchainID": "C"
      },
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "platform.getBlockchainStatus",
  "params": {
    "blockchainID": "C"
  },
  "id": 1
}

response = requests.post('https://flr.nownodes.io/ext/bc/C/avax/', json=payload)
data = response.json()

Request Body

{
  "jsonrpc": "2.0",
  "method": "platform.getBlockchainStatus",
  "params": {
    "blockchainID": "C"
  },
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "result": {
    "status": "Validating"
  },
  "id": 1
}

platform.getCurrentSupply

POST

https://flr.nownodes.io/ext/bc/C/avax/

Body

application/json

jsonrpcstring2.0required

methodstringplatform.getCurrentSupplyrequired

paramsobjectrequired

idinteger | stringrequired

Response

200OK

JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or gateway error

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

platform.getCurrentSupply

curl -X POST 'https://flr.nownodes.io/ext/bc/C/avax/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "platform.getCurrentSupply",
    "params": {},
    "id": 1
  }'

const response = await fetch('https://flr.nownodes.io/ext/bc/C/avax/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "platform.getCurrentSupply",
      "params": {},
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "platform.getCurrentSupply",
  "params": {},
  "id": 1
}

response = requests.post('https://flr.nownodes.io/ext/bc/C/avax/', json=payload)
data = response.json()

Request Body

{
  "jsonrpc": "2.0",
  "method": "platform.getCurrentSupply",
  "params": {},
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "result": {
    "supply": "508058360000000000"
  },
  "id": 1
}

platform.getCurrentValidators

POST

https://flr.nownodes.io/ext/bc/C/avax/

Body

application/json

jsonrpcstring2.0required

methodstringplatform.getCurrentValidatorsrequired

paramsobjectrequired

idinteger | stringrequired

Response

200OK

JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or gateway error

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

platform.getCurrentValidators

curl -X POST 'https://flr.nownodes.io/ext/bc/C/avax/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "platform.getCurrentValidators",
    "params": {
      "subnetID": "11111111111111111111111111111111LpoYY"
    },
    "id": 1
  }'

const response = await fetch('https://flr.nownodes.io/ext/bc/C/avax/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "platform.getCurrentValidators",
      "params": {
        "subnetID": "11111111111111111111111111111111LpoYY"
      },
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "platform.getCurrentValidators",
  "params": {
    "subnetID": "11111111111111111111111111111111LpoYY"
  },
  "id": 1
}

response = requests.post('https://flr.nownodes.io/ext/bc/C/avax/', json=payload)
data = response.json()

Request Body

{
  "jsonrpc": "2.0",
  "method": "platform.getCurrentValidators",
  "params": {
    "subnetID": "11111111111111111111111111111111LpoYY"
  },
  "id": 1
}

200

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

platform.getHeight

POST

https://flr.nownodes.io/ext/bc/C/avax/

Body

application/json

jsonrpcstring2.0required

methodstringplatform.getHeightrequired

paramsobjectrequired

idinteger | stringrequired

Response

200OK

JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or gateway error

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

platform.getHeight

curl -X POST 'https://flr.nownodes.io/ext/bc/C/avax/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "platform.getHeight",
    "params": {},
    "id": 1
  }'

const response = await fetch('https://flr.nownodes.io/ext/bc/C/avax/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "platform.getHeight",
      "params": {},
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "platform.getHeight",
  "params": {},
  "id": 1
}

response = requests.post('https://flr.nownodes.io/ext/bc/C/avax/', json=payload)
data = response.json()

Request Body

{
  "jsonrpc": "2.0",
  "method": "platform.getHeight",
  "params": {},
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "result": {
    "height": "1773310"
  },
  "id": 1
}

platform.getMinStake

POST

https://flr.nownodes.io/ext/bc/C/avax/

Body

application/json

jsonrpcstring2.0required

methodstringplatform.getMinStakerequired

paramsobjectrequired

idinteger | stringrequired

Response

200OK

JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or gateway error

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

platform.getMinStake

curl -X POST 'https://flr.nownodes.io/ext/bc/C/avax/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "platform.getMinStake",
    "params": {
      "subnetID": "11111111111111111111111111111111LpoYY"
    },
    "id": 1
  }'

const response = await fetch('https://flr.nownodes.io/ext/bc/C/avax/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "platform.getMinStake",
      "params": {
        "subnetID": "11111111111111111111111111111111LpoYY"
      },
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "platform.getMinStake",
  "params": {
    "subnetID": "11111111111111111111111111111111LpoYY"
  },
  "id": 1
}

response = requests.post('https://flr.nownodes.io/ext/bc/C/avax/', json=payload)
data = response.json()

Request Body

{
  "jsonrpc": "2.0",
  "method": "platform.getMinStake",
  "params": {
    "subnetID": "11111111111111111111111111111111LpoYY"
  },
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "result": {
    "minValidatorStake": "1000000000000",
    "minDelegatorStake": "50000000000"
  },
  "id": 1
}

platform.getPendingValidators

POST

https://flr.nownodes.io/ext/bc/C/avax/

Body

application/json

jsonrpcstring2.0required

methodstringplatform.getPendingValidatorsrequired

paramsobjectrequired

idinteger | stringrequired

Response

200OK

JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or gateway error

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

platform.getPendingValidators

curl -X POST 'https://flr.nownodes.io/ext/bc/C/avax/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "platform.getPendingValidators",
    "params": {
      "subnetID": "11111111111111111111111111111111LpoYY"
    },
    "id": 1
  }'

const response = await fetch('https://flr.nownodes.io/ext/bc/C/avax/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "platform.getPendingValidators",
      "params": {
        "subnetID": "11111111111111111111111111111111LpoYY"
      },
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "platform.getPendingValidators",
  "params": {
    "subnetID": "11111111111111111111111111111111LpoYY"
  },
  "id": 1
}

response = requests.post('https://flr.nownodes.io/ext/bc/C/avax/', json=payload)
data = response.json()

Request Body

{
  "jsonrpc": "2.0",
  "method": "platform.getPendingValidators",
  "params": {
    "subnetID": "11111111111111111111111111111111LpoYY"
  },
  "id": 1
}

200

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

platform.getRewardUTXOs

POST

https://flr.nownodes.io/ext/bc/C/avax/

Body

application/json

jsonrpcstring2.0required

methodstringplatform.getRewardUTXOsrequired

paramsobjectrequired

idinteger | stringrequired

Response

200OK

JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or gateway error

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

platform.getRewardUTXOs

curl -X POST 'https://flr.nownodes.io/ext/bc/C/avax/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "platform.getRewardUTXOs",
    "params": {
      "txID": "11111111111111111111111111111111LpoYY",
      "encoding": "hex"
    },
    "id": 1
  }'

const response = await fetch('https://flr.nownodes.io/ext/bc/C/avax/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "platform.getRewardUTXOs",
      "params": {
        "txID": "11111111111111111111111111111111LpoYY",
        "encoding": "hex"
      },
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "platform.getRewardUTXOs",
  "params": {
    "txID": "11111111111111111111111111111111LpoYY",
    "encoding": "hex"
  },
  "id": 1
}

response = requests.post('https://flr.nownodes.io/ext/bc/C/avax/', json=payload)
data = response.json()

Request Body

{
  "jsonrpc": "2.0",
  "method": "platform.getRewardUTXOs",
  "params": {
    "txID": "11111111111111111111111111111111LpoYY",
    "encoding": "hex"
  },
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "result": {
    "numFetched": "0",
    "utxos": [],
    "encoding": "hex"
  },
  "id": 1
}

platform.getStake

POST

https://flr.nownodes.io/ext/bc/C/avax/

Body

application/json

jsonrpcstring2.0required

methodstringplatform.getStakerequired

paramsobjectrequired

idinteger | stringrequired

Response

200OK

JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or gateway error

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

platform.getStake

curl -X POST 'https://flr.nownodes.io/ext/bc/C/avax/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "platform.getStake",
    "params": {
      "addresses": [
        "P-flare1exampleaddress"
      ],
      "validatorsOnly": false
    },
    "id": 1
  }'

const response = await fetch('https://flr.nownodes.io/ext/bc/C/avax/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "platform.getStake",
      "params": {
        "addresses": [
          "P-flare1exampleaddress"
        ],
        "validatorsOnly": false
      },
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "platform.getStake",
  "params": {
    "addresses": [
      "P-flare1exampleaddress"
    ],
    "validatorsOnly": False
  },
  "id": 1
}

response = requests.post('https://flr.nownodes.io/ext/bc/C/avax/', json=payload)
data = response.json()

Request Body

{
  "jsonrpc": "2.0",
  "method": "platform.getStake",
  "params": {
    "addresses": [
      "P-flare1exampleaddress"
    ],
    "validatorsOnly": false
  },
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "result": {
    "staked": "0",
    "stakedOutputs": [],
    "encoding": "hex"
  },
  "id": 1
}

platform.getStakingAssetID

POST

https://flr.nownodes.io/ext/bc/C/avax/

Body

application/json

jsonrpcstring2.0required

methodstringplatform.getStakingAssetIDrequired

paramsobjectrequired

idinteger | stringrequired

Response

200OK

JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or gateway error

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

platform.getStakingAssetID

curl -X POST 'https://flr.nownodes.io/ext/bc/C/avax/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "platform.getStakingAssetID",
    "params": {
      "subnetID": "11111111111111111111111111111111LpoYY"
    },
    "id": 1
  }'

const response = await fetch('https://flr.nownodes.io/ext/bc/C/avax/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "platform.getStakingAssetID",
      "params": {
        "subnetID": "11111111111111111111111111111111LpoYY"
      },
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "platform.getStakingAssetID",
  "params": {
    "subnetID": "11111111111111111111111111111111LpoYY"
  },
  "id": 1
}

response = requests.post('https://flr.nownodes.io/ext/bc/C/avax/', json=payload)
data = response.json()

Request Body

{
  "jsonrpc": "2.0",
  "method": "platform.getStakingAssetID",
  "params": {
    "subnetID": "11111111111111111111111111111111LpoYY"
  },
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "result": {
    "assetID": "2q9e4r..."
  },
  "id": 1
}

platform.getSubnets

POST

https://flr.nownodes.io/ext/bc/C/avax/

Body

application/json

jsonrpcstring2.0required

methodstringplatform.getSubnetsrequired

paramsobjectrequired

idinteger | stringrequired

Response

200OK

JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or gateway error

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

platform.getSubnets

curl -X POST 'https://flr.nownodes.io/ext/bc/C/avax/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "platform.getSubnets",
    "params": {
      "ids": []
    },
    "id": 1
  }'

const response = await fetch('https://flr.nownodes.io/ext/bc/C/avax/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "platform.getSubnets",
      "params": {
        "ids": []
      },
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "platform.getSubnets",
  "params": {
    "ids": []
  },
  "id": 1
}

response = requests.post('https://flr.nownodes.io/ext/bc/C/avax/', json=payload)
data = response.json()

Request Body

{
  "jsonrpc": "2.0",
  "method": "platform.getSubnets",
  "params": {
    "ids": []
  },
  "id": 1
}

200

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

platform.getTimestamp

POST

https://flr.nownodes.io/ext/bc/C/avax/

Body

application/json

jsonrpcstring2.0required

methodstringplatform.getTimestamprequired

paramsobjectrequired

idinteger | stringrequired

Response

200OK

JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or gateway error

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

platform.getTimestamp

curl -X POST 'https://flr.nownodes.io/ext/bc/C/avax/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "platform.getTimestamp",
    "params": {},
    "id": 1
  }'

const response = await fetch('https://flr.nownodes.io/ext/bc/C/avax/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "platform.getTimestamp",
      "params": {},
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "platform.getTimestamp",
  "params": {},
  "id": 1
}

response = requests.post('https://flr.nownodes.io/ext/bc/C/avax/', json=payload)
data = response.json()

Request Body

{
  "jsonrpc": "2.0",
  "method": "platform.getTimestamp",
  "params": {},
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "result": {
    "timestamp": "2026-07-31T09:00:00Z"
  },
  "id": 1
}

platform.getTotalStake

POST

https://flr.nownodes.io/ext/bc/C/avax/

Body

application/json

jsonrpcstring2.0required

methodstringplatform.getTotalStakerequired

paramsobjectrequired

idinteger | stringrequired

Response

200OK

JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or gateway error

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

platform.getTotalStake

curl -X POST 'https://flr.nownodes.io/ext/bc/C/avax/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "platform.getTotalStake",
    "params": {
      "subnetID": "11111111111111111111111111111111LpoYY"
    },
    "id": 1
  }'

const response = await fetch('https://flr.nownodes.io/ext/bc/C/avax/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "platform.getTotalStake",
      "params": {
        "subnetID": "11111111111111111111111111111111LpoYY"
      },
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "platform.getTotalStake",
  "params": {
    "subnetID": "11111111111111111111111111111111LpoYY"
  },
  "id": 1
}

response = requests.post('https://flr.nownodes.io/ext/bc/C/avax/', json=payload)
data = response.json()

Request Body

{
  "jsonrpc": "2.0",
  "method": "platform.getTotalStake",
  "params": {
    "subnetID": "11111111111111111111111111111111LpoYY"
  },
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "result": {
    "stake": "1000000000000",
    "weight": "1000000000000"
  },
  "id": 1
}

platform.getTx

POST

https://flr.nownodes.io/ext/bc/C/avax/

Body

application/json

jsonrpcstring2.0required

methodstringplatform.getTxrequired

paramsobjectrequired

idinteger | stringrequired

Response

200OK

JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or gateway error

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

platform.getTx

curl -X POST 'https://flr.nownodes.io/ext/bc/C/avax/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "platform.getTx",
    "params": {
      "txID": "11111111111111111111111111111111LpoYY",
      "encoding": "hex"
    },
    "id": 1
  }'

const response = await fetch('https://flr.nownodes.io/ext/bc/C/avax/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "platform.getTx",
      "params": {
        "txID": "11111111111111111111111111111111LpoYY",
        "encoding": "hex"
      },
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "platform.getTx",
  "params": {
    "txID": "11111111111111111111111111111111LpoYY",
    "encoding": "hex"
  },
  "id": 1
}

response = requests.post('https://flr.nownodes.io/ext/bc/C/avax/', json=payload)
data = response.json()

Request Body

{
  "jsonrpc": "2.0",
  "method": "platform.getTx",
  "params": {
    "txID": "11111111111111111111111111111111LpoYY",
    "encoding": "hex"
  },
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "result": {
    "tx": "0x00",
    "encoding": "hex"
  },
  "id": 1
}

platform.getTxStatus

POST

https://flr.nownodes.io/ext/bc/C/avax/

Body

application/json

jsonrpcstring2.0required

methodstringplatform.getTxStatusrequired

paramsobjectrequired

idinteger | stringrequired

Response

200OK

JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or gateway error

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

platform.getTxStatus

curl -X POST 'https://flr.nownodes.io/ext/bc/C/avax/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "platform.getTxStatus",
    "params": {
      "txID": "11111111111111111111111111111111LpoYY"
    },
    "id": 1
  }'

const response = await fetch('https://flr.nownodes.io/ext/bc/C/avax/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "platform.getTxStatus",
      "params": {
        "txID": "11111111111111111111111111111111LpoYY"
      },
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "platform.getTxStatus",
  "params": {
    "txID": "11111111111111111111111111111111LpoYY"
  },
  "id": 1
}

response = requests.post('https://flr.nownodes.io/ext/bc/C/avax/', json=payload)
data = response.json()

Request Body

{
  "jsonrpc": "2.0",
  "method": "platform.getTxStatus",
  "params": {
    "txID": "11111111111111111111111111111111LpoYY"
  },
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "result": {
    "status": "Committed"
  },
  "id": 1
}

platform.getUTXOs

POST

https://flr.nownodes.io/ext/bc/C/avax/

Body

application/json

jsonrpcstring2.0required

methodstringplatform.getUTXOsrequired

paramsobjectrequired

idinteger | stringrequired

Response

200OK

JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or gateway error

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

platform.getUTXOs

curl -X POST 'https://flr.nownodes.io/ext/bc/C/avax/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "platform.getUTXOs",
    "params": {
      "addresses": [
        "P-flare1exampleaddress"
      ],
      "limit": 1024,
      "sourceChain": "C",
      "encoding": "hex"
    },
    "id": 1
  }'

const response = await fetch('https://flr.nownodes.io/ext/bc/C/avax/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "platform.getUTXOs",
      "params": {
        "addresses": [
          "P-flare1exampleaddress"
        ],
        "limit": 1024,
        "sourceChain": "C",
        "encoding": "hex"
      },
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "platform.getUTXOs",
  "params": {
    "addresses": [
      "P-flare1exampleaddress"
    ],
    "limit": 1024,
    "sourceChain": "C",
    "encoding": "hex"
  },
  "id": 1
}

response = requests.post('https://flr.nownodes.io/ext/bc/C/avax/', json=payload)
data = response.json()

Request Body

{
  "jsonrpc": "2.0",
  "method": "platform.getUTXOs",
  "params": {
    "addresses": [
      "P-flare1exampleaddress"
    ],
    "limit": 1024,
    "sourceChain": "C",
    "encoding": "hex"
  },
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "result": {
    "numFetched": "0",
    "utxos": [],
    "endIndex": {
      "address": "",
      "utxo": ""
    },
    "encoding": "hex"
  },
  "id": 1
}

platform.getValidatorsAt

POST

https://flr.nownodes.io/ext/bc/C/avax/

Body

application/json

jsonrpcstring2.0required

methodstringplatform.getValidatorsAtrequired

paramsobjectrequired

idinteger | stringrequired

Response

200OK

JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or gateway error

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

platform.getValidatorsAt

curl -X POST 'https://flr.nownodes.io/ext/bc/C/avax/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "platform.getValidatorsAt",
    "params": {
      "height": "1",
      "subnetID": "11111111111111111111111111111111LpoYY"
    },
    "id": 1
  }'

const response = await fetch('https://flr.nownodes.io/ext/bc/C/avax/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "platform.getValidatorsAt",
      "params": {
        "height": "1",
        "subnetID": "11111111111111111111111111111111LpoYY"
      },
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "platform.getValidatorsAt",
  "params": {
    "height": "1",
    "subnetID": "11111111111111111111111111111111LpoYY"
  },
  "id": 1
}

response = requests.post('https://flr.nownodes.io/ext/bc/C/avax/', json=payload)
data = response.json()

Request Body

{
  "jsonrpc": "2.0",
  "method": "platform.getValidatorsAt",
  "params": {
    "height": "1",
    "subnetID": "11111111111111111111111111111111LpoYY"
  },
  "id": 1
}

200

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

platform.validatedBy

POST

https://flr.nownodes.io/ext/bc/C/avax/

Body

application/json

jsonrpcstring2.0required

methodstringplatform.validatedByrequired

paramsobjectrequired

idinteger | stringrequired

Response

200OK

JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or gateway error

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

platform.validatedBy

curl -X POST 'https://flr.nownodes.io/ext/bc/C/avax/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "platform.validatedBy",
    "params": {
      "blockchainID": "C"
    },
    "id": 1
  }'

const response = await fetch('https://flr.nownodes.io/ext/bc/C/avax/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "platform.validatedBy",
      "params": {
        "blockchainID": "C"
      },
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "platform.validatedBy",
  "params": {
    "blockchainID": "C"
  },
  "id": 1
}

response = requests.post('https://flr.nownodes.io/ext/bc/C/avax/', json=payload)
data = response.json()

Request Body

{
  "jsonrpc": "2.0",
  "method": "platform.validatedBy",
  "params": {
    "blockchainID": "C"
  },
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "result": {
    "subnetID": "11111111111111111111111111111111LpoYY"
  },
  "id": 1
}

platform.validates

POST

https://flr.nownodes.io/ext/bc/C/avax/

Body

application/json

jsonrpcstring2.0required

methodstringplatform.validatesrequired

paramsobjectrequired

idinteger | stringrequired

Response

200OK

JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or gateway error

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

platform.validates

curl -X POST 'https://flr.nownodes.io/ext/bc/C/avax/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "platform.validates",
    "params": {
      "subnetID": "11111111111111111111111111111111LpoYY"
    },
    "id": 1
  }'

const response = await fetch('https://flr.nownodes.io/ext/bc/C/avax/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "platform.validates",
      "params": {
        "subnetID": "11111111111111111111111111111111LpoYY"
      },
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "platform.validates",
  "params": {
    "subnetID": "11111111111111111111111111111111LpoYY"
  },
  "id": 1
}

response = requests.post('https://flr.nownodes.io/ext/bc/C/avax/', json=payload)
data = response.json()

Request Body

{
  "jsonrpc": "2.0",
  "method": "platform.validates",
  "params": {
    "subnetID": "11111111111111111111111111111111LpoYY"
  },
  "id": 1
}

200

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

Documentation

Authentication

MAINNET / C-Chain / Avalanche-API

C-Chain Avalanche API

Body

Response

Authorization

Body

Response

Authorization

Body

Response

Authorization

MAINNET / C-Chain / EVM

C-Chain EVM

Body

Response

Authorization

Body

Response

Authorization

Body

Response

Authorization

Body

Response

Authorization

Body

Response

Authorization

Body

Response

Authorization

Body

Response

Authorization

Body

Response

Authorization

Body

Response

Authorization

Body

Response

Authorization

Body

Response

Authorization

Body

Response

Authorization

Body

Response

Authorization

Body

Response

Authorization

Body

Response

Authorization

Body

Response

Authorization

Body

Response

Authorization

Body

Response

Authorization

Body

Response

Authorization

Body

Response

Authorization

Body

Response

Authorization

Body

Response